Relearning might look like a good thing, but it’s not

👇 (This is the same intro for all the lean waste posts. If you have read it already, scroll down for 4 paragraphs) 👇

We waste time all the time. Small unimportant tasks. Procrastination. Looking at nothing (this one is not really a time waster if it clears your head). The world is filled with traps that make us waste our time, and some of them we already know how to detect and adapt to them.

Photo by Stas Knop from Pexels

Lean Manufacturing talks about the 7 lean wastes, these wastes can also be mapped to software development.
During these next 7 days, I will pick up one of the wastes and investigate the following questions

  • Why does it impact our work?
  • What could be the causes of this?
  • How can we measure it?
  • How can we avoid it?

For today, the focus is re-learning. If learning is good, why is re-learning a waste?

How much did civilization lose, when the great library of Alexandria burned to the ground?

Learning how to do something is the most rewarding experience one can have. But if we learn and then forget, what value is in this learning?
The same goes for software projects. If the code we do is so complicated that the next time we look at it we don’t understand, that is a very big waste of time.

Information that is lost in translation, lack of comments or documentation, is information that we will need to re-learn later in the future. Re-learning is usually fueled by other gateway drugs of time waste. Hand-offs, delays, and task-switching are the major causes of having to re-learn what we already did.

Why does it impact our work?

Photo by Pixabay from Pexels
  • We don’t learn new things and keep re-learning that same thing over and over.
  • If we don’t remember, we are doomed to commit the same mistakes.

What could be the causes of this?

Photo by Pixabay from Pexels

How can we measure it?

Photo by Lukas from Pexels
  • # time to repair. If your bugs are similar, the time to repair should be reduced over time
  • # similar bugs. If we keep committing the same mistakes.
  • Code standards, smells and linting.

How can we avoid it?

Photo by Linda Eller-Shein from Pexels
  • Code should be properly documented and reviewed by your peers
  • Refactor constantly to keep the code fresh
  • Automate everything that can be automated, that way you don’t need to remember
  • Continuous improvement – Kaizen
  • Pair programming and knowledge sharing



Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

search previous next tag category expand menu location phone mail time cart zoom edit close