\\\ being \\\ thinking \\\ doing \\\ buy ☕

Closing feedback loops

Hammurabis understanding of evolutionary loops

By Robert Nickel - June 05, 2020

A long time ago, King Hammurabi of Babylonia, wrote a code of law, the so called Code of Hammurabi, which holds some surprisingly effective thoughts regarding the contract between a landlord and a house builder.

„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.“ [1]

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.“ [2]

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 [3] by Nassim Nicholas Taleb.

[1] 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
[2] Harper p.81, §229, §230
[3] Taleb, Nassim Nicholas. Skin in the Game, Random House, 2018.

Segregating responsibility

The two dimensions of an increment

By Robert Nickel - March 08, 2020

This post discusses the segregation of responsibility of an increment between technical people and business 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 better 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.

Scaling innovation

The McDonald's of Software Development

By Robert Nickel - August 29, 2019

Often when I tell people, that I am a Software Engineer, they explain their idea of a game changing app, but don't know how to make it real. People backtrack when they find out about the cost of software development, because they fear the risk and often have no clue about this whole craftmansship. This does not mean, that the ideas are worthless, many of them are really good and some are actually game changing, I believe. So there is value, but no one picks it up.

Why is there no McSoftware that paves the way for low-budget projects to become real? It could be a franchising company with a world wide network of managers and lawyers, a great branding and very efficient value streams, just like the fast food restaurant equivalent McDonald's.

I thought about this a lot, especially about the question, how I could build this. And I came to this result: If it would be achievable, someone would probably have achieved it already, or at least something similar. But that is not the case, as far as I know. The reason: software development barely scales. The software itself scales indefinitely, and therefore there is no reason to produce the same thing cheaper then the competitors. Software breathes innovation. And innovation does not scale at all, that is in its nature. Innovation in general is the effort of many but the success of few, and those Einsteins who get humanity to the next level might get the prestige and/or the money.

What can we get out of this? The bad news are, that you will need to have the game changing idea and the resources to make it real. But on the other hand, due to higher level programming languages, reusable components and frameworks, better ways of teaching and learning technology and more digital natives with upcoming generations, it is getting cheaper and more accessible over time to develop innovative software that changes the world.

Thinking humble

The quality of an answer to an open question

By Robert Nickel - July 8, 2019

I used to work in the same team for more than 2 years, and now I left and joined a much smaller team in a green field project. We had the chance to set up parts of our methodology on our own, and one part was the question: "How do we as a team want to estimate?".

It was consciously expressed as a very open question, and a colleague of mine immediately responded: "In hours please!". Before this project, she was in a project where one story point was equal to two hours of work, and you get into trouble, if you take more than the estimated time. The improvement/simplification she proposed was to not divide by two (which sounds like a random number in this context) when estimating story points instead of hours. I do not want to discuss this way of estimating non-linear work here.

The question she answered was not: Should we estimate time, effort, complexity, risk, business value or something else, on which scale (Fibonacci numbers, natural numbers, binary..) and in which unit (hours, days, story points, T-Shirt sizes, our own scale, apples..)? Her perspective to the question was one dimensional (which factor per hour), in a multidimensional answer-space. I believe her answer was smart in that one dimension, but not useful, when considering more of the dimensions we know of. This is not her failure or stupidity, it is her experience with this world of "agile" software development, and was extended in the next few minutes after other colleagues told their opinion.

It made me think: Am I answering multi-dimensional questions on a one-dimensional scale? Of course I do, basically everything I think of, I have to think in words I know and cannot think in languages or other concepts I have never heard of. In a lot of open questions, there are a lot of answers from dimensions I would never even consider, but are equally valid or much better than those I would consider.

This means, that the quality of an answer to an open question is not defined by the number of other answers that were considered from the same dimension, but by the number of dimensions, that came into consideration in the thinking process.

