Why Unity?

A lot of people, both co-workers and not, have asked me why I “chose” Unity for my post-Microsoft career. Although I documented (sort of) why I broke up with Microsoft, and talked in a few other places about my role, I guess I haven’t publicly shared why I’m at Unity (vs any other tech company).

I had musings about leaving Microsoft for quite a while. In fact, I composed a version of my breakup blog post in my head as far back as 2010 when I almost took a role at another large tech company. It may be worth sharing that I almost accepted roles at several other companies over the years, and halfway pursued several others as well.

So, why Unity and why not any of those other companies?

The short answer is that I’m picky, and that Unity is my unicorn.

I wanted a role that was both challenging and where I could leverage my experience. I wanted to work in services (or, at the very least, in an Agile environment). I didn’t want to move, and I didn’t want to travel too much. I wanted to work on a product with avid and vocal customers.

Then along came Unity – a second time, actually, as I first talked with my current manager about Unity over a year ago. The role at the time, wasn’t quite right for my strict requirements, but when we restarted our conversation a few months ago, Unity felt a lot more like a good fit. I met with a few people (all people I now work with almost every day). I liked them, and they liked me. After a few short conversations with HR to get the financial side in order, and after a few longer conversations with my family about the  move, I accepted the offer.

As soon as I made the decision, I knew it was the right one. I’ve had zero regrets, and every day I feel better about the move. So much to do, but so excited to do it.

That’s why.

Forty days in

Calendar math says I’m a few hours into the 39th day since I started at Unity. I’m still well within the honeymoon window, but my optimism and excitement about working here continue to grow. It’s just a pretty damn cool place to work.

I’ve met most of my team face to face, and will spend more time with team members in Copenhagen and Helsinki next week. I still have half a dozen people in Austin and Montreal whom I will track down and meet in person sometime before I hit my hundredth day. I’ve spent a lot of time learning about Unity (I made a simple game), and a bigger chunk of time learning how Unity services work – and more importantly how they’re built, deployed, and tested.

I’ve also spent a lot of time thinking about my role – or in general, the role of a manager of a team of “embedded” testers. Organizationally, I’m the Quality Director for all Unity services – but everyone on my team is an integrated member of a feature team (for the record, one minor complaint I have with the phrase “embedded tester” is that it can sound like a foreign body inserted into a functioning team rather than a test and quality specializing generalist who is an equal member of a feature team).  I’ve embraced the words of Steve Denning in The Leader’s Guide to Radical Managementand provide a framework for the team – and then get out of their way (quote likely plagiarized, but I can’t recommend Denning’s work enough, so take the time to read it yourself).

In a search to find the exact quote (I have a hard copy of the book…but at home…), I wasn’t surprised to see that I’ve heaped praise on Denning before and expanded on the phrase above.

Give your organization a framework they understand, and then get out of their way. Give them some guidelines and expectations, but then let them work. Check in when you need to, but get out of the way. Your job in 21st century management is to coach, mentor, and orchestrate the team for maximum efficiency – not to monitor them continuously or create meaningless work. This is a tough change for a lot of managers – but it’s necessary – both for the success of the workers and for the sanity of managers. Engineering teams need the flexibility (and encouragement) to self-organize when needed, innovate as necessary, and be free from micro-management.

Given that my team is globally distributed, working on a large number of feature areas, and are highly skilled and motivated, any approach within five-hundred miles of anything resembling micro-management would be silly. My role will include helping the team balance priorities; to facilitate learning, collaboration and community; coaching; communication; and, of course, a bit of management administrivia (budgets, approvals, planning, etc.).

I’ve been taking some notes on some of the biggest differences I’ve noticed (culture, practice, tools) between my job for the past 40 days, and my job for the previous ~8000 days. Someday soon, I’ll dedicate an entire post to these observations.

While talking with a dev lead earlier this week, I told him I felt like I was on the edge of almost being briefly effective. I’ll try to keep heading in that direction and post the victories (and setbacks) here as they happen.

Oh the tests I’ll run

