Flicking through a blog the other day, I was impressed by the author's insight, the breadth of material, his interest in the semantics, theory and practice of testing. I chuckled at the sense of humour and I adored the modesty and humility he displayed.

And then I noticed that of the seven images I could see on the blog's front page three (1, 2, 3) were record sleeves.

I was distracted by this, my train of thought moving away from the content and onto the relevance of my observation and speculation about the author's interests: is it significant that there are so many record sleeves here? Will I have a look at the archives to see what images were used there? Is this chap a record collector? Are these records personal favourites? Why is he using images on every post, anyway? What value do they add? What was this blog about, again?

And then I remembered that it was my blog and that I had started off scanning for typos.

The signal I was giving out, from an aggregation of discrete decisions taken over time, was not one that I had intended but was one that revealed (or at least gave an observer cause to suspect it revealed) something about me and my interests, priorities, decision-making.

In software development we're constantly making discrete decisions - should we aim to put that feature in in this cycle? Can we get away without that widget? Will we have time to fix that bug and test it? Could we risk changing the format of this file given the benefits it would enable? Is it time to refresh the interface?  These will generally be taken with good intent for the issue at hand but they can still add up into something unintended that users notice, that takes them away from the task they're trying to perform, that they will use to form an opinion about us and the way we operate. Be sure to step back and look for the patterns from time to time.

And then I wrote a new post. With an image that can't be misinterpreted. Probably.
Image: http://flic.kr/p/ZRBo

I messed up this week. And the week before. And the week before that, the one prior, most weeks last month, most months this year, most weeks in most months most years ... Basically all the time. And I do it on purpose because it puts me in a position to find bugs that I wouldn't otherwise come across.

I'm not talking about deliberately entering junk content into applications, configurations, data and the like. I'm not talking about random clicking in a system under test or trying to engineer corner cases by artificially restricting disk space or RAM or some other resource or any other of those legitimate test vectors that benefit from experimenting with the available parameters.

I'm talking about sympathetic testing - or even just plain usage - in an untidy way to try to increase my test coverage in passing. Here's some examples:

• If your application is in the cloud, maybe don't log out of it when you've finished your current task. Look for odd effects next time, perhaps after you've moved between networks or not accessed the system for a few days.
• If you start an application daemon or service at the console, don't close it immediately, but leave the console open while the system runs. Check in on it now and again as you move between tasks and look for exceptions, unexpected errors and so on.
• If you have an instance of your application open already and want to try something, sometimes don't use the open instance but open another and watch for effects due to cross-contamination.
• At the end of  a session, don't close down cleanly. Instead, leave the application in the middle of an interaction - with a dialog open, say - and see what happens when you come back to it.
• If you're testing a web-based application don't always use the same bookmark to get there. Use your browser history, or type into the URL bar and get some old URL from your history or paste a URL from an old email to find a new starting point and see what the server does with it.

This can be extremely productive and has the side-benefit of forcing you into a state of mind where you're alert to issues from the moment you begin your task. You should be looking to automatically log wherever and whatever is possible, record exceptions and other error trace immediately you see it, take screenshots of anything you think might be unexpected behaviour and so on because one of the consequences of this approach is that reproduction steps can be harder to obtain and the evidence can help you to return to the bad state later.

People talk about setup, test, teardown sequences and in some cases that's exactly what's required. You may need to understand your starting context as precisely as possible so that when running a sequence of test ideas you can return to that context each time. But your users won't be running inside a sterile laboratory, so make sure you don't always do that either.
Image: http://flic.kr/p/9RnnTK

Since reading the last issue of The Testing Planet on leadership I seem to have come across more blogs than usual talking about how to be a great leader, manager, boss or whatever, for instance:

• Evaluate Character AND Performance
• 9 Leadership Tips Anyone Can Use Immediately
• 10 Things Really Amazing Bosses Do
• This is why you need to learn how to talk to developers

I'm interested in improving as a manager, leader, boss and (especially) whatever and this kind of material can provide inspiration. I'm also keen on personal reflection and introspection as a way of identifying areas to work on and over the years I've come to realise that a couple of principles trump most other things for me:

