I love reading twitter after I give a talk, because I can review what I said and make sure I agree with it (I never know what will come out of my mouth when I’m on a stage in front of people – it’s part of my presentation style). At TestBash in Philadelphia, I (apparently) said:

“Don’t be afraid to speak up and don’t be afraid to be wrong!!!” @alanpage Great reminder for testers!!! #testbash

— tony g (@tgtigger77) November 11, 2016

 

I said the above at the end of a story where I also referenced Richard Feynman’s story about being afraid to ask a question, asking anyway, and finding a “bug” (in this case, a problem resulting from a stuck valve). If you’re a tester, and haven’t read Feynman, you are really missing out on the stories of a great systems thinker. In this story, Feynman asks a question he is almost too afraid to ask, and the answer is, “… ‘you’re absolutely right, sir.”

In my day job, I have a shallow view of a big and complex product. I review some code, I look at some of the specifications and designs, and I go to some architecture meetings. I know enough to know that I don’t know most things, so I ask questions when I’m confused.

Inevitably (and most recently, just a few weeks ago), I’ll ask a question that makes me look smart despite my lack of knowledge. In this case, I happened to look at a code review, and was curious how the feature and flow worked. I reviewed every line, but it still wasn’t clear how one part of the flow worked. I dug for a while, but all I did was feel dumb about not being able to figure it out. As a last resort, I added a comment to the code saying, “It’s not clear to me exactly how [this flow] works, do you mind swinging by my desk and walking me through it so I understand it better?”

The response in the code review? ‘’”you’re absolutely right – great catch!”

I wouldn’t bother telling the story if this was a one time thing, but it happens all the time. I try to learn, and ask questions when my learning is (or feels) blocked. Most of the time, I merely learn, but sometimes, I inadvertently find something interesting. Either way, if you’re passionate about learning (and every knowledge worker should be), then always ask questions if you need clarification or more understanding – you may just be right.

Way back in 2008 when I wrote chapter three of HWTSAM, I briefly mentioned the HiPPO in the context of ship room (war room) meeting structure:

Everyone’s voice is important. A phrase heard in many war rooms is “Don’t listen to the HiPPO”—where HiPPO is an acronym for highest-paid person’s opinion.

It was a term I came across, but could not find attribution. I discovered fairly recently that Ronny Kohavi (whom I’ve stolen  / borrowed from liberally when discussing A/B testing and experimentation) who came up with the term in 2006.

My old colleague Seth Eliot also discussed the HiPPO in a blog post in a post last year.

While many organizational leaders aspire to become the next Steve Jobs, just about all of them will fail (as an aside, I was in a meeting once where a very senior person said that they made a critical decision, because “it’s what Steve Jobs would do, , and I’m like Steve Jobs”). What I’ve discovered is that no matter how strongly someone feels they “know what’s best for the customer”, without data, they’re almost always wrong.

It can be a big step to use data over organizational rank to make decisions, but if you care about pleasing your customers, the choice is obvious.

I mentioned this at TestBash a few weeks ago (and on a yet-unreleased ABTesting podcast) – and probably on twitter too, but my third “secret” project in a row at Microsoft (following Xbox One and the science project to make Android apps run on Windows Phone) was finally announced to the world on November 2nd.

For the last fifteen months and change, I’ve been in charge of quality for Microsoft Teams. I was originally hired as “the quality guy”, where my job was to coach developers on testing, and ensure we had a strategy in place to deliver a quality product. Along the way, I picked up some infrastructure pieces and now am responsible for taking code from developer check-in all the way through do deployment. I’ve found that owning check-in gates, builds, and deployments (along with quality tools and testing) gives me a lot more confidence in releasing a high quality product to our customers.

It’s also been a great opportunity to catch up on a lot of tech and processes that I’ve wanted to get involved in. We use a lot of open source, and we try to release as frequently as we can (currently weekly, but certainly on the path to continuous deployment). There’s still a lot of work to do on the product, and a lot on my team to ensure we can improve builds, deployment, and quality.

Now that we’re “out there”, I can finally share some stories about things I’ve tried, what’s worked, and what has failed using real examples rather than abstract references. Looking forward to sharing those stories soon.

Short story is that TestBash may be my new favorite testing conference. Great venue (no, fantastic venue), well-organized, and excellent variety and diversity across the different presentations. I was reflecting while walking the streets of Philadelphia this morning and realized that almost every talk was experiential – filled with stories of problem solving and discovery.

For those who know me, let me put it this way. I don’t think I rolled my eyes even once! (except the time when Nancy asked how many of us were context-driven testers).

I also met so many people I’ve only known on twitter (so many, in fact, that I can’t list them), and a large handful of new people I follow now too.