Last week, Katrina Clokie (@katrina_tester) asked this question on twitter:


I gave a few abbreviated answers based on my experience, and promised to write up a bit more, as this is something I’ve played with quite a bit before. I sort of meant to copy and paste an email I sent to an internal team (at msft) a few months back, but alas – I don’t have access to that email anymore :}

Why select tests?

A lot of people will ask, “If I can run every test we ever wrote in five minutes, why does this matter?” If this is the case, of course it doesn’t matter. I’m all for parallelization and leveraging things like selenium grid to run a massive number of tests at the same time; but it’s not always possible. On the Xbox team, for example, we had a limited (although large) number of systems we could use for testing, so test selection / prioritization / ordering was something we had to do.

Basics of Test Selection

OK – so you’ve decided you have need to select the tests most likely to fail to run first. Easy(ish) – just run the tests that exercise all the code that changed!

This is quite a bit easier than it sounds – that is if you’re already using code coverage tools. Now is a good time to remind you that code coverage is a wonderful tool, but a horrible metric. Test selection benefits from the former part of that statement. For every automated test in your suite, periodically collect the coverage information just for that test, and save it somewhere (I suggest a database, but you can shove it in json or excel if you feel the need). Now, you know exactly which lines, functions, or blocks (depending on your coverage tool) are hit by each test.

The slightly harder part may be to figure out which lines of code have changed (or have been added, or removed) since the last time the tests were ran (which may be the last check-in, the last day, or longer). I can leave it as an exercise to map source control information to the same database / json / excel as mentioned above, but once you have this key/map pair, test selection is just picking the tests that hit changed lines.

