Why Simpler Software Is Harder: Uncovering Essential vs Accidental Complexity

Preface

A group of clever diners discovered that the salt and pepper bottles were mislabeled and devised a clever swap using a napkin, a straw, and two plates; the waiter simply exchanged the caps, illustrating how a simple solution can be overlooked.

Essential vs Accidental Complexity

All software construction involves essential tasks and accidental tasks. -- Frederick P. Brooks, Jr., No Silver Bullet

Brooks distinguished between essential complexity, which is inherent to the problem, and accidental complexity, which arises from poor choices in methods or tools. While some domains (e.g., trading, payments) naturally have complex logic, many systems become needlessly tangled due to over‑engineered architectures.

As business functions are split into micro‑services, the scope of each service shrinks, prompting us to question whether the perceived complexity is real or merely a symptom of unnecessary abstraction.

We Tackle Simple Problems with Complexity

Even straightforward requirements—like automatically closing a door when a person leaves—can become a nightmare in legacy systems, where hidden dependencies cause unexpected side effects.

Maintenance costs dominate software engineering; a simple module can be ruined by over‑complication, leading teams to chase an illusory “future‑proof” design that actually degrades current simplicity.

TMF Extension Implementation

TMF, a reusable and extensible business‑mid‑platform, was initially used to support both domestic and overseas merchants. After three years, only two extensions existed, and a third request forced a quick strategy‑pattern addition while preserving the original TMF code, resulting in multiple overlapping frameworks for a handful of use‑cases.

PD’s Colorful Black

In an effort to help sales filter customers, a product team added over 80 tags with flexible set‑operations. Analysis showed most salespeople only needed 8 tags, making the extensive tagging system more burdensome than useful.

‘Complex’ Halo and ‘Simple’ Dim

Despite all their heroics, overtime, and dedication, they simply aren't getting much of anything done anymore. All their effort is now consumed with managing the mess. -- Robert C. Martin, Clean Architecture

Complex solutions often earn praise, while simple fixes go unnoticed, reinforcing a culture that favors intricate designs over elegant minimalism.

‘Simple’ Is Actually More Complex

Simple can be harder than complex: You have to work hard to get your thinking clean to make it simple. -- Steve Jobs

Even the iPhone’s minimalist home button draws inspiration from a toilet design, showing that simplicity does not mean ease; it requires disciplined decoupling and focus.

KISS Principle

Keep it Simple and Stupid -- Robert S. Kaplan

Kaplan, the creator of the Balanced Scorecard, emphasized that adding complexity is easy, while stripping it away is hard. Over‑reliance on “simple” slogans can still produce a “tactical tornado” of tangled features.

Unix Art

In 1974, the Unix system was described in the Communications of the ACM, spawning Linux, BSD, Solaris, and macOS. Doug McIlroy summed up Unix philosophy: a program should do one thing and do it well.

All the philosophy really boils down to one iron law, the hallowed ‘KISS principle’ of master engineers everywhere. -- Eric S. Raymond, The Art of Unix Programming

Unix exemplifies continuous practice of KISS, reminding developers that code is written for future readers, not just machines.

Lost Occam’s Razor

Entities should not be multiplied beyond necessity. -- William of Ockham, Occam's Razor

Occam’s Razor urges us to strip away unnecessary abstractions; in software, each extra piece of code adds maintenance risk far greater than its creation cost.

Maven SNAPSHOT

The SNAPSHOT versioning scheme (e.g., 1.0‑SNAPSHOT) cleanly distinguishes development builds from releases, offering a simple yet powerful way to manage evolving artifacts.

Because of Trust, Simplicity

Alibaba’s “trust‑based simplicity” philosophy argues that excessive rules breed friction; mutual trust reduces the need for complex controls and improves efficiency.

Conclusion

Complex problems attract applause, while simple, robust solutions often remain in the shadows. True mastery lies in embracing simplicity, decoupling concerns, and applying principles like KISS, Occam’s Razor, and essential‑vs‑accidental complexity to keep software maintainable.

References

Antifragile: Things That Gain from Disorder

The Art of Unix Programming

The Mythical Man‑Month

Clean Architecture