My colleague could not have found a great solution by trading off the number of hours per story point to be 1, 2, 3 or any other number, but we could find a good solution together, by exchanging thoughts and experience with other people, that do consider other dimensions. It is not easy to think out of the box, I therefore propose to visit other peoples boxes and have a curious look out of their windows. Also dare to step out onto their balconies. I think this is a basic concept in teamwork, friendship and familiy.

Rethink everything

Refining the whole product after 2 years.. and maaan, where did we go?

By Robert Nickel - April 15, 2019

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?"

Being cohesive

Only split a story, when it is too big?

By Robert Nickel - May 03, 2018

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.

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."


Hello World!

By Robert Nickel - March 26, 2018

This is usually one of the first console outputs, you learn to implement, when you are facing the situation of learning a new programming language. Same for me, I learned a new language, which is the language of Software Engineering.

But first things first, let me tell you where I come from. I grew up in a tiny village near Münster, Germany with my parents and siblings, until I moved out to go to the university in 2012. After deciding to do "something with computers", which I was really good with, and something with design, which I was interested in, I found the perfect subject for me at the Hochschule Hamm-Lippstadt (HSHL): Computitional Visualistics and Design. Sounds good, right? The first semesters where full of Math, Programming and Software Engineering, but also some Drawing, Design Fundamentals and even Soft Skills lectures. At the beginning I was sure that I was studying the right thing, to have both: fun and good job opportunities. But after some time doubts about the whole thing arose. Most of the time I had acceptable results, but I didn’t feel like I was ready to work in a real company after this.

In the 5th semester I did a 16 week internship at a big local provider of vehicle electronics and lighting systems, and worked in a project, all alone, the whole time. I had days, when I didn’t talk to anyone at the company, just sitting there and working at a super innovative and experimental way to measure the calibration of headlights with Matlab. I knew Matlab before, and Image Processing seemed to be fun, when I started off with the projects, but I had almost no sparring partner for my ideas and what I was doing, only a status meeting with my boss once per week. I didn’t use any kind of version control, it was all on my computer. No git, no problems, right? Now I know: no, but then, this is how I argued with myself. Mathematically I digged deeper and deeper, but my code was shitty from the beginning: Variables with the same name used for different purposes, loops in loops in loops in... whoops, thats an infinite loop! Anyway, my project was a partial success and a partial failure: I worked out some stuff that worked under very specific circumstances, which were not really usual in the reality out there. I wrote a 40-page thesis about it and received a good grade, but the main things I have learned were to survive boredom, handle Microsoft Word for my thesis and this super specific mathematical problem. Which of this could I use in the real world of Software Engineering out there? - I asked myself, and came to a result: None of them..

My doubts were getting bigger, but I strangled them with time pressure for another project thesis in the 6th and the bachelor thesis in the 7th semester. Both were related to Game Balancing, a subtopic of Game Design, and first I developed a small, but balanced game named "Revolve" with a fellow student, who was somehow on the same coding level as I were: Both of us didn’t always understand, why the software behaved the way it did, but somehow it all worked out. We developed our own two dimensional game engine for Java (stupid!) and then the game on top of it. We had a lot of work for a small but buggy game, and the most fun thing was, when we invited 4 friends into my living room to play it with controllers in front of a projector, obviosly with a beer or two.

For the bachelor thesis I wrote a more theoretical text with the title: "Analysis of the Transferability of Software Testing Methods and Structures for Game Balancing". After the thesis and some more subjects were I learned about 3D Modelling, Design Management and Usability Engineering, I was finally done, and could throw the mortarboard into the air. I did not really feel ready to work, and therefore had applied for a visa for Canada. I wanted to do work and travel or whatever all those cool young adults do nowadays. But the visa was rejected, so I was pretty depressed about that. After some more month I finally found, with the help of an old friend of mine, a promising job offering as Junior Software Engineer in a (connected) car related company called Daimler TSS in Ulm.

Today I work for almost 2 years in this company, and even if I have deadlines and sometimes really a lot of time pressure, I really like the job, the company and my colleagues. I want to talk about my experiences as a "20% designer - 80% software developer" mutant in the world of software engineering. Have fun!