Today I received my copy of Implementing Lean Software Development: From Concept to Cash by Mary and Tom Poppendieck, and so far it has been a decent read.

The first chapter is rather interesting as it takes an approach of how we got to agile software development, startling by taking a tour of the evolution of industrial production, beginning in 1785 with Honore Blanc and his weapons that consisted of interchangeable parts, to Henry Ford and his assembly line production that emphasized interchangeable people, and ends with a quick discussion on Toyoda (and Toyota) and the production system developed there, which came to be known as The Toyota Production System.

With the Toyota Production System (which was apparently quickly adopted in many industries in the 80s) we learn of several key concepts that have parallels in agile software development. Just-In-Time flow emphasizes manufacturing only “what is needed, when it is needed, and in the amount needed”, which for those of us familiar with agile are used to the term YAGNI or “do the simplest thing that could possibly work” (as Gary Brown always tries to drill into our heads at Carfax).

Zero-inspection is another part of the process, specifically autonomation. In the Toyota Production System, this translates that no one should be looking for a machine to break or testing a product to see if it is good, but rather, should design systems to be mistake-proof. What is highlighted here is that “Mistake-proofing assumes any mistake that can be made will eventually be made, so take the time at the start to make the mistake impossible.” This ties into the principles of TDD, where we try to “test everything that could possibly break” as we write our code, rather than leaving the testing as an afterthought, that is, looking for our code to break or testing to see if a product is good.

The focus of the rest of the chapter continues to follow Toyota and what became to be known as Lean Production. What’s amusing about Lean Production is that it is noted that the new model faced fierce resistance from the old model, and a lot of companies tried to implement only part of it, seeing some aspects of it unrealistic and counterintuitive. Just the same reaction to a certain software development methodology we all know. ;)

What is also interesting is that it is also stated that product development is acknowledge creation process, and that many projects at Toyota focused on having engineers learn and design as they went rather than do everything up front…. just like in XP we avoid BDUF. Finally, the chapter ends with a few paragraphs on Lean Software Development, stating that is in fact a form of product development and, as such, can learn a lot from what was discovered in previous decades in lean manufacturing and lean product development.

Overall, I found the comparisons and parallels between Agile and Lean Product Development very fascinating, and rather amusing to consider that Agile isn’t new at all, but rather an adaptation of best practices in industrial manufacturing to software development, where they are just as relevant as they were for Toyota.

Anyhow, stay tuned for my summary of Chapter 2. :D

If you're new here, you may want to subscribe to my RSS feed. Thanks for visiting!


This entry was posted on Tuesday, October 3rd, 2006 at 9:10 am and is filed under Agile Software Development. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.