During our latest monthly call, Maaret Pyhäjärvi and I spent some of our time discussing agency, accountability and scrum masters. At one point I said something along the lines of:

Scrum masters often end up as scrum mascots.

Maaret said I should write a blog post about scrum mascots¹, so here we are.

According to the 2020 Scrum Guide a Scrum Master² is accountable for two things:

• “establishing Scrum as defined in the Scrum Guide”.
• “the Scrum Team’s effectiveness”.

Accountability implies (or rather: should imply) corresponding authority. You’re being held accountable for certain outcomes *and* you have sufficient power to influence those outcomes. That’s a scrum master. A scrum mascot is a very different beast: they have neither power nor accountability. And yet that seems to be what a lot of organizations (and scrum masters?) want.

Read more…

Recently I applied to two scrum master jobs and it got me thinking: what is a scrum master? What is it exactly that they do?

What made this question even more pertinent to me (apart from the job applications) is that in the past I have been a scrum master. But that was five years ago and none of my jobs since had much involvement of a scrum master. And my experiences of those past five years made me wonder: where exactly does a scrum master fit in?

A scrum master is the Scrum boss

The 2020 Scrum Guide says:

The Scrum Master is accountable for establishing Scrum as defined in the Scrum Guide. They do this by helping everyone understand Scrum theory and practice, both within the Scrum Team and the organization.

Read more…

Chapter 5 of “Clojure for the Brave and True” explores two core concepts of functional programming: pure functions and immutable data structures. It wraps up with walking you through the code¹ of a game called “Peg Thing”², which uses “everything you’ve learned so far: immutable data structures, lazy sequences, pure functions, recursion - everything!”

So what is this Peg Thing?

For a full description and the code of Peg Thing, you can follow the links in the paragraph above. In this post I’ll only share what’s relevant to describe what I learned about functional programming through Peg Thing.

Read more…

This post is a slightly edited version of the experience report I presented at the xp2023 conference. It covers my first six months at a scale-up, working as a quality engineer for the first time - after having worked in other testing-related roles for 15+ years.

My main finding is that for a quality engineering role to work well, certain structures need to be in place. The most important one is that the impact the quality engineer is expected to have, is clear to both the quality engineer and the team(s) they are supporting. However, regardless of which structures you put in place, a quality engineer will also need to work around those structures to be fully effective.

Read more…

Too often I’ve heard people say: “Oh no, not another meeting!” Usually this means they feel their time at work is split between time in meetings and time in which they do actual work. And to be fair, they have a point. I too have been in plenty of meetings that didn’t achieve much of anything. It doesn’t have to be this way, however. Meetings can be effective and they can leave you with a real sense of having accomplished something. And in this post I’ll explain how to make that happen.

We struggle with meetings

We struggle with meetings. On the one hand we keep proposing them, scheduling them, attending them. On the other hand we keep complaining about them. We feel sorry for people with a day full of meetings. When a meeting ends early, we “get 10 minutes of our lives back”.

To that I say:

If you feel you do all your work outside of meetings, you’re meeting wrong.

It’s something I realized while I was a scrum master: my work happens during meetings. Mostly team meetings and 1-to-1s. There’s prep before and follow-up after meetings, but I did the core of my job through meetings.

Read more…

Recently I realized there are a few testing questions I use a lot. They lie at the top of my testing toolbox, so to speak. Together they shape my testing style, making it easier for me to discover certain things, but probably also harder to find other kinds of things. So here are my five favorite testing questions, in no particular order.

What if there are zero, one, many, lots of this thing?

Last year I expressed my surprise on Mastodon how many times I’ve found bugs by asking the question: “What if there are 0 / 1 / several / lots of this thing?” And if you’re working closely enough to the code, you should also ask about “null”.

Quite a few people responded to my message. Turns out it’s a very common pattern in TDD. And Brian Marick¹ remembered it standing out when he was looking into fixed bugs in the Linux kernel they used in the ‘80s. Personally I learned it from Elisabeth Hendrickson’s “Test Heuristics Cheat Sheet”, which found a new home last year at the Ministry of Testing.

Read more…

Originally Scrum was very much about “You tell us what needs building. We’ll decide how we build it and how soon we’ll deliver.”¹ I’ve never seen that version of Scrum. The version I have seen, has a product manager try to get as many features into a sprint as reasonably possible - for varying degrees of reasonable. This comes at the expense of maintenance work, such as keeping libraries up-to-date or removing technical debt. And it incentivizes the team to cut corners on features, to not leave code in a better state than they found it, to not fix smaller bugs and instead log them somewhere for later.

One solution I see to this problem, is to put an engineering manager fully in charge of the team.² The product manager prioritizes the features. The engineering manager prioritizes the full scope of work for the team. That’s not a simple change to pull off, however.

Another solution might be to change the way we use our backlogs. If a product manager gets to prioritize all the work, and the tool they use is a backlog, then we should make sure that all the work³ is in the backlog: features, bugs, and technical debt. Let’s take a look at each of these three categories of work.

Read more…

A few weeks ago someone suggested we should start measuring how many automated test cases versus how many manual test cases we have. Luckily it was part of a longer list of suggested metrics and it was also presented in that way: a list of options, to be discussed later. And the reason I say “luckily” is because I knew I disagreed with using that metric, but didn’t have a good explanation as to why. At that moment I could have given a minutes-long monologue about how that metric doesn’t fit how I think we should be thinking about testing. However, I have zero expectations that such a monologue could have worked in that situation. It would be all over the place as I philosophize about testing and make all kinds of connections and analogies. A convincing argument that does not make.

So since then, I’ve been thinking: how would I explain my position on measuring manual versus automated test cases? Something to the point, something relatable, something that acknowledges the need behind asking for this metric. And then it hit me: use cooking as an analogy. Now I know plenty of people have made this analogy before. However, I don’t remember reading everything I will cover in this post somewhere else. Also, there’s value in different people saying similar things, but each in their own voice.

Read more…