YAGNI principle
The YAGNI principle is a software design discipline of avoiding functionality or structure until a concrete need for it arises.
Machine Learning System Design
YAGNI is a software design principle that advises implementing functionality only when it is actually needed.
- How it is used
- Limits complexity and maintenance burden by discouraging functionality or abstraction that current requirements do not justify.
- How deep it goes
- Defines the principle and illustrates its tradeoff, but stops short of a formal decision procedure or implementation checklist.
- Examples
- Uses a metric pipeline, contrasting repetitive code with metaprogramming, and an overkill model that consumes business resources.
- What you can do after
- Apply YAGNI by choosing the simplest design that satisfies current requirements and resisting speculative abstractions.
Read how Machine Learning System Design explains YAGNI principle →
Build Financial Software with Generative AI (From Scratch)
YAGNI is the software-development principle of avoiding functionality and complexity until they are actually needed.
- How it is used
- Guides incremental project decisions by limiting unnecessary implementation and infrastructure during MVP development.
- How deep it goes
- Defines the principle and applies it to database setup, but stops short of a formal decision checklist.
- Examples
- Uses ACH-file storage, PostgreSQL, CloudBeaver, file or in-memory alternatives, and generated Docker Compose configurations.
- What you can do after
- Evaluate proposed features and infrastructure, then implement only the complexity justified by current project requirements.
Read how Build Financial Software with Generative AI (From Scratch) explains YAGNI principle →
Unit Testing Principles, Practices, and Patterns
YAGNI is the principle of avoiding implementation of functionality until it is actually needed.
- How it is used
- Guides decisions about speculative functionality, interfaces, and future-proofing during implementation.
- How deep it goes
- Explains the principle through opportunity cost, changing requirements, ownership cost, and the limits of single-implementation interfaces.
- Examples
- Uses single-implementation interfaces and hypothetical future functionality as examples of premature design.
- What you can do after
- Evaluate proposed abstractions and defer code whose need has not yet emerged.
Read how Unit Testing Principles, Practices, and Patterns explains YAGNI principle →
Related concepts
- pull modelkind of · A pull model is a pattern in which a consumer or recipient initiates requests for data, messages, configuration, or work according to its needs or readiness.
- strangler patternimplemented by · The strangler pattern is an incremental modernization approach that replaces a legacy system by gradually transferring its functionality to a new system until the legacy system can be retired.
- scalabilitycontrasts with · Scalability is the ability of a system, process, or method to accommodate increasing workload, size, or demand while maintaining acceptable operation.
- overengineeringaddresses · Overengineering is designing or implementing a solution with more complexity or capability than its requirements justify.
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.