Dan Ashby recently posted his views regarding a model for test strategies and heuristics. I really like the level of effort put into it, particularly because it was clearly distilled not just from thought but thought based on experience. Let’s talk about this.
I see so many people lately talking about the “death of manual testing.” Opinions obviously polarize on this but what I don’t see is testers engaging at all with why this perception is there. There is a form of indoctrination that happens across the industry. And testers, by and large, do nothing to combat it. Largely because they ignore where it’s coming from. Let’s talk about this a bit.
This is the last of a four part series (see parts 1, 2 and 3). The goal has been investigating whether specialist testers have a role in machine learning environments uniquely distinct from development roles in those same environments. These posts have been getting you up to speed on what that might look like. Here we finish off that journey.
This post continues on directly from the first and second parts. I covered a lot of material in those posts so I can’t easily recap it here so definitely read those before reading this one. Here we’ll dig more into how a tester actually tests in this context but also look at testing as a framing activity.
This post continues on directly from the first one in the series. We’ll take the CartPole example we started with and continue our journey into how testing — particularly that done by a specialist tester — intersects with the domains of data science and machine learning.
As a tester are you ready to work in environments that are based in or around data science and machine learning? What will you actually do in these environments? How will you interact with developers? How technical do you have to be? Is it all just automated testing? Or do we still have room for a human in there somewhere? Let’s dig into this a little bit by going through a scenario.
In a series of posts, I’ve talked about my Tapestry micro-framework and I tried to provide some of the rationale for its design choices. Providing that rationale meant providing a context for you to see it in action. This post will cap off the previous posts by digging into the code of Tapestry a bit and showing you how it works. I hope this is more relevant given that you’ve now seen it in action.
In the previous post I talked about communication patterns in terms of the micro-framework and tests. Here I’ll talk about the expressiveness of the tests themselves, showing how Tapestry supports the idea of a context.
In my last post on micro-frameworks, I got into the organizing principles of my Tapestry solution, by which the framework provides or supports a mechanism for the encapslation of and delegation to logic. Here I’m going to continue on that theme but with a focus on showing how the framework calls into the tests, rather than the reverse, and why I think this is a good design approach.
This is a continuation of my exploration into providing insight into micro-framework creation for automation, using my own Tapestry tool by way of example. The first post set the context and the second post focused on exposing an API. Here we’ll dig into exposing the organizing principle.
Here I’ll continue on with the introduction of my Tapestry micro-framework that I started in the first post. This time I’ll focus on a bit on how you want to create an API interface for your micro-framework.
Here I want to talk a little about test automation framework construction. Or, rather, micro-framework construction. I will use my own tool, called Tapestry, for this purpose. Tapestry is written in Ruby but what I talk about is potentially transferrable to your language of choice.
This post continues on from the first part where I went over the high-level details of a tester getting involved in a machine learning context. I left off just at the point of introducing the algorithm and letting us get to work. So here, in this post, we’re going to dig right in.
I’ve talked before about the intersection of testing and AI as well as provided a series of posts, using a Pac-Man clone to further introduce testers into algorithmic searching. Here I’ll consider a really simple example of engaging with a machine learning example. I’ll focus on reinforcement learning, which often isn’t talked about as much.