Learning – DANIEL SLATER'S BLOG

Books, Development, Learning, Project management

Book review: The lean manager

The lean manager is a book about the manager of a car factory in France. His company has just gone through a takeover and the new CEO informs him he must close the factory. After begging the CEO agrees that if significant improvements are made to productivity, before the closure can be arranged(it’s France, labor laws are very complex), he may keep it open.

How is our hero to make these improvements at a factory that has been stagnating for so long?

Through the application of LEAN principles.

If you have worked in any manufacturing/tech industry jobs you will have heard the term LEAN. LEAN management was a system developed by Toyota that led to huge improvements in their productivity. This book is from the same family as the Phoenix project, which I wrote about here, a management book in the form of a novel. Like the Phoenix project, it is also a surprisingly good novel. A few empty characterizations aside the story was engaging and I found myself really hoping the factory would turn around and the jobs would be saved.

What is interesting from a management/LEAN point of view is in the book the factory already follows LEAN processes. They have a continuous-improvement officer and the main character has already gained various LEAN certifications. What the company CEO teaches the manager is there is a difference between the LEAN process, which is a prescriptive set of actions to apply and true LEAN working, which is more about educating employees to collectively solve problems.

The CEO’s first advice for improving the factory has 3 parts:
1: Fix quality problems
2: Reduce inventory to free up cash
3: Lower costs by eliminating waste found doing 1 and 2

From this advice the manager tries installing red bins at every point in the factory. When a part comes off a line in a defective state it is put in the red bin. Multiple times a day, inspections are made to check on the contents of the red bins. At first parts are put into the red bins, but this doesn’t feed through to improvements. Senior managers argue about the reason for different defects and nothing is really done.

This leads to next issue in order for people to solve problems there needs to be agreement on what the problem is. Only then can group problem solving begin. There can only be agreement on what the problem is, if these things are clearly tracked. This involved better monitoring and much more education of the workers in terms of what the quality standards were.

Once there was clear agreement on what the problem was and how progress could be tracked then they could start to look at which teams and people were the most productive and start to feed the improvements they had across the factory. This is where continuous improvement could start to happen.

My take-aways

To create a good product, you must have a good process. But a good process only comes from good people and having those people engaged with the process. The first step to improving your product is improving your people. Improving people is not simply a matter of sending existing employees on training courses or hiring new more qualified new staff. It is about building a culture of continuous improvement and collaboration where the best ideas from one employee are adapted by the rest of his team and then the rest of the company. A factory is not just about part flow, but also knowledge flow. To improve parts, improve people.

In trying to create such a culture the first problem encountered at the plant is that it is very hard for employees to work together to solve problem. People look to avoid blame. If something goes wrong, the warehouse will blame the engineers, who will blame the maintenance teams, and so on. In order to solve problems together the first barrier is there must be consensus on what the problem is. When there is a problem it must be stopped at source. A bad part must be caught at the place it is made and not become the part that caused the problem in a larger component.

This is why the pull system goes hand in hand with LEAN. The shorter work cycles in a pull system mean it is much easier to identify where the process goes wrong and get people together to fix it.

Kaizen is term used by Toyota. It roughly translates to change for better. But as applied by Toyota is a thing meet for. When engaged in Kaizen there is a checklist to go through:

What is the problem we are trying to solve?
What result do we expect?
What principle should we apply?
Did we get the result we wanted? Why? What did we learn?

The Toyota 4 obsessions

Managing production sites through stable teams of multi-skilled workers
Get everyone involved in quality
Just in time process by reducing lead time
All around cost reduction by eliminating waste

Another big theme in the book and a solution to so many problems is what they term “Go and see”. How do you get people to improve productivity? Go and see who is doing a good job and what they are doing. How do you reduce waste? Go and see what is being wasted. How do you get people to take responsibility for process? Go and see what they are worrying about. This really rang true to me, so much of what I’ve seen when I’ve worked at organizations with bad cultures is a lack of managers actually looking into what is going on.

The book makes clear the distinction between this and micro managing. Your not going in to fix the problem, you don’t need to have the solution to a waste or productivity issue. Your going in to listen and understand, to see why things aren’t happening and bring the right people together to solve the right problems. The Toyota way says that a manager should wash his hands 3 times every day, because every day he is going to the factory floor 3 times to see what is happening.

This concept of go and see is the thing I most took away from the book. There are all kinds of tools for tracking performance and productivity, and many of them are great, but there is no substitute for actually going and seeing.

Conclusion

Overall I really enjoyed this book and would recommend it for anyone involved in management or just interested in understanding LEAN a bit better. You can pick it up on amazon here.

Development, Learning

How do I know if I’m good at programming?

I was talking to a very junior programmer recently and he asked me a great question. A question so good, it made me stop and think about my perspective on how learning happens. The question was:

“How do I know if I’m good at programming?”

I’ve often been asked the other side of this question “How do I get good at programming?”, or “What can I do to get good at programming”. The answer to which is some combination of experiment on your own projects, do courses, read books, work with good programmers and contribute to open source projects. But if you think about the problem in terms of “how do I know if I’m good?” it becomes much more of an engineering approach. You have a metric, optimize it.

Aside from practice, the most important thing for improving at any task is good feedback. When starting in a new domain without a good teacher, good feedback is difficult. A course for example may have exams or projects on which you get feedback. But once you’ve completed a course, how do you get the higher level feedback on your overall improvement? If you have a good mechanism for feedback, the answers for which thing to pursue next flow much more easily.

So how do I know if I’m good at programming? A good place to start is to ask “what is good code?”. If a programmer can’t produce good code, they aren’t a good programmer.

What is good code?

All code exists to complete tasks. The first mark of good code is that it completes the desired task. The task may vary massively in level of complexity, but the code can never do better than complete the task. Feedback for this is simple, “does the code achieve the desired aim?”. The code should only complete the desired task, there should not be other undesirable side-effects. Writing a good sets of unit tests around your code can act as a success metrics.

If you cannot successfully complete the task, here is your first good piece of feedback which, will show you exactly what you need to learn next. Identify the knowledge you lack and seek out the most relevant resource. Systems theory tells us if you’re not optimizing on the constraint, you’re wasting your energy. This is the constraint, learn only this thing.

Is the code readable?

A well written piece of code is a clean concise expression of ideas. It should be as easy as possible for another programmer to understand what you’ve written. Get familiar with idioms and syntactic sugar of your language. There might be nice ways to write what you’ve written in 3 lines in just one, while still maintaining readability. Make sure your code is correctly documented, explaining why not what is the code is doing. To test this, if you don’t have friends who can look at your code, I would recommend posting your code to https://codereview.stackexchange.com/ or some other similar sites. Yourself 6 months in the future is also a pretty good substitute for a stranger.

Is it easy to extend or modify?

It’s a lot of programmers favorite complaint, “the requirements changed”. This is reality, you’re not programming exam questions with clearly stated features and aims. In the real world requirements are always changing and that’s a good thing. If a task took you 3 months to complete and you have no new requirements, someone is not doing a good job. More time should bring in new information and requirements.

In an interview I like to ask a candidate to complete a fairly simple programming task, such as programming an elevator system. Once they’ve finished that, I ask them to implement a crazy feature that they could never have foreseen. There response to this, both interpersonal and technical, tells you a huge amount about their skill.

A good programmer should be planning for this. If you wrote a program to complete task x, see how easy it is to modify it to do task x and y but not when conditions k through q occur(unless k and m occur at the same time then execute y but not x). CS 101 concepts – like polymorphism and the difference between inheritance and composition – that seemed meaningless at the time, may now feel interesting.

