Scrum: A highly selling agile framework that is based on a prerequisite that is impossible to fulfill: knowing how long a chunk of work will take to complete . It is all so great!
- Autonomous teams that are told to do Scrum.
- Early feedback and improved communications, but only after two weeks.
- “Measuring the velocity” by relying on estimates. Everyone knew this already, when the estimates were done.
- A Scrum Master that doesn’t require any skill or experience in order to have “master” in his job title.
- The highest adoption of all agile frameworks, except no one “really” does Scrum, because it “doesn’t really fit in this particular context”, and therefore “we are doing Scrum OUR way”.
cynical: doing agile
Doing agile: We do understand, that every team member is selfish, has poor communication skills and insufficient knowledge to solve an undefined problem that everyone pretends to understand in a predictable amount of time.
Therefore we are shifting the focus from believing the experts and their plans to learning, experimenting and repeatedly checking something useful gets done. And we do test-driven SAFe T-shaped daily pair programming Kanban with our Scrum PO.
P.S. We don’t do documentation, because we value working software more.
A lumberjack metaphor
To illustrate 12 very important aspects of agile software engineering, I want to use the oversimplified metaphor of lumberjacking. A forester, who represents the product owner, leads a team of lumberjacks, which is the development team, to the most important trees to cut down. The trees represent features or stories. How is this metaphor valuable?
- Segregation of responsibility: One marks the trees to cut, the others define how and do cut them.
- The lumberjacks who have the strength, skills and tools to cut down trees, although not everyone is on the same level of experience, so they help each other out. Some trees can be cut alone, others need to be cut together.
- The forester pays the team of lumberjacks to cut down trees, so that he can futher explore the infinite forest of valuable trees.
- In order to collaborate, mutual respect for the counterpart's discipline is required. Discussions and proposals are valuable and humility is a prerequisite, but the circles of competence are known and respected.
- The lumberjacks are able to state concerns: It could be dangerous to cut down a tree, because of uncertainty where the tree will fall. Risks, depending on what is on the line (another tree? A human?), need to be evaluated strategically and should be reduced on the long run.
- The forester can ask questions: Do you think, we can chop this tree safely already, or do we need to chop another tree first?
- CYA concerns are resolved easier: It is either the wrong tree, or it is the wrong way to cut it down.
- No one is perfect: Sometimes a tree is mouldy (=> wrong feature), sometimes the chopping takes longer than expected (=> unexpected technical complexity).
- Some trees are in the way and need to be cut down in order to get to the 'good' trees.
- The forester doesn't tell the lumberjacks to sharpen their chainsaw or axes (=> write tests, update IDE's etc.): They know and do it themselves, better than the forester could. They will do it within the working hours.
- It is dangerous to cut trees. It is important to have safety precautions and stick to them (=> QA).
- After a tree is chopped, the work is not done (=> definition of done): It needs to be cut into smaller pieces and carried away. Then the wood goes trough a number of procedures (=> build pipeline) in order to be made valuable. Sometimes the value is to give shelter, craft furniture or build a ship, sometimes it just gives comfy warmth in front of a fireplace. The foresters intention might materialize here (=> business value).
To be honest, I do not know so much about lumberjacking or foresting, so forgive my oversimplification and maybe misconceptions. The goal is to write about software engineering metaphorically, and I find some concepts easy to understand using these wooden examples. I have a more detailled and less metaphorical article about the segregation of responsibility here.
For the module “Agile Procedure Models” at my university, I write an essay about BDDs origin, principles, advantages, evaluation and how to approach it. Since we need to hand in a PDF version and a markdown version, I decided to go the extra mile and have a always up-to-date version of it hosted as Github Pages website here: bdd.guru,
so that I can receive early feedback from other readers and the professor. Please send me a mail (firstname.lastname@example.org) if you have any feedback for me.
Update: The paper is done.. I think it is worth reading. Feedback is still valuable to me.
I then realised, that it is generic enough to use it for all future essays and thesis’, so I extracted a template repository which makes it really easy to get started with a new paper, export it as HTML and host it as Github Pages website with every commit and additionally export it as PDF using pandoc and the latex pdf engine with minimal effort. Find it on Github to experience the same ease.
Closing feedback loops
A long time ago, King Hammurabi of Babylonia,
code of law,
the so called Code of Hammurabi,
which holds some surprisingly effective thoughts regarding the contract between a landlord and a house
„If a builder build a house for a man and complete it, (that man) shall give him two shekels of silver per SAK [a length unit] of house as his wage.“ 
A bigger house costs more money. But isn‘t it interesting, how the house builder is not paid depending on the time it took to build it? There is no hourly rate, which means, the landlord wont get any unhappy financial surprises, which is good. But wait a second! Doesn‘t that mean, that a house builder will do anything as fast and cheap as possible, wouldn't that be a catastrophy? He might put those people in danger, who want to live in this house later on. The key question is: How can the owner of the house assure, that it has a good quality, if he only pays depending on the size of the house?
Hammurabi thought about this, did some risk management, and solved this „quick and dirty“ approach by the following law:
„If a builder build a house for a man and do not make its construction firm, and the house which he has built collapse and cause the death of the owner of the house, that builder shall be put to death. If it cause the death of a son of the owner of the house, they shall put to death a son of that builder.“ 
There is no need to explain, that the house builders will do their absolute best to prevent houses to collapse and kill someone, because they have so much skin in the game for an unlimited amount of time, meaning they can be killed because a house collapsed, they built 20 years ago. How exactly assured Hammurabi the quality of houses? By closing a feedback loop for the craftmanship of house building. Those who are really good at building houses will be able to keep building houses, while those who fail doing that will be stopped putting peoples live in danger. It might sound like a cruel practice from our modern cultural perspective, but it led to ridiculously good houses, there is no doubt. The house building quality solution is not a solution for house building anymore, maybe because of technological advancement and regulations, but I believe we can learn a lot from Hammurabis structural solution here. He shows us, that we need to close the feedback loop and reduce its complexity. This is, in my opinion, the single most important task of agile software processes. What I mean goes far beyond „You build it, you run it.“.
One example: A software architect, who does architectural work on a project and then leaves over to the next project, has zero skin in the game of the old project, and is therefore hardly able to improve. In a frictionless world, this architect would maybe get verbal feedback from people on the lower technical levels, that experience the actual haptical feedback that result from his decisions. But in the real world, complexity, reputation and hierarchy fog this verbal feedback, which complicates improvement for the architect further. And this is just one example for the concept of closed feedback loops, and therefore having skin in the game.
Lets enhance our motto: „You build it, you run it .. and you bleed for it.“, where bleeding is metaphorical for all the (negative) consequences that result from our decisions. It may be a phone call in the middle of the night, it may be doing overtime that originates in our own mistakes or might be getting fired. Especially the last point might sound extreme on the first glance, but think about this on a theoretical level first: Do you really want to build a team, in which people don't experience negative feedback on their own actions? Do you prefer working with people who survived the sometimes brutal reality, or would you rather work with people that have set up (and used!) safety nets a little too often? Please get this right: I am all for improvement that is based and being able to fail and learn. In order to be able to innovate, it is crucial to have playgrounds with limited consequences to failure. On the other hand I am worried, that an extensive lack of consequences will lead weak software craftsmen, who build houses that collapse.
And, of course, be aware! Don‘t let someone else put YOUR skin in HIS game. It has happend more than once, that a release plan, that was promised by a project manager led to overtime for engineers, or that product owners are blamed for quality issues, that were caused by „I will fix it later“ minded engineers. See my article The Two Dimensions of an Increment right below to get more detail on this topic.
I found the inspiration for this thoughts in the book Skin in the Game  by Nassim Nicholas Taleb.
 Harper, Robert Francis, Ph.D. The Code of Hammurabi, King of Babylon about 2250 B. C. Autographed Text, Transliteration, Translation, Glossary, Index of Subjects, Lists of Proper Names, Signs, Numerals, Corrections, and Erasures, with Map, Frontispiece, and Photograph of Text. p.81, §228
 Harper p.81, §229, §230
 Taleb, Nassim Nicholas. Skin in the Game, Random House, 2018.
