Simplicity
Simplicity is the quality of minimizing unnecessary complexity while preserving a system’s intended purpose and making it easier to understand.
Machine Learning System Design
Simplicity is the property of having relatively few concepts, dependencies, or implementation details that must be understood or managed.
- How it is used
- Guides ML API integration toward interfaces that are simple and predictable.
- How deep it goes
- Explains abstraction, parameter exposure, and configuration tradeoffs, but stops short of general REST or RPC design.
- Examples
- Uses predict-function designs and an overconfiguration-versus-underconfiguration comparison.
- What you can do after
- Apply it by designing ML APIs with few parameters, deliberate customization, and separation between ML and IO concerns.
Read how Machine Learning System Design explains simplicity →
Functional Design and Architecture: Examples in Haskell
Simplicity is a property of software that limits unnecessary complexity and makes its behavior easier to understand and change.
- How it is used
- Balances delivery goals and requirements against maintainability, readability, support cost, and future change.
- How deep it goes
- Explains simplicity through maintenance consequences and design trade-offs, then compares approaches without prescribing a universal winner.
- Examples
- Uses newcomer maintenance scenarios, maintainability-cost trends, trade-off diagrams, and comparisons of functional design approaches.
- What you can do after
- Evaluate design approaches consciously by weighing simplicity, boilerplate, convenience, language features, goals, and requirements.
Read how Functional Design and Architecture: Examples in Haskell explains simplicity →
The Art of Code
Simplicity is the quality of expressing software behavior with minimal unnecessary complexity while preserving its essential structure.
- How it is used
- Uses simplicity to control growing software complexity and preserve understandable, maintainable code.
- How deep it goes
- Defines simplicity, measures complexity, and develops six practical levers without detailing their full implementation.
- Examples
- Contrasts repeated null checks with an Optional mapping chain that returns a defined fallback.
- What you can do after
- Apply it through six levers that guide refactoring, maintenance, and code review.
API Design Patterns
Simplicity is the API design quality of exposing desired functionality straightforwardly without unnecessary user-facing complexity.
- How it is used
- Guides API usability by exposing desired functionality directly while containing advanced complexity.
- How deep it goes
- Contrasts RPC minimization, focused methods, advanced options, and versioning choices without specifying implementation internals.
- Examples
- Uses ExecuteAction(), DetectLanguage(), translation models, optional modelId, and highly granular version choices.
- What you can do after
- Evaluate API designs for hidden configuration, misplaced functionality, unnecessary choice, and burdensome advanced options.
Also covered in
- Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI
- Grokking Software ArchitectureIn early access (MEAP)
- Simple Object-Oriented Design: Create clean, maintainable applications
- Practices of the Python Pro
- Go by Example
What to know first
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- functionA function is a callable unit of program code that performs a computation or operation, can accept inputs, and may produce a result or side effect.
- conditional logicConditional logic is a programming technique that evaluates conditions to select among execution paths, actions, or result values.
- methodA method is a callable function or operation associated with a type, class, or object and invoked through that association.
Related concepts
- complexitycontrasts with · Complexity is the degree to which interacting elements or factors make a system or problem difficult to understand, predict, change, operate, or solve.
- consistencycontrasts with · Consistency is the degree to which related data, behavior, or results agree with one another and conform to applicable rules or expectations.
- expressive powerused by · Expressive power is the capacity of a model, language, or system to represent or convey a range and complexity of functions, patterns, distinctions, or ideas.
- kissequivalent to · KISS is a design and problem-solving principle that favors keeping systems and solutions as simple as their requirements permit.
- maintainabilityproduces · Maintainability is the degree to which software can be understood, modified, corrected, tested, or kept operational with reasonable effort over time.
- storytellingused by · Storytelling is a communication technique that conveys information, ideas, or experiences through a structured narrative.
Questions about simplicity
What is simplicity?
Simplicity is the quality of minimizing unnecessary complexity while preserving a system’s intended purpose and making it easier to understand.
Which Manning books explain simplicity?
Machine Learning System Design, Functional Design and Architecture: Examples in Haskell, The Art of Code and API Design Patterns.
What should I know before learning simplicity?
Manning books that teach simplicity usually introduce contract, function, conditional logic and method first.
What is the difference between simplicity and complexity?
Simplicity is the quality of minimizing unnecessary complexity while preserving a system’s intended purpose and making it easier to understand. Complexity is the degree to which interacting elements or factors make a system or problem difficult to understand, predict, change, operate, or solve.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.