As for my talk, it seemed well received for a talk that (in title) could be scary to a lot of testers. Honestly, I don’t think the talk would have worked as well with a less sophisticated group of testers. It’s really easy to take an idea like testing without testers and look at it with no critical thinking and dismiss it entirely – but folks seemed to get how it could work (and I, of course, was unafraid to talk about how it can fail miserably.

“This is bullshit!” – yeah!! So glad to hear how removing testers sucks. @alanpage #TestBash Philly pic.twitter.com/9TfNHcvAWX

— MelTheTester (@m_eaden) November 11, 2016

I used a ping pong metaphor to describe the inefficiencies in typical test-dev relationships, and I hammed it up a bit figuring if I was going to look stupid, I’d go all in. It went a little  better than I expected, and I owe Angie Jones an apology:

Since @alanpage was up right before I was, I asked him to not pull out his A game. He agreed but then proceeds to play ping pong on stage! ? https://t.co/FsmIF0MyBM

— Angie Jones (@techgirl1908) November 11, 2016

To my credit, Angie – I don’t have an A game. I barely have game, so I just wing it and see what happens. This time, ping pong worked – I was fortunate and lucky.

Overall, a very good experience, and a conference I look forward to attending again someday.

The fine folks at the Ministry of Testing keep promoting my blog posts, so the least I can do is give them a link and a shout out. I’m looking forward to talking about “Testing without Testers” at Test Bash Philadelphia (preview here) and about my role on the team.

This morning, I passively listened to The Bach Bros talk in a webinar about roles and what they mean, as I was curious to get their take. The punch line of the talk was the introduction of “Role grams” – which are shapes that describe who does what, what they’re doing, and who owns it. Nothing earth-shattering, but a workable model.

For the last 14 months, I’ve been a manager on an engineering team responsible for deployment and quality. As I’ve put it before, I am responsible for everything that happens between the time code is checked in (or slightly before, as I also added a few git hooks) to the time it is deployed to our production servers. Given that context, my role is a big blob of stuff. One could say that my “role” is Director of quality and infrastructure, and within that role, I take on activities of tools, engineering productivity, builds, quality, and testing. Certainly, you could say that each of those are roles I take on as part of my job – that model just doesn’t work as well for me. My role – the part I play as an actor on my product team, is one where I need to look at the entire ecosystem of check-in, CI, build, test, and release as one thing. I look at all of that as a system – how quickly and efficiently can I move a developer check-in to something that shows customer value. I have to view the system to know which parts are bottlenecks, and which parts need speeding up, or slowing down in order to increase overall system efficiency.

Here’s a low-tech view of my role. I’m not locked in my box – in fact, since I’m the “quality guy” (label, not role) on my team, I spend most of my time working across the team on improving the testing done by other engineers on the team. I also have a small team of dedicated testers (these people have a testing “role”), who focus almost entirely on exploratory testing driven by trends in customer feedback and areas where I think we need additional breadth coverage in order to reduce risk.

It’s an evolving role, but one I enjoy, and one that I think will become much more common in the coming years.

It’s been a heck of a year.

I joined a new team at MS fourteen months ago, and it’s been the busiest fourteen months of my career. To be fair, I worked more hours during my stint in Xbox One, but the role I’m in now has even more responsibility (more on what that means some other time). Since I haven’t really blogged much since I joined the team, perhaps a recap is in order for context.

I’m working on a yet-unannounced, and possibly-soon-to-be-released product. I was hired as “the quality guy”, but expanded the role over the time I’ve been on the team to take ownership of all of our build and release infrastructure as well. Basically, I’m responsible for everything from the moment code is checked in (including check-in quality gates), until it hits our production servers (at this time, “production” is for beta users only). This includes our CI system, build systems, test infrastructure, deployment, and a bit of manual testing as well. To this end, I’ve ventured back into management, and manage a small handful of full time employees, as well as a larger handful of temporary (vendor) testers. I’m responsible for making sure we have systems and strategies that enable us to get a good product to our customers frequently. I make sure the code is ready, and that the product is well-tested. It’s also my call on whether – and when to push bits to our production environment. It’s a killer job, but one deep in my wheelhouse. I’ve grown in many ways over the last year, and learned even more.

But it’s taken away a bit of who I am. I don’t write much anymore. I speak much less than I used to, and I’ve all but disappeared from twitter (one plus is that I’ve been really happy with the AB podcasts that Brent and I have been delivering). While part of me is growing and learning, another part of me is withering and dying.

So I need to make a change. Not necessarily a change as big as changing jobs or changing companies, but I need to remember that my job is just a job, and it’s not who I am. Like a lot of people, I lose sight of that sometimes, and I need to see if I can get myself back on track – and start by (re) connecting with the community that inspires me and drives me to do even better things.

I remain excited about the product I’m working on, and the team I work with – but perhaps more excited about speaking at Test Bash, getting back to talking with old friends on Twitter, knocking the dust off angryweasel.com, and sharing a bit more with my friends.

Here’s to re-engaging.

Chris McMahon, who has always impressed me with his words and his wit called me out in his blog.

Specifically:

Apropos of my criticism of “Context Driven Approach to Automation in Testing” (I reviewed version 1.04), I ask you to join me in condemning publicly both the tone and the substance of that paper.

Almost exactly a year ago, I reviewed a draft of the paper, and my name is among those listed as reviewing the paper. The feedback I gave was largely editorial (typos and flow), with a few comments about approach that I’ll repeat here:

The first red flag I called out (and will call out again here) is the phrase that describes test automation as something to “automate testing by automating the user”. This is a shallow view of test automation, but other than comment, I didn’t push hard on it. In hindsight, this was a mistake (much of The A Word touches on this topic).

In regards to the scenario the authors chose for scenario automation, I thought the choice was weird, and asked for more…context and provided some food for thought.

I think you can add even more emphasis to how and why you chose to automate scene creation. Too many times, testers choose to automate because they can automate. The thought process (for me) may be, “The scene feature is pretty important, I’m curious what happens if an author has thousands of scenes. Will it cause performance problems, formatting problems, file load problems, or other issues, etc. There’s no way in hell I want to do this manually, so let me write some code to help me run my experiment”.  You may also want to discuss alternate implementation ideas – e.g. creating a macro in Notepad++ to create the text then paste it in, or creating a macro in Word for the same, or using for in a windows console (e.g. for /L %f in (1,1,1000) do echo “##”>>output.txt&echo “Scene %f”>>output.txt ). Using tools for creating and manipulating data could be a whole article.

And that led to my real beef with the paper. It talks about using tools to test – which can be a good thing, but it doesn’t really talk about automation in the way successful teams actually use it.

I think it may be important to talk about purposes of automation and where to apply it – or at least one context of that – as I don’t think that’s discussed enough (but I’ve made a note to myself to write a blog on this very subject). At a BFC (big company) like Microsoft, we write a lot of shared / distributed automation – automated tests that we need to run on a lot of different hardware/platform configurations in some sort of lab setting (tools like SauceLabs or BrowserStack are helpful here). Web apps are famous for this [problem].

I also commented:

The other kind of automation (which you cover in your article) is what I sometimes call exploratory automation (or more often, just “Testing”). This is where we get a test idea, and want to write some quick automation to help learn about the product. While we may turn this sort of test into something that’s distributed / shared someday, its primary purpose is to help me answer questions and learn. There’s (another) story in HWTSAM where I described a case of this. I wrote really ugly brute force automation in C (using things like FindWindow and SendMessage(LBUTTON_DOWN…) to simulate opening and closing a connection to a remote host many times (the only thing this app did). It found a nice memory leak that may not have been found otherwise (or at least not as quickly).

All of this feedback fed my uber-point, which was that while the article talked about test automation, the examples really just talked about using somewhat random tools to help the authors explore or test some software. There was nothing about strategy, or about more typical use of test automation. I asked about it in a comment:

I wonder why you don’t use the word “Tools” in the title – e.g. “A CDT approach to tools and automation in testing” or something like that.

…because the paper is about, as I said above, using non-standard tools to help test. Sure, it’s automation in a sense, but nothing in the paper reflects the way test automation is used successfully in thousands of successful products.

All that said, I do not support this paper as a description of good test automation, and I think it’s an inappropriate method for anyone to learn about how to write automation. Chris requested that the authors remove the paper; while I support this, and do believe that the paper can cause more harm than good, there’s so much bad advice on the internet about creating software, that removing this one piece of bad advice will hardly make a dent.

I did not realize my name was listed as a reviewer, and although I did (as admitted above) review this paper, I do not want my name associated with it, and will request that the authors remove my name.

There’s a light at the end of the oh-my-work-is-so-crazy train, and I look forward to ranting more often both here and on twitter.

But first, a few minor anniversaries to acknowledge. Monday was my 21-year anniversary at Microsoft. It’s not a nice even number like 20, but it’s weird to think that people born on the day I started (full-time) at Microsoft, can now drink in the U.S. While I doubt I’ll make it to 25, I doubted that I’d make it to 20…or 10, so this is definitely an area where I’m bad at estimating.

Meanwhile, the ABTesting Podcast just hit episode #40. That’s another milestone I never thought I’d hit, but Brent and I keep finding things to talk about (or new ways to talk about the same things). We should hit the 50-episode milestone (by my already established as poor estimates) before the end of the calendar year. I’m thinking of inviting Satya to be a guest, but I don’t think he’ll show up.

 On the announcement front, I’m speaking at Test Bash Philadelphia in November. I’ll be talking about “Testing without Testers and other stupid ideas that sometimes work”. This is an evolution of a talk I’ve been giving recently, but I’m preparing something extra special for test bash that should inspire, as well as cause some great conversations to happen.

I’m at no loss for blog material, but have been short on time (that’s not going to change, so I’ll need to tweak priorities). But…I wanted to write something a bit different  from normal in case anyone else ever needs to solve this specific problem (or if anyone else knows that this problem already has an even better solution).

Our team uses a tool called Istanbul to measure code coverage. It generates a report that looks sort of like this (minus the privacy scribbling).

For those who don’t know me, I feel compelled to once again share that I think Code Coverage is a wonderful tool, but a horrible metric. Driving coverage numbers up purely for the sake of getting a higher number is idiotic and irresponsible. However, the value of discovering untested and unreachable code is invaluable, and dismissing the tool entirely can be worse than using the measurements incorrectly.

The Missing Piece

Istanbul shows all up coverage for our web app (about 600 files in 300 or so directories). What I wanted to do, was to break down coverage by feature team as well. The “elegant” solution would be to create a map of files to features, then add code to the Istanbul reporter to add the feature team to each file / directory, and then modify the table output to include the ability to filter by team (or create separate reports by team).

I don’t have time for the elegant solution (but here’s where someone can tell me if it already exists).

The (or “My”) Solution

This seems like a job for Excel, so first, I looked to see if Istanbul had CSV as a reporter format (it doesn’t). It does, however output json and xml, so I figured a quick and dirty solution was possible.

The first thing I did was assign a team owner to each code directory. I pulled the list of directories from the Istanbul report (I copied from the html, but I could have pulled from the xml as well), and then used excel to create a CSV file with file and owner. I could figure out a team owner for over 90% of the files from the name (thanks to reasonable naming conventions!), and I used git log to discover the rest. I ended up with a format that looked like this:

app.command-foo,SomeTeam
app.components.a,SomeTeam
app.components.b,AnotherTeam
app.components.c,SomeTeam
app.components.d,SomeOtherTeam

Then it was a matter of parsing the coverage xml created by Istanbul and making a new CSV with the data I cared about (directory, coverage percentage, statements, and statements hit). The latter two are critical, because I would need to recalculate coverage per team.

There was a time (like my first 20+ years in software) where a batch file was my answer for almost anything, but lately – and especially in this case – a bit of powershell was the right tool for the job.

The pseudo code was pretty much:

• Load the xml file into a PS object
• Walk the xml nodes to get the coverage data for a node
• Load a map file from a csv
• Use the map and node information to create a new csv

Hacky, yet effective.

I posted the whole script on github here.

I was thinking about this on the way to work today, and thought I’d try to spit out a quick blog post before I got side-tracked again.

I’ve been very fortunate to have had success with organizational change with teams at Microsoft. Whether it’s getting programmers to run integration tests before check-in, or helping a team get to a daily zero-bug bar, my leadership style is the same. I believe that people will do things that they think are valuable. In fact, this quote from Eisenhower (which is, admittedly, overused) aligns tightly with my style.

Leadership is the art of getting someone else to do something you want done because [s]he wants to do it.

I talk with people to understand what their concerns and motivations are. I communicate plans and strategies to the team. Often, I “plant seeds” – for example, I may mention to a manager a few of the benefits of keeping engineering debt low and give a few examples. No judgement or decree – just an idea to put in their head. Later, I may mention that it would may be a good idea to keep pri 1 bug counts at zero, and maybe overall bugs below some arbitrary number. Often, a few weeks later, I’ll see that manager’s team with zero pri 1 bugs. Or, I’ll mention in a meeting that I’d like to get the whole team down to zero bugs, and I generally have support from everywhere I planted a seed.

The big advantage of this style of change management (in my experience) is that the team owns the change, and accept it as part of the way they work. The disadvantage, is that it takes time. To me, that time investment is worth it.

There’s a faster approach, but I don’t like it – yet I see it used often. It probably has a better name, but I’ll call it the do-it-because-I-said-so style of leadership. Eisenhower also said that leadership doesn’t come from barking orders or insisting on action (paraphrase because I’m too lazy to look it up). To me, leadership isn’t about your ideas, it’s about working with others and building your tribe. Too many so-called leaders think that leadership is being the loudest voice, or being the one that makes mandates to an organization. That’s not leadership to me. That’s being a dick.

That said, there’s a middle ground there, that I see often enough to respect, but not often enough to completely understand. I know some leaders who are able to make explicit mandates and have their team rally around them immediately. They don’t do this often, and I think it helps. They are humble and I think this helps. They have a relationship with their followers – and this helps too. Maybe the answer is that they’ve waited until they’re a real leader (rather than a self-proclaimed chest-thumper), and waited until circumstances were necessary before making a mandate.

What kind of leader do you want to be?