This post discusses the segregation of responsibility of an increment between technical people and
people. I experienced a very unclear understanding of this topic on both sides,
which usually leads to wrong decisions and poor quality. I believe the proposed model will lead to a
sense of responsibility and therefore greater results.
Lets start by some definitions: An increment can be everything between a whole product, that was developed for years to a small feature that was developed in the last iteration/sprint. It has many dimensions. For this model we need only two of them: the business perspective (also referred to as functional), and the technical perspective. Business people are those that work on the business perspective of an increment, by defining and refining the problem, doing business research, talking to stakeholders etc; they answer the "what?". In scrum these are the product owners (POs). Technical people on the other hand are those who tackle the technical perspective on an increment. They develop a solution to a problem, by answering the "how?". And they work in a team, why not call them "tech team" for this article. If the tech team says, they want to do a technical task that does not directly provide business value, but is necessary to keep the system alive, what should happen? Should the product owner agree to do it? The tech team as a whole is responsible for everything that happens on the technical dimension, including a sufficient level of quality ("We do not deliver Shyt!"), operations and security issues. Other examples are architectural, programming language and cloud platform related decisions, and there are many more. Since it is "their" solution to the problem, you call the tech team in the middle of the night, when the software isn't running! Additionally, they are the only ones that know how to fix it.
Therefore, the business people should not actively agree to the technical task, that was mentioned earlier; they shouldn't bother at all! The questions that are asked on the business dimension are often similar to "What do we need to do?", "What is our (functional!) priority?", "When will we be done with this stage of the backlog?" and "Should I take this as one feature, or rather split it into two?". The business people should decide everything, that belongs to the business perspective, and shouldn't decide anything that does not belong to that dimension. If they would do the latter, they would take away the responsibility of people, who are better at doing that, which is a guarantuee for a loss of value from a wholesome standpoint. The business peoples decision making power starts and ends at business questions.
This is a very clean and structural (and massively simplified!) solution to a typically "unclean" problem. I have worked with engineers who believe, it isn't their responsibility to take actions on technical topics, because they do not feel responsibile. The technical debt piles up, which leads to quality issues and paralyzation in the development process. But they want to get told by the business people, or at least get allowance, to deliver good quality. That is not what being a craftsman and taking responsibility looks like.
On the other side, I have seen customers and managers, who believe that the business people are responsible for everything, even technical things like architecture and quality. And of course, as common as the "unresponsible engineer" is the "I-will-take-it-all-business-person", who wants to decide on huge technical decisions or backlog items based on a two minute explanation. This persons often "allows" the tech team to decide on the smaller issues, because he "trusts" them with that. He mixes up the two given dimensions of an increment with importance or size.
To make this more clear, think of the following example: As a member of the tech team, I have to keep my operating system up to date and secure all the time. On the long term, there is no way around it in order to be able to develop a feature, and I am responsible to do this. The very important question here is:
Why am I responsible for doing this very small technical thing?
Is it because it is a technical thing to do, or is it, because it is a small thing? If the answer is the former: Great. Scale that up. You don't need to read this any further. If the answer is, because it is a quick and small thing, than you have that unclean structural problem that was mentioned above. There is no exact way in determining beforehand if a task is above or below a given threshold in size, complexity, importance, criticality etc. It is a subjective and discussable thing, that depends on experience, perspective and even the mood of people. At this point one could be tempted to think: "If it is close to that threshold, I will know if it is in my area of responsibility or not.". Yes, you might, but someone else might have a different perception, and this relies by far to much on that subjective metric. A very clear segregation in responsibility, between the business perspective and the technical perspective (and people who are well aware of it) is a good thing that leads to great results in software development.
One is responsible who has the power to make decisions, is affected by the consequences and has to deal with the reaction to those.
In order to embrace the segregation of responsibility, I propose that you start by cleaning up your backlog (or any other form of todo list you have). Group the items in "functional" and "technical". If some items are on the edge between those two, focus on the functional aspects first and kick out the technical questions or decisions, they will follow. The functional items are the reign of the business people. If you are one of them: This is the area you can make decisions on, and you have to take the full responsibility for your decision. This is your area of influence, doing a great job here will be easier without having all those technical aspects in mind.
Now have a look at all the technical items. What you see is the reign of tech team. If you are part of the tech team: This is what you decide and take the responsibility for. Ask yourself for every legacy item you have: Which problem does my technical item solve, and is that really necessary and relevant? Clean up and discuss it with the other tech team members. You have to see the whole picture (the beyond-sprint-perspective), because you will be accountable for it.
Just to get this right. I am not proposing to reduce the communication between business people and technical people. As a technical person, it often is a good idea to challenge business requirements. The technical people will sometimes have to justify, why they decide for a specific framework or why you want to switch the programming language etc. But by all the technical decisions you do and execute, you should always (at least every iteration) also deliver things. Have in mind: the tools you use, are tools to solve a problem. Tools are not useful without a problem to solve. Talk to each other :-)
One concern I have often heard: How can you take away the responsibilty for big and time consuming technical backlog items from the business people? They will need to meet agreements and make promises about release dates etc.! That is a valid question, and the answer is underwhelming: A technical decision is equally not in their responsibility, as protecting the engineers from getting hit by a bus. They simply cannot control it, and they shouldn't. At this point, business people have to let go the urge to control that and trust the tech team, which will deliver solutions, which will lead to more trust. It is an upward flywheel.
I hope that this clarification about the dimensions of an increment, that should be taken into consideration when taking responsibility for a software project in any role, helps to build highly valuable software with less stress for every involved person. Please keep in mind, that the more formal segregation I propse is no silver bullet. It is just a small piece in the big puzzle of software development, that can only work, if you have a non-broken tech team, that is abled and willing to take responsibility.
A lot of people do retrospectives. A lot of teams do that on a regular basis. They sit down, think about the last two weeks or so, identify problems they have had and find action items to improve. That is super cool. What we did today, went one step further: We thought about the problem we tried to solve in the past two years with our product. Having the problem in mind we brainstormed on how we could solve the problem, not thinking of our current solution at all. We reset our brains, including all of the domain language, business rules and other burdensome legacy concepts. This. Was. Awesome. The concept: Let us do two full day design thinking-ish meetings. First day: Brainstorming, throwing "the big five "topics out. Then splitting up and grooming in pairs and presenting the results to everyone. Second day: Trying to be more structured and start thinking on a high level, considering the ideas of the first day, and refining into more detail. Result: Eventually we found a cool way to solve our business problem, which was not related at all with the solution we had in place. It was totally mind-blowing, how we could do the same stuff we did the past two years a lot better than before. Next steps: By mapping the status quo with the target state, we want to identify the concepts that are different and those, that are similar, on which level, and why. For those concepts that are far apart: Which were the historic reasons to make the decisions, that led to a the status quo? Is the solution, we have in our heads now, really better, than the one, we have implemented? For those areas, where we had no shiny new ideas: Were we really open minded, or is it really the only way to solve this problem? Then we go quickly into the direction of making things concrete, by iterating over all the necessary steps: Starting from clarifications with the legal department, marketing people and other stakeholders, getting a more precise understanding of the solutions we are going to implement, having scribbles of the screens, implementation in code and so on.. as meantioned: all iterative. Okay, now the truth: It was not awesome at all. It was super difficult to let go all of the known, and most people, maybe all, actually did not manage to rethink concepts from scratch they had already solved. It actually hurt to see a lot of complexity, which we put a lot of effort in, just flushing. People had developed close relationships with "their" solutions, and felt attacked by questioning everything. We did not finish within the time we expected, and people questioned, if we should actually continue with this format, because all of it was so heavy and took so long. And then there was this constant: "Man, why didn’t we do this one year ago?"
I gave a lightning talk @ Fullstackfest 2018 Barcelona, and yes, I confused the words “Requirement” and “Prerequisite”. Shit happens.
Story Estimations in the world of agile software development is, in my opinion, a totally underrated topic*. It has major influence on several important topics, such as the agile mindset of the team, the trust between the PO and the development team, and how to deal with pressure. I observed several biases related to this topic, and today I am going to write about one of them, the "Only split a story, when it is too big" bias. Assume a team, that is estimating stories** with Fibonacci numbers (0,1,2,3,5,8,...) having an average velocity of 10 story points (SP) per sprint. The rule behind the bias says: If a story is bigger than 8 SP, it is too big, and it should be split into two stories. Otherwise it is "small enough"and can stay as it is. There are several advantages of this, especially from the PO's POV: - You have less work, less text to write and less items in the backlog. - You can cut and merge the stories based on your feeling. If you have to split it, the estimation of the team will tell you. If no one tells you, it is okay. - You do not need to bother about details (from a business POV!) too much. Since there is barely any space for details, they can stay hidden and will be handled by the team as soon as the story is being implemented. Here are my objections: First, about the flexibility: The number of stories in the backlog might be small, but the PO cannot change the amount of work by putting things together in one story instead of two. What he instead does, is burying the flexibility to postpone the less important part of the story and shift the more important part closer to the sprint backlog. Moreover, just think of the following situation: A big story was planned and not split, and while implementation, the team found out it is not only big, it is huge, so they cannot do it in this one sprint. In most cases, the team will continue with this story in the next sprint, and questions like "How many percent of the story are done?" or even worse "How much story points of this story have you already achieved?" might pop up. Having stories for more than one sprint leads to frustration for the development team and immobility for the PO, who has no good options, then putting the story into the next sprint again. You might have heard of the "divide and conquer" strategy in other contexts, but here it fits perfectly as well: By dividing stories as often as possible, you will be able to conquer the more important parts of the product first and leave out all the rest for later. Just as a side note: I have heard sentences like "…but if the PO doesn't want this flexibility, it is his problem.". Dear engineer with this opinion: If you try to make the life of the PO easier, he will try to make yours easier; help your PO! Second, about reducing the amount of work: A PO, who is lazy in writing stories, and has rather one long story instead of to short stories, doesn't invest enough attention into the most important parts of his job: Leading the work of the development team into the direction, that increases the value of his product. At the end of the day it is cheaper and less time-consuming, if the PO figures out the details from a business POV upfront and puts them into stories. Dear PO, who thinks that he can "save work" by "just leaving as it is" and "seeing what the team thinks": You are generating unnecessary work for the development team, and for yourself; do your homework instead! Third, about the user feedback: It is a great strategy for products, that are already live and released, to monitor, which features are actually useful for the users and which are not. With smaller stories, the feedback loop gets smaller as well. The user and his wishes and needs related to the product can be understood, and the solutions, the user really desires, can be applied. The PO will be able to see, if his idea is a good idea, before investing a lot of time and money into developing it. And even if your product is not live yet: If the stories are small, the PO will get the feedback from the team, of how they understood the story, early. Therefore, he can react to misunderstandings und surprises early and reduce waste. Fourth, about the motivation: This fourth point might not seem to be the most important one, but I still decided, to note this down: What do you think feels better for all involved, saying "There are 3 stories done and one is started", or "The one (huge) story this sprint is almost done". Obviously the first option sounds better and makes people feel better, since achieving something is always better than achieving nothing. Yes, this doesn't affect the reality directly, but it is a good motivation to see constantly, that you get stuff done. Conclusion: Writing as small stories as possible (ASSAP) helps the PO to gain flexibility, by being abled to leave unimportant stuff out and putting more important stuff faster in. It also increases the speed of the development, by giving more space for the details and time to clarify them upfront. Moreover, it helps the PO and the development team with going into the right direction, by reducing the size of the feedback loops between the development team, the PO, and, for live-systems, the user. Finally, it motivates the team, by making transparent, that they actually get stuff done. *There are some interesting people who write about this topic, such as Woody Zuill and Mike Cohn. In general, I am not a fan of having estimations at all (Compare with Woody’s #NoEstimates), but since it is still a very common way of planning (i.e. guessing) the future, we have to deal with it somehow. **All stories in this consideration underlay the precondition, that they contain only a business POV and no technical perspective on things. Typically, this looks similar to "As a user, I want to rate an online shop, in order to tell others about my experiences with it and give hints, recommendations or warnings."