But there are a lot of caveats with this approach. If you’re changing a low level component, every test will hit it (as an example, I used this approach many years ago on a test system that communicated with external devices over winsock. Every change to winsock told us that we needed to run every test. While probably a correct approach, it didn’t really help with prioritization. You’ll also find that often enough, there aren’t any tests to cover the changed code – and I’ll let you figure out what to do when you have tests that hit code that was removed (hint: maybe run the test once anyway to make sure it fails).


What I’ve found, is that coverage is a good start – and may be enough for most teams (among teams who can’t run all of their tests quickly on every build). But adding some other selection factors (or heuristics) and applying some weights can take you a bit farther.

Some heuristics I’ve used in the past for test prioritization / selection include:

  • Has the test found a bug before? Some tests are good at finding product bugs. I give these tests more weight.
  • When was the last time the test ran? If a test has run every day for a year and never failed, I don’t give it much weight. We testers are always paranoid that the moment we choose not to run a test that a regression will appear. This weighted heuristic helps combat the conundrum of running the test that never fails vs. fear of missing the regression
  • How flaky is the test? If you never have flaky tests, skip this one. For everyone else, it makes sense to run my tests that return false positives less often (or at the end of the test pass)
  • How long does the test take? I put more weight on tests that run faster.

Then I give each of these a weight. You can give each a whole number (e.g. 1-5, or 1-10), a decimal value, or whatever. Then, do some math to turn the full set of weights into a value, and then sort tests by value. Voila – my tests are prioritized. As you run the tests and learn more, you can tweak the numbers.

You can add more test meta-data as needed, but the above is a minimum. For example, with just the above, you could run something like:

run the most important tests that will complete in under 15 minutes

Using whatever command line arguments would support the statement above, you can limit the test run based on test time (and optionally add even more weight to tests that run quickly).

Probably a lot more nuance here, but the concept of test selection is probably something any tester working with automation should know a bit about.

Just in case.

The New World

I mentioned on twitter that Barack Obama and I both left our old jobs on the same day. The world has been a very different place for both of us since then.

Twitter is full of politics – and I’m completely ok with that, and happy to join in with my own opinions and thoughts. I’ve marched, I’ve protested, and I’ve done a lot of learning (and re-learning) about civics, politics, and done what I can to become as educated as possible.

Meanwhile, I have a new job, and a lot to learn about a new company, code, practices, people, and culture. I absolutely love it so far, and I know I’m only scratching the surface of what there is to learn. I’ve asked a lot of questions (even a few that actually seemed smart), but I’m still at the stage where everything I discover unveils three more things I need to learn.

In eight days at the company, I’ve spent two days in San Francisco (where we’re hiring testers for my team in Ads and Analytics – ping me for more info), and two days in San Diego (where I crashed a hack week to meet more people from my team). Combine that with the work-at-home-snow-day that was Monday, and tomorrow will be just my fourth day at my desk (but I think I’m in a non-traveling state for at least another week).

My new team is spread across offices in Bellevue, Austin, Helsinki, Odessa, Copenhagen, and Montreal. I’ve been to half of those cities before, and look forward to visiting folks in the others (odds are that Helsinki is up next).

Too early to share Unity testing stories, but I’m sure those (or stories inspired by Unity) will be on the blog soon. Until then, wish me luck on trying to get a reasonable drink of water from the current firehose of learning.


For those of you who missed it on Twitter or in the AB Testing Podcast, my unemployment lasted (as planned) just a bit over week. On January 30, I started work at Unity, heading up quality for their various services.


I spent most of last week trying to learn as much as I can and trying to meet  and get to know as many people as I can. I expect the next few weeks will be similar.

I’m massively excited to join Unity, and know I’m going to learn a lot. It’s different than the big M, but so refreshing in so many ways.

More updates here, as they happen.



The Breakup

This one goes out to the one I love. This one goes out to the one I left behind

Relationships are both challenging and rewarding. As adults, we’ve all gone through dozens of relationships – some short, some long, some very long. They all have their ups and downs; their ebbs and flows; and their joy and pain. This is an open letter reflecting on the longest relationship I’ve ever had.

It’s been over 20 years (22, actually) since we first crossed paths. In the early days, I was so excited to be with you. I knew of you, of course, long before our paths crossed –  but couldn’t believe we were together – you were completely out of my league. There was no reason someone like you and someone like should have been together. But it worked – for both of us. I think it worked better than either of us thought it would. For many reasons you brought out the best in me. In some ways, you still do.

We both grew a lot in those early years. I gave you everything I had, and you were there to support me and grow with me. I was proud and excited to be your partner.

As with most relationships, there were ups and downs. I was mad at you sometimes – other times even livid. Sometimes I didn’t respect your decisions – sometimes I don’t feel like you respected mine – but as we grew older together, we both began to change and grow – but I guess that’s normal in any relationship.

The problem is, that we’ve been growing in different directions for many years now. I give you full credit for the effort you’ve put into changing and growing these past few years, but for me, it’s just not fast enough. I know you want to change, but I feel like you just have too much baggage from your history to ever change enough where I can be happy with you. I want to race through life like a cheetah – and while you’re no longer the tortoise you were for much of our relationship, you’re at best, still just a bear lumbering through the forest.

I need more.

What’s happening now isn’t your fault – and it’s not mine either. We  grew in different directions, and now it’s just too much for us to recover. At least it’s too much for me.

I’ve been thinking of leaving for at least five years. It’s been easy to stay – you’re comfortable, and I feel safe with you.

But I’m not happy. I need more – I need to be challenged more; I need to grow more; I need to be around those who won’t be afraid to take risks and fail with me as I learn.

I took some time over the last year or so to try even harder to make-it-work. In the end, I just don’t feel like I’m getting the same from you of what what I put into this relationship. I don’t feel like you truly care about me and the value the things I bring to the table.

It’s just not working.

Could I have tried harder – of course. Would trying differently have made a difference – likely… but in the end, there are just too many incompatibilities for me to get over. It’s sad and scary, but I need to move on. I need to give myself a chance to have a life without you and see if I’m up for the challenge.

I’ll miss you. I appreciate everything you’ve done for me, but our time is over. It’s time for me to move on and see what I can do without you.

My last day at Microsoft – the company where I’ve spent the last 22 years, is Friday, January 20.


Asking Questions

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:


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.

Watch out for the HiPPO

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.

%d bloggers like this: