Good Taste Engineering Principle
Good taste in engineering means seeing the simple elegant solution that others miss beneath complexity
Linus Torvalds, creator of Linux and Git, reveals that the difference between good engineers and great engineers is taste—the ability to see the simple, elegant solution hidden beneath the complex one. Using a code example, Torvalds shows two implementations of a linked list removal: one with special cases and conditional logic, and one that eliminates the special cases entirely through a more fundamental understanding of the data structure. The second approach is not just shorter but fundamentally better because it removes unnecessary complexity at the conceptual level. Torvalds argues that this taste—the ability to recognize and create simplicity—is what separates transformative engineering from competent engineering, and it applies equally to operating system kernels and to any system design challenge.
- Good taste means eliminating special cases through deeper understanding of the problem
- The elegant solution is always simpler, not more clever
- Complexity is a cost that compounds at the system level
- Vision is the ability to see where you want to end up and work backward from there
- The best engineers do not add features—they remove unnecessary complexity
- Recognize Unnecessary Complexity as a Design SmellWhen your solution requires special cases, conditional branches, and workarounds, treat these as signals that you have not yet found the right abstraction. The presence of special cases usually means you are working at the wrong level of abstraction. Step back and look for a more fundamental approach that makes the special cases disappear entirely rather than handling them individually.Pro tipWhen you find yourself writing an if-else chain, ask: is there a way to restructure this so the conditional is unnecessary? The answer is often yes.WarningNot all complexity is unnecessary. Some problems are genuinely complex. The skill is distinguishing essential complexity from accidental complexity.
- Develop Taste Through Exposure to Elegant SolutionsGood taste in engineering, like taste in any craft, develops through exposure to both excellent and poor examples. Study well-designed systems and understand why they feel right. Study poorly designed systems and identify what makes them feel wrong. Over time, you develop an intuition for elegance that guides your own design decisions. Torvalds developed his taste through decades of reading and evaluating code, not through following rules.Pro tipWhen you encounter a solution that feels surprisingly simple for a complex problem, study it carefully. Understand why it works and what insight made the simplicity possible.
- Optimize for the System, Not the ComponentGood taste requires thinking at the system level, not just the component level. A solution that is locally optimal for one component can introduce complexity that makes the overall system worse. Torvalds evaluates code contributions not just on whether they work but on how they affect the overall kernel. The discipline of thinking at the system level while working at the component level is what produces truly elegant engineering.Pro tipBefore finalizing any solution, ask: how does this affect everything else it connects to? The best solutions reduce complexity not just locally but systemically.WarningSystem-level thinking can cause analysis paralysis. Set a time limit for design exploration, then commit and iterate.
Torvalds shows two ways to remove an item from a linked list. The typical approach uses a special case for the head of the list and a different case for middle items, requiring conditional logic. The elegant approach uses an indirect pointer that makes both cases identical, eliminating the conditional entirely. The second approach is not just shorter—it reveals a deeper understanding of the data structure that makes the special case conceptually unnecessary. This is what Torvalds means by good taste: the ability to see the solution that makes complexity disappear.
Torvalds developed this perspective through decades of maintaining Linux, where he reviews thousands of code contributions and must constantly choose between approaches that work and approaches that are right. His famous exacting standards for code quality come not from pedantry but from the practical understanding that in a system with millions of lines of code, complexity in individual components multiplies into unmanageable chaos at the system level. Good taste at the micro level is a survival requirement at the macro level.