Writing code to change is a thing you get a feel for with more experience, but don’t add more abstraction layers too soon. Premature abstraction leads things like Enterprise FizzBuzz (https://github.com/EnterpriseQualityCoding/FizzBuzzEnterpriseEdition).

Is the code Efficient?

Efficiency has a few different components, speed to finish and various resource components such as memory usage, CPU usage, etc. Luckily all of these are easy to track, and there are profilers in every language that can show you where program time and resources are being used. Get familiar with these tools and then see how much you can shave off these metrics. If you are reengineering an existing problem, such as writing your own LRU cache, you can look up the theoretical best performance and compare it to your own. Here you may want to start thinking about your code from a big-O perspective, it is also useful to know roughly how long different operations take https://people.eecs.berkeley.edu/~rcs/research/interactive_latency.html.

Can you write it quickly?

Especially early on in learning it’s important not to focus on speed. Competing in speed coding competitions is impressive, but when it comes to the craft of programming, it’s a poor way to learn. Speed should not be the goal, more the measure of progress. If you are mastering a domain then you should be able to write code that completes it’s task, is efficient, readable, and easy to extend in a shorter amount of time.

It is easy to measure time taken to complete a task, but that metric is difficult to act upon. Instead maybe try to analyze the amount time spent on the various sub tasks. Are these are the areas you need to deepen your understanding of? Maybe you are spending large amounts of time doing manual testing of your code, could this be speeded up through automation? You could start to look at the tools you are using. Your IDE has all kinds useful hotkeys that can improve speed and free up your brain from mechanical tasks so it can focus on the higher level problems.

Finishing up

If your code achieves all these things to a high standard then you are good at programming for that task. If not there are clear areas on which to improve. You can then look towards more complex tasks or tasks in other areas that you wish to be a good.

I would like to add one more thing to this article to finish. Given the hard limit on hours in the day, and a harder limit on productive hours, there is only so much a single programmer can do. Elon Musk has a reputation as a productive guy, but if he was the only engineer at PayPal they would not have gotten far. At a certain level if you want to build great things you need to be working in a team. At this point programming becomes a social activity. You want to be able program not just with your own hands and brain but on some level through the whole team you work with. At this point being a good programmer is about not just how good your code is, but about how good the code of people you work with is.

There are many ways to get feedback on this. After you code review a colleagues work, do they produce better code? The next question is have they just improved the specific code you reviewed or has their general code improved as well? Getting people to improve in this way is not simply a matter of technical feedback, but also motivation. Can you get them excited about the task, to understand why different improvements or approaches are important. Are you improving the overall skills of the people around you? The famous 27x research says that the best programmers are 27 times better than the worst. Well if you are a 7x programmer and you help 4 other people in your team go from 1x to 7x then you’re far more productive than a 27x.

For me these are essential skills of a good programmer and if you are achieving any of them even in some small way, you can sleep soundly knowing you know you are a good programmer.

Books, Learning, Project management

Book review: The Phoenix Project

This book is about IT project management, but unlike most management books, instead of being a series of case studies, it is written like a novel. The main character, Bill, is suddenly promoted from head of middleware technology to CTO at a time when the company, Parts limited, is failing apart at the seems.

What I found most surprising was that the book actually worked as a novel. I found myself genuinely caring about Bill and people he worked with and getting sucked in to the drama of delivering the project.

Also for a book about IT project management it’s amazing what a page turner it is. Especially in the early sections of the book where everything is going wrong. I found myself wondering how I would deal with his different problems which made me really wish there was a deathtrap dungeon style “choose your own adventure” book based around IT project management:

Your CEO is demanding you release the project at the pre-agreed date though you have major worries that it will not scale in production, do you:

Accept his demands release the change: turn to page 72
Refuse to do the release: turn to page 143

Maybe one day…

As a developer I also found it interesting learning how other aspects of the IT organization work. There is quite a lot of details on what a CIO, CEO and head of sales actually do.

Also though I’m sure the transformations they make in the book are possible, many companies have successfully made it, I found the time scale for these changes a little improbable and it seemed too easy to get buy in from people who were initially so sceptical.

Things to take away from the book

In order to mange anything you need to know what work is actually happening.
If you have a constraint on any system improving anything but that constraint is not actually going to make things better. In the book a single operations guy is the constraint for half the IT organization.
IT should be integrated into all aspects of an organization not seen as an external department in itself.
Operations and development need to be integrated.
Limit work in progress.
Understand The 3 ways:

Systems thinking: The flow of work from business requirements through development and ops to the customer.
Amplify feedback loops: Make sure issues found in any part of the process are fed back to where they can be fixed. If ops had a problem it may have started with dev. If dev had a problem maybe it needs to go back to the requirements.
Culture of continual experimentation and learning: Take the time to improve things, it will be worth it.

For IT there are 4 types of work:

Business projects
Internal projects
Operational changes
Unplanned work