Keeping Software Simple to speed up Software Development

Dec 5, 2024

Keeping Software Simple: Lessons from a Lean Assembly Line

Imagine walking into my kitchen. Over the years, I’ve accumulated dozens of tools: a bread maker that’s used twice a year, three different types of coffee makers (at least the ones that are visible), specialty knives for every possible cutting task (while using only 1 for 90% of the work), and countless other tools that seemed essential at the time (like a bottle top aerator). Now, opening a drawer feels like solving a puzzle, and finding the right tool takes longer than the actual cooking. Sounds familiar?

This kitchen scenario mirrors a common problem in software development: accidental complexity. Just as our kitchens can become cluttered with unnecessary tools, our software systems often become bloated with unnecessary features, tools, and complicated designs. But there’s hope, and it comes from an unexpected place: Lean manufacturing principles.

The Toyota Way: Less is More

In the 1950s, Toyota revolutionized manufacturing with a simple yet powerful idea: eliminate waste. They discovered that a clean, organized workspace with just the essential tools led to better cars, happier workers, and more efficient production. The Toyota Production System (TPS) emphasizes “just-in-time” production, visualizing workflows, and reducing waste. As Taiichi Ohno, the father of Lean Manufacturing, explained, “All we are doing is looking at the timeline… and reducing the time between receiving the order and collecting the cash.”. Taiichi Ohno explains in “Toyota Production System: Beyond Large-Scale Production,” the key was to “create flow” by removing obstacles and unnecessary steps.

Think about a well-organized professional kitchen. Chefs keep their most-used tools within arm’s reach, ingredients are prepared before cooking begins (mise en place), and everything has its place. This organization creates a smooth flow of work, much like Toyota’s assembly line.

Applying Toyota’s Wisdom to Software

So, how do we apply these manufacturing principles to something as abstract as software? Let’s break it down with some everyday analogies.

1. Keep It Simple: The Capsule Wardrobe Approach

Consider the concept of a capsule wardrobe: a small collection of essential clothing items that work well together. Instead of a closet stuffed with rarely-worn outfits, you have a carefully chosen selection that meets all your needs.

In software, this translates to what Martin Fowler calls “simple design” in his works on refactoring. Just as a capsule wardrobe avoids unnecessary items, good software design avoids unnecessary complexity. Each piece of code should serve a clear purpose, just like each item in your capsule wardrobe.

2. Loose Coupling: The Lego Principle

Think of Lego blocks. Each block is independent but can easily connect with others to create something bigger. More importantly, you can remove or replace blocks without affecting the entire structure.

This is what software architects mean by “loose coupling.” As described in “Domain-Driven Design” by Eric Evans, well-designed software systems work like Lego blocks: independent pieces that work together but aren’t tightly bound to each other. If one piece needs to change, you can modify it without taking apart the entire structure.

3. Open for Extension: The Garden Analogy

Imagine planning a garden. A wise gardener leaves space for new plants and ensures the garden can grow and evolve over time. They don’t concrete over every inch of soil. I wish that I applied this principle in the Spring of this year. My garden didn’t quite follow this principle.

In software, this principle is called “Open for Extension,” and it’s like leaving room in your garden for future additions. Bob Martin, in “Clean Code,” emphasizes this principle: design your software so you can add new features without having to modify existing code extensively.

Practical Steps to Reduce Complexity

1. Regular Cleanup

Just as you periodically clean out your closet or kitchen drawers, software needs regular cleanup. This process, known as refactoring, involves simplifying code without changing its behavior. It’s like reorganizing your kitchen to make it more efficient – the ingredients and tools are the same, but they’re arranged better.

2. Think in Modules

Consider how a good kitchen is organized: baking supplies in one area, cooking utensils in another, spices in their own space. This modular organization makes everything easier to find and maintain.

Similarly, well-organized software groups related functionality together. As described in “Domain-Driven Design,” this modular approach makes systems easier to understand and modify.

3. Resist the Urge to Overcomplicate

Remember the bread maker gathering dust in your kitchen? In software, we often face the temptation to add features or tools “just in case.” As Fred Brooks warns in “No Silver Bullet,” this tendency to over-engineer solutions is a major source of accidental complexity.

The Results: A Leaner, Healthier System

When we apply these principles, the benefits are similar to those discovered in Lean manufacturing:

Faster development (like a clean kitchen speeding up cooking)
Fewer bugs (like having an organized workspace reducing mistakes)
Easier maintenance (like being able to find and fix things in a well-organized home)
Happier developers (like the joy of cooking in a clean, organized kitchen)

Conclusion: The Joy of Simplicity

Just as Toyota found that lean manufacturing led to better cars, software teams are discovering that lean, simple systems lead to better software. The next time you’re tempted to add another layer of complexity to your system, remember the cluttered kitchen drawer. Sometimes, the best tool is the simplest one that gets the job done.

The beauty of Toyota’s principles isn’t in their complexity – it’s in their simplicity. Whether you’re organizing a kitchen, running a factory, or building software, the fundamental truth remains the same: less is often more.

References

Fred Brooks. No Silver Bullet: Essence and Accidents of Software Engineering.
Martin Fowler. Refactoring and Patterns of Enterprise Application Architecture.
Eric Evans, Domain-Driven Design: Tackling Complexity in the Heart of Software..
Bob C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship.
Ben Moseley. Various essays on simplicity in software design.
Ohno, Taiichi. Toyota Production System: Beyond Large-Scale Production. Productivity Press, 1988.
Liker, Jefrey. The Toyota Way, Second Edition: 14 Management Principles from the World’s Greatest Manufacturer, 2021.
Charnas, Dan. Work Clean: The Life-Changing Power of Mise-En-Place to Organize Your Life, Work and Mind.

Tags: post , accidental-complexity , lean , flow , ai