Lean, lean, lean. We already heard this mantra over and over, but what does it really mean? Particularly, what does it mean when it comes to creating software? In this post, we explore what a lean approach can bring to any developer, and how you can start using this approach in practice. Once you read it, you will be up and running with lean software development.
Behind Lean Software Development
Where does it come from?
Lean Software Development is not just a new-age trend. Instead, it finds its roots in lean manufacturing. This is the approach that revolutionized factories in the XX century, the approach that made mass-production possible. It started with Taylorism, and it evolved in up until the 80s with Toyota. The foundation of this approach was the scientific method.
Lean manufacturing is all about minimizing waste, of all kinds, to maximize productivity. This is utterly evident if you have a production line that works with raw material. For example, if you need a circle metal sheet and you start with a square sheet, you will end up wasting all the excess metal.
Now, I think you may want to get immediately your hands on how to maximize productivity. However, if you want to go deeper on the history of lean, check out these resources:
- A Brief History of Lean is a wonderful article anyone truly embracing Lean should read.
- The Origins and Principles of Lean Manufacturing by Martin Murray is a must-read. In less than 5 minutes, it teaches all you need to know about lean manufacturing. Definitely worth checking, even if you’re in a hurry.
Wasting time and inventory
But the waste of materials is not the only waste we have. We also need to consider the waste of time and inventory. Wasting time is intuitive to understand: you take more than you should to do something. Instead, wasting inventory is slightly more subtle.
In the car production line, you start with thousands of pieces and you end up with one big thing: the car. In the production line, the various teams work at different stages in assembling the parts. Naturally, one team will need the parts assembled by another to work. If one team is faster than another, at some point you will either have one team stockpiling or another waiting for the other team to finish.
Lean manufacturing addresses that. It aims to reduce the inventory (materials one team has finished and another team needs to work on) to the minimum needed to avoid that someone is kept waiting. We want to reduce it to the minimum because having more than that adds really no benefit, it just locks resources into the production process.
Moving to Lean Software Development
Lean Software Development takes all this beautiful zen concept coming from lean manufacturing into the world of software. As we will see, this has wonderful benefits. It allows you to create better applications, faster and cleaner, and later evolve them with your needs.
Embrace Lean Software Development
There is no secret recipe to improve your productivity. Instead, Lean Software Development gives you a set of principles. Ideally, you should follow all of them to have the best results. However, the transition can be a hard and slow process, and even a little bit painful.
Thus, skim the principles and adopt them gradually if you are already working on something. Instead, if you are starting a project from scratch, consider the whole package straight away.
The 7 Principles of Lean Software
The seven principles that come with lean software are quite simple to understand. Yet, after listing them, we will see in detail why they are important.
- Eliminate waste
- Amplify learning
- Decide as late as possible
- Deliver as fast as possible
- Empower the team
- Build integrity in
- Optimize the whole
As we will see, these seven principles end up replicating what nature has been doing with evolution.
Eliminate waste
This comes straight away from lean manufacturing. You should eliminate any kind of waste in your software and in your work.
You should eliminate unnecessary features, and don’t even plan for their development. If your software doesn’t have an urgent need for a feature, probably you shouldn’t implement it.
Focus on eliminating the waste also in your work process. Reduce waitings and handoffs (passing the work between colleagues). Cut down the time spent managing (rather than producing) to the minimum required. Ideally, you should also reduce task-switching: moving between different tasks. If someone starts to do something, it would be better if he finishes it before doing something else.
Try to reduce defects by improving the quality of your software. If you deliver a buggy software, you will have to waste a lot of time reworking it later. Quite bad!
If you do all of that, your productivity will skyrocket. In fact, waste that you can easily avoid is something quite common in the industry. This paper shows common areas of waste, most notably even building the wrong product (not just a feature!). However, so many areas of waste translate into large untapped potential if you fix them.
Amplify learning
Making mistakes is human, but making the same mistake twice is simply poor learning. Whatever you do, and particularly when you screw up, it is a wonderful opportunity to learn. Never let it slip, particularly in software development.
Lean software development teaches us that we should build small features. As soon as the feature is ready, we should test it and deliver it to the customer. This way, we reduce the size of the feedback loop. In other words, the time elapsing between starting developing the feature and getting feedback from the customer is as little as possible.
This means learning is faster. Furthermore, it enables you to act quickly and address any potential issue. It makes your software development process nimble.
Technically, we can translate this principle in having a DevOps process and write tests for it. Yes, you read it right. You need to write tests for your code, all the time. If you are not familiar with tests, just know they are pieces of code that verify that your “main” piece of code works. Any programming language supports tests in some way or another.
Decide as late as possible
This concept can apply to any project but it is particularly with lean software development: uncertainty is your enemy.
Virtually, uncertainty is the root cause of the failure of all the projects in the world. In fact, if you were certain to succeed, you would have succeeded. Instead, if you were certain to fail, you wouldn’t have started the project at all. Failed projects pave all the way between the two.
So, you need a great way to get rid of unsafe assumptions and eliminate doubtful decisions. The best way to do it is to decide as late as possible. Don’t overthink way ahead, make the decisions Just In Time (JIT).
Furthermore, by deciding as late as possible you often have more data to rely on. If you have a platform and some users on it, you can easily collect statistics on how they use it. Then, with those statistics, you can make an informed decision based on facts. As a rule, try to decide with facts and not with assumptions. Of course, this will not be possible 100% of the time.
Deliver as fast as possible
This is another important concept of lean software development. You should deliver as fast as possible. This means shipping your code to the users as early as you can.
The concept behind this is simple. If you can go faster than this, it means you can cut down some waste (e.g. too long meetings, unnecessary waitings, and so on). So, cut down on such things and go faster!
Many teams approach this with agile. They work on a Kanban board to stay focused, and they avoid formal meetings in favor of quicker stand-up meetings. In case you don’t know them, stand-up meetings are meeting where everybody stands up. Standing up is meant to make you feel uncomfortable so that meetings end quickly, ideally within 10 minutes.
If you want to embrace agile with Kanban, check:
Empower the team
In short, trust your team to get the job done, and never micro-manage. Ideally, you should have competent people in your team, and you should trust they know what to do. The manager should listen to the feedback from the developers so that they can express what are the various options on how to proceed.
Bring the decision-making down in the hierarchy. The more decisions the manager needs to take, the more it will be the bottleneck. Free him by moving some of the decision power down in the command chain. This will mean decisions happen faster, avoiding unnecessary waitings.
Of course, you need to see what works for your team, and what doesn’t. Experiment on this until you get to a comfortable level where decisions are made properly and fast enough.
Build integrity in
Be consistent, don’t mess things up. Well, of course, this can apply to life as well, but in lean software development makes even more sense.
Your customers should understand your product. All its parts should work together beautifully, much like an orchestra. This may sound like poetry if you are a practical developer, but the implementation is simpler than you think.
You build integrity in with code refactoring. The more you add things to existing code, the more it gets messy, no matter how good you are. Code refactoring simply means taking the time to review existing code and removing unnecessary parts. Optimizing it. It is a zen practice for software developers.
In this way, you will ensure your code will always get better as it grows over time. And, if you think it’s a waste because it doesn’t give a feature to the user, think again. If you don’t do that, you will eventually have to throw it all away and built it anew. How’s that for a waste instead?
Optimize the whole
When you develop large software you often have many teams working on different parts. And, if they are good at their job, you might even get amazing parts. The thing is, your user doesn’t simply use the parts. It uses the entire system and the interaction between its parts.
Always ensure the whole user experience is great, and optimize for it. Ensure all the parts come together beautifully, and not just from a technical standpoint, from a user experience standpoint.
Ensure that the experience is so consistent and that parts work so good together that you can’t easily tell when one finishes and the other begins.
In Summary
With this quick read, you have an overview of lean software development. With the 7 principles we explained, you can now start and build your own approach to software, one that works for your team.
As always, making changes to how people work can be painful and take time. So, go step by step, and embrace lean software development gradually!
