If you’re around testers or reading about testing it won’t be long before someone mentions models. (Probably after context but some time before tacit knowledge.)
As a new tester in particular, you may find yourself asking what they are exactly, these models. It can be daunting when, having asked to see someone else’s model, you are shown a complex flowchart, or a state diagram, or a stack of UML, a multi-coloured mindmap, or a barrage of blocked-out architectural components linked by complex arrangements of arrows with various degrees of dottedness.
But stay strong, my friend, because – while those things and many others can be models and can be useful – models are really just a way of describing a system, typically to aid understanding and often to permit predictions about how the system will behave under given conditions. What’s more, the “system” need not be the entirety of whatever you’re looking at nor all of the attributes of it.
It’s part of the craft of testing to be able to build a model that suits the situation you are in at the time. For some web app, say, you could make a model of a text field, the dialog box it is in, the client application that launched it, the client-server architecture, or the hardware, software and comms stacks that support the client and server.
You can model different bits of the same system at the same time in different ways. And that can be powerful, for example when you realise that your models are inconsistent, because if that’s the case, perhaps the system is inconsistent too …
I’m a simple kind of chap and I like simple models, if I can get away with them. Here’s a bunch of my favourite simple model structures and some simple ideas about when I might try to use them, rendered simply.
You’re looking at some software in which events are triggered by other events. The order of the events is important to the correct functioning of the system. You could try to model this in numerous ways, but a simple way, a foothold, a first approximation, might be to simply draw a horizontal line and mark down the order you think things are happening in.
Well done. There’s your model, of the temporal relationship between events. It’s not sophisticated, but it represents what you think you know. Now test it by interacting with the system. Ah, you found out that you can alter the order. Bingo, your model was wrong, but now you can improve it. Add some additional horizontal lines to show relationships. Boom!
Edit: Synchronicity. On the day I published this post, Alex Kotliarsky published Plotting Ideas which also talks about how simple structures can help to understand, and extend understanding of, a space. The example given is a horizontal line being used to model types of automated testing.
So horizontal lines are great, sure, but let’s not leave the vertical out of it. While horizontal seems reasonably natural for temporal data, vertical fits nicely with stacks. That might be technology stacks, or call sequences, process phases, or something else.
Here’s an example showing how some calls to a web server go through different libraries, and which might be a way in to understanding why some responses conform to HTTP standards and some don’t. (Clue: the ones that don’t are the ones you hacked up yourself.)
Combine your horizontal and vertical and you’ve got a plane on which to plot a couple of variables. Imagine that you’re wondering how responsiveness of your application varies with the number of objects created in its database. You run the experiments and you plot the results.
If you have a couple of different builds you might use different symbols to plot them both on the same chart, effectively increasing its dimensionality. Shape, size, annotations, and more can add additional dimensions.
Now you have your chart you can see where you have data and you can begin to wonder about the behaviour in those areas where you have no data. You can then arrange experiments to fill them, or use your developing understanding of the application to predict them. (And then consider testing your prediction, right?)
Just two lines and a few dots, a biro and a scrap of paper. This is your model, ladies and gentlemen.
A picture is worth a thousand words, they say. A table can hold its own in that company. When confronted with a mass of text describing how similar things behave in different ways under similar conditions I will often reach for a table so that I can compare like with like, and see the whole space in one view. This kind of approach fits well when there are several things that you want to compare in several dimensions.
In this picture, I’m imagining that I’ve taken written reports about the work that was done to test some versions of a piece of software against successive versions of the same specification. As large blocks of text, the comparisons are hard to make. Laid out as a table I have visibility of the data and I have the makings of a model of the test coverage.
The patterns that this exposes might be interesting. Also, the places that there are gaps might be interesting. Sometimes those gaps highlight things that were missed in the description, sometimes they’re disallowed data points, sometimes they were missed in the analysis. And sometimes they point to an error in the labels. Who knows, this time? Well, you will soon. Because you’ve seen that the gaps are there you can go and find out, can’t you?
I could have increased the data density of this table in various ways. I could have put traffic lights in each populated cell to give some idea of the risk highlighted by the testing done, for example. But I didn’t. Because I didn’t need to yet and didn’t think I’d want to and it’d take more time.
Sometimes that’s the right decision and sometimes not. You rarely know for sure. Models themselves, and the act of model building, are part of your exploratory toolkit and subject to the same kinds of cost/value trade-offs as everything else.
A special mention here for Truth tables which I frequently find myself using to model inputs and corresponding outcomes, and which tester isn’t fascinated by those two little blighters?
The simple circle. Once drawn you have a bipartition, two classes. Inside and outside. Which of the users of our system run vi and Emacs? What’s that? Johnny is in both camps? Houston, we have a problem.
This is essentially a two variable model, so why wouldn’t we use a scatter plot? Good question. In this case, to start with I wasn’t so interested in understanding the extent of vi use against Emacs use for a given user base. My starting assumption was that our users are members of one editor religion or another and I want to see who belongs in each set. The circle gives me that. (I also used a circle model for separating work I will do from work I won’t do in Put a Ring on It.)
But it also brings Johnny into the open. The model has exposed my incorrect assumption. If Johnny had happened not to be in my data set, then my model would fit my assumptions and I might happily continue to predict that new users would fall into one of the two camps.
Implicit in that last paragraph are other assumptions, for example that the data is good, and that it is plotted accurately. It’s important to remember that models are not the thing that they model. When you see something that looks unexpected in your model, you will usefully ask yourself these kinds of questions:
- is the system wrong?
- is the data wrong?
- is the model wrong?
- is my interpretation wrong?
The circle’s elder sister. Where the circle makes two sets, the Venn makes arbtrarily many. I used a Venn diagram only this week – the spur for this post, as it happens – to model a collection of text filters whose functionality overlaps. I wanted to understand which filters overlapped with each other. This is where I got to:
In this case I also used the size of the circles as an additional visual aid. I think filter A has more scope than any of the others so I made it much larger. (I also used a kind of Venn diagram model of my testing space in Your Testing is a Joke.)
And now I have something that I can pass on to others on my team – which I did – and perhaps we can treat each of the areas on the diagram as an initial stab at a set of equivalence classes that might serve useful when testing this component.
In this post, I’ve given a small set of model types that I use frequently. I don’t think that any of the examples I’ve given couldn’t be modelled another way and on any given day I might have modelled them other ways. In fact, I will often hop between attempts to model a system using different types as a way to provoke thought, to provide another perspective, to find a way in to the problem I’m looking at.
And having written that last sentence I now see that this blog post is the beginnings of a model of how I use models. But sometimes that’s the way it works too – the model is an emergent property of the investigation and then feeds back into the investigation. It’s all part of the craft.
Image: In Deep Music Archive
Edit: While later seeking some software to draw a more complex version of the Venn Diagram model I found out that what I’ve actually drawn here is an Euler Diagram.