In today’s post, I will be writing about the eight lessons I learned from Programming. I enjoy programming, and developing customer centric programs. I have not pursued a formal education in programming, although I did learn FORTRAN and BASIC as part of my Engineering curriculum. Whatever I have learned, I learned with an attitude of “let’s wing it and see”.
- Be Very Dissatisfied with Repetitive Activities:
Our everyday life is riddled with repetition. This is the operative model of a business. Design a product, and then make them again and again. This repetitive way of doing things can be sometimes very inefficient. The programmer should have a keen eye to recognize the repetitive non-value adding activities that can be easily automated. If you have to generate a report every week, let’s automate it so that it is generated every week with minimal effort from you.
- There is Always a Better Way of Doing Things:
Along the same lines as the first lesson, you must realize that there is always a better way of doing things. The best is not here yet, nor will it ever be. This is the spirit of kaizen. Even when a process has been automated, there is still big room left for improvement. The biggest room certainly is the room for improvement.
- Never Forget Making Models:
When a Lean Practitioner is looking at a system, creating a model is the first step. This model could be a mental model, a mathematical model or even a small scale physical model. This model can even be a basic flowchart. This is part of the Plan phase of PDCA. How do the components work with each other? How does the system interact with the environment? What happens when step A is followed by Step B? A good programmer should understand the system first before proceeding with creating programs. A good programmer is also a good Systems Thinker.
- Keep Memory in Mind:
A good programmer knows that using up a lot of memory and not freeing up memory can cause the program to hang and sometimes crash. Memory Management is an important lesson. This is very much akin to the concept of Muri in Lean. Overburdening the resources has an adverse impact on productivity and quality, and it is not a sustainable model in the long run.
- Walk in Their Shoes:
A good programmer should look at the program from the end user’s viewpoint. Put yourself in their shoes, and see if your program is easy to use or not. Programmers are sometimes very focused on adding as many features as possible, when the end user is requiring only a few features. There is some similarity with the use of lean or six sigma tools at the Gemba. If it is not easy to use, the end users will try to find a way around it. This brings us to the next lesson.
- Listen to the Gemba:
One of the lessons I learned early in my career is that I am not the owner of the program I write. The person using the program is the owner. If I do not listen to the end user then my program is not going to be used. I do not make the program for me; I make it for the end user. Less can be more and more can be less. The probability of a program being successful is inversely proportional to the distance of gemba from the source of program creation.
I wrote at the beginning that I learned programming from a “winging it” attitude. However, I soon learned the importance of documentation. A good programmer relies on good documentation. The documentation should explain the logic of the program, the flow of the program, how it will be tested and qualified, how the program changes will be documented and how the bugs will be tracked. The simplest tool for documentation can be a checklist. My favorite view on using checklists is – not using a checklist for a project is like shopping without a shopping list. You buy several things that are not needed, and do not buy the things that you actually need.
- Keep a Bugs List – Learn from Mistakes:
Bugs to a programmer are like problems on a factory floor to a lean practitioner- it depends on how you view them. For a lean practitioner, problems are like gold mine. They are all opportunities to improve. In this same line of thinking, bugs are also a programmer’s friends. You learn the most from making mistakes. No program is 100% bug free. Each bug is unique and provides a great lesson. The goal is to learn from them so that you do not repeat them.
Another important lesson is – ensure that fixing a problem does not cause new problems. A programmer is prone to the law of unintended consequences. Any change to a program should be tested from a system standpoint.
I will finish off with my favorite anecdote about programming:
When Apple introduced the IPod, they were very proud of its “shuffle” feature. There is no accurate way of truly randomizing songs. However, there are several algorithms that can generate a pretty good random order. Apple utilized such an algorithm. It was so good that the users started complaining because sometimes the same song was repeated, or the same artist was played repeatedly. That is not how random should be – the end users argued. Steve Jobs then asked his programmers to change the algorithm so that it is less random.
The Digital Music Service company, Spotify faced the same problem. As they explained on their blog;
“If you just heard a song from a particular artist, that doesn’t mean that the next song will be more likely from a different artist in a perfectly random order. However, the old saying says that the user is always right, so we decided to look into ways of changing our shuffling algorithm so that the users are happier. We learned that they don’t like perfect randomness.”
The perception of random for the end user meant that the songs are equally spaced from one another based on how similar they are. The end user did not want randomness in a theoretical sense. They wanted random from a human practical sense.
Spotify changed their algorithm in 2014. “Last year, we updated it with a new algorithm that is intended to feel more random to a human.”
Always keep on learning…
In case you missed it, my last post was Be Like Coal At the Gemba.