• clear: I will do my best to be absolutely clear about what I think, what my response to any request is, what my motivation for any particular approach is, what I will commit to do (or not do) about some problem and so on. I will encourage and answer any question on any work-related topic to the fullest extent that I can given obvious constraints such as confidentiality.
• present: I will do my best to be approachable, available and responsive. If I can't be responsive I'll try to explain why and give a commitment to respond at some later time.

With these in place, and applied appropriately, I like to think that whatever techniques, approaches or methodologies  that we're using or experimenting with will be well-grounded and, although they apply primarily to how I want to interact with my teams, I try to abide by them when working with any of my colleagues.
Image: http://www.last.fm

Rands recently wrote a great blog post on the way that companies project unrealistic expectations onto new employees, are disappointed when they don't achieve them and then then come to know the new hire further down the line. This trajectory is a familiar one and applies not just to employees but also to many aspects of software development including whole products and features within an application.

When a feature description is still relatively broad, unexplored and underdeveloped it will naturally be understood in a variety of ways by different people. Equally naturally, the ways in which it is understood and the depth of the understanding will correspond largely to the particular interests of those people. The sharp end of those interests tend to be in issues that the idea can resolve and the feature can often look like Lilly the Pink with respect to them. High-level apparent solutions to high-value problems inflate the attraction of the feature.

As the feature moves into implementation a host of reality factors begin to apply and the space of possibilities must naturally collapse into a particular configuration. This, for an implementation of any complexity, inevitably means that some irritations will not be soothed by the solution. Errors in the implementation, lateness in delivery, downstream consequences and other emerging character traits will give even the most ardent admirers cause to review the level of their affection.

Ultimately the feature makes it into production and with luck retains the kernel of what was appealing back when it was a cloud of wispy fluff that looked like it could turn defects into dollars. This phase, often, is when the true personality of the feature is revealed. Some people will find that they can be friends with it after all, some will move on to the next good-looking thing and some will be lucky and have found true happiness.

And the testers? They should enjoy a strictly platonic relationship with these things, do their best to understand them for what they are at every stage, be a sounding board for hopes, a go-between for messages of endearment and a shoulder for their for their colleagues to cry on. (All the while taking notes for the next time the cycle kicks off.)
Image: http://flic.kr/p/9jYipe

I had more or less the same conversation with  Michael Bolton and Pradeep Soundararajan recently and both started with a statement about tool use and automation:

Pradeep:

@testertested: I help testers re-think what they mean by automation. I help them see usage of any tool as automation
@qahiccupps: any tool? A pen and paper is a testing tool..
@testertested: Yes, it does help you make notes, that you refer to for re-exploring the app. Do you see it that way?
@qahiccupps: Yes, a tool but not automation which, for me, requires action w/o my participation. Another: I can use Excel manually (enter formula into every cell) or automated (macros). Tool != automation.
@testertested: So, what about annotation pens and stuff ?
@qahiccupps: Used directly it's manual. Without me (directly) controlling, automation. Not sure if we're missing each other's point?Michael:

@michaelbolton: Test automation is any use of tools to support testing.
@qahiccupps: pen and paper are tools that I use in testing. Can we regard their use as automation? If so, how?
@michaelbolton: Good question. In general, we refer to electronic machinery, of course. However, consider this aspect of all tools: "We shape (and choose) our tools; thereafter they shape (or choose) us."  McLuhan (with my parentheticals)
@qahiccupps: Agree w/that. But I'd hesitate to call anything that doesn't perform actions independently automation. tool !=automation. I can fill every cell in an Excel sheet by typing into them by hand, or I can write a macro.
@michaelbolton: Using Excel itself, however, is a fabulous example of test automation in the sense of any use of tools to support testing.
@qahiccupps: If I only write notes into Excel it's just like pen and paper. The use I make of the tool is key to whether it's automationMichael has talked about this before in, for example, on a blog on automation in ET:
Some people might have a problem with the idea [that exploratory testing can include automation], because of a parsimonious view of what test automation is, or does. To some, test automation is getting the machine to perform the test. I call that checking. I prefer to think of test automation in terms of what we say in the Rapid Software Testing course: test automation is any use of tools to support testing.The copula verb, for all its slightness, makes strong assertions. In this case: if you use any tool while testing you have performed test automation. But what does the term mean? The Oxford University Press dictionary says this:

• Tool: a thing used to help perform a job  
• Automatic: working by itself with little or no direct human control  
• Automation: the use or introduction of automatic equipment in a manufacturing or other process  

An anecdote from the same blog post describes some places where automation could be part of exploratory work:
[One colleague] got curious about something that he saw [in a program's behaviour]. Curiosity can't be automated. He decided to generate some test values to refine what he had discovered in earlier exploration. Sapient decisions can't be automated. He used Excel, which is a powerful test automation tool, when you use it to support testing. He invented a couple of formulas. Invention can't be automated. The formulas allowed Excel to generate a great big table. The actual generation of the data can be automated. I don't disagree with any of the assessment and I strongly agree that automation can be used to drive analysis and discovery, amongst other things. I disagree with the claim that (all) tool use is automation.

Tools need not exist at all in the tangible world. Shorthand is a tool, for example. Its utility relies on it being realised in some form by some other tool, say a stenotype or a nail dipped in blood. Although we might argue about whether these secondary tools are or can be automated, can the use of an ephemeral tool like shorthand itself be regarded as automation when the tool itself only exists inside the user's head?

Perhaps that's too obscure. Let's look at something more traditionally called a tool. I'm in the garden and I want to dig a hole. I have a spade but that tool isn't going to dig the hole by itself. It's unlikely that anyone would regard me digging the hole with the spade as garden automation. There's certainly a tool and there's certainly an efficiency to using it over my bare hands, but digging the hole is still manual labour.

In the Twitter thread above Michael said he was thinking of electronic machinery, presumably more generally as something that at least has the potential to operate independently. So let's think about a more sophisticated tool, one where the user does not directly manipulate every operation, but instead controls them by some higher level process. How about a car? It takes around two hours to drive my car to my mum's house. In that time many things happen without my explicit direction - the engine runs through its cycle thousands of times; shock absorbers compress and stretch to smooth out the ride; computers monitor various metrics such as oil level and temperature and report them to my dashboard. And some things happen with my direction but without my knowing exactly what physical actions are performed - I turn the wheel and I think there's probably some kind of rack-and-pinion technology implementing my request, but I don't know the details.

Is driving the car travel automation? Not for me, not by the definitions above. Although much in a car happens independently - to some level of granularity - I cannot leave the car unattended and expect it to get me to my mum's house.  Ah yes, but Google notoriously has a driverless car, you say. Yes, and there are functionalities that I would regard as automation in some of today's vehicles too: assisted parallel parking, for example. But even though Google's car can function in an automated fashion, if I got into it and drove it myself that would not be automation.

Tools, used appropriately, are capable of delivering advantages in areas such as reporting, visibility,  scalability, scope, quality and quantity of data, communications, coverage, checking and numerous other things that are valuable to a tester. Automation requires tools. Some tools can provide automation. Not every use of such a tool is automation.

Michael was kind enough to read a draft of this post and commented:
We sometimes make provocative statements to get people to question their beliefs. "Any use of tools to support testing" is an encouragement to think expansively.  (McLuhan again, on his students: "I don't want them to agree with me.  I just want them to think.") People who respond to this provocative statement typically apply emphasis to the "tool" part.  What I'm more interested in is the "any use" part. The intention here is to stop thinking of the role of tools exclusively in terms of automated checks, and start thinking of test automation as "any use of (automated) tools to support testing".  In fact, James Bach and I are trying to avoid "automated testing" altogether, and say what we mean: machine checking, and tool-supported testing.  For me, the strength of test automation is any use of tools to support testing, memorable and provocative as it is, is reduced by distractions around tools and their capacity for automation. I prefer this alternative: test automation is not automated testing.
Image: http://flic.kr/p/5GfNfo