Design pattern
A design pattern is a reusable, general solution structure for a recurring software design problem in a particular context.
Idiomatic Rust
A reusable, high-level software design abstraction that provides a familiar template for solving a class of common programming problems.
- How it is used
- Provides recognizable approaches to recurring design problems, making code easier to write, assess, and understand.
- How deep it goes
- Defines shared properties and tradeoffs, then points to concrete Rust patterns rather than prescribing one universal implementation.
- Examples
- Names builders, fluent interfaces, observers, commands, newtype, and RAII as patterns to recognize or explore.
- What you can do after
- Build it from scratch by combining Rust features, or evaluate whether an established pattern fits a design problem.
API Design Patterns
A design pattern is a reusable, established solution structure for recurring software design problems.
- How it is used
- Structures recurring API problems with adaptable blueprints that reduce the need for large structural changes.
- How deep it goes
- Defines reusable blueprints and outlines names, rules, motivation, implementation, and trade-offs without detailing a specific implementation.
- Examples
- Uses a shed-building analogy and an input/output pattern for moving data between storage sources and destinations.
- What you can do after
- Evaluate pattern fit and trade-offs before applying an API design pattern or choosing custom software.
Software Design for Python Programmers
A design pattern is an industry-proven model for creating a solution to a recurring software design problem.
- How it is used
- Solves recurring software architecture problems by guiding custom designs built from established models.
- How deep it goes
- Defines patterns and demonstrates their application through before-and-after examples, but stops short of treating any pattern as directly reusable code.
- Examples
- Uses publisher–subscriber components, sports reports, and interchangeable sports recruitment and venue strategies as examples.
- What you can do after
- Apply it through before-and-after examples to design flexible solutions and assess whether architectures use appropriate industry-standard patterns.
Read how Software Design for Python Programmers explains design pattern →
Object-Oriented Software Design in C++
A design pattern is an industry-proven reusable model for solving a recurring software design or architecture problem.
- How it is used
- Solves recurring software architecture problems with reusable models that support flexible, maintainable applications.
- How deep it goes
- Defines patterns and illustrates their architectural roles, but defers detailed implementation to individual pattern treatments.
- Examples
- Uses publisher–subscriber, Singleton, Composite, and Decorator as concrete architecture problems and solution models.
- What you can do after
- Apply industry-proven patterns to develop custom solutions for common architecture problems and manage change.
Read how Object-Oriented Software Design in C++ explains design pattern →
Functional Design and Architecture: Examples in Haskell
An object-oriented pattern is a language-agnostic, reusable solution structure for a recurring object-oriented design problem.
- How it is used
- Uses reusable structures to reduce risk while designing large object-oriented applications and resolving recurring problems.
- How deep it goes
- Defines patterns, distinguishes them from idioms, and works through an Adapter implementation while stopping short of a complete catalog.
- Examples
- Demonstrates an Adapter that converts Kelvin thermometer data into Celsius through an ISensor-compatible interface.
- What you can do after
- Apply it by translating a language-agnostic pattern into an object-oriented language and evaluating functional alternatives.
Read how Functional Design and Architecture: Examples in Haskell explains design pattern →
The Art of Code
A design pattern is a named, reusable solution structure for a recurring software design problem whose implementation can vary across languages and frameworks.
- How it is used
- Uses named reusable structures to shape implementations that can accommodate changing requirements and technologies.
- How deep it goes
- Defines pattern intent, catalog examples, and language variation, but does not provide a complete implementation of each pattern.
- Examples
- Uses Singleton, Builder, Strategy, Factory, Circuit Breaker, and a condition-heavy shipping calculation as examples.
- What you can do after
- Apply named reusable solutions to recurring design problems while varying their implementations across languages and frameworks.
Practices of the Python Pro
A design pattern is a reusable solution structure for recurring problems in software design, expressed in terms of objects, components, or their interactions.
- How it is used
- Uses named patterns to decouple application layers and establish a shared vocabulary for software design.
- How deep it goes
- Explains the pattern concept, maps one command-pattern example, and introduces UML without surveying implementations in depth.
- Examples
- Uses Bark’s persistence layer, commands, menu options, client module, and a UML diagram as concrete examples.
- What you can do after
- Apply it via named patterns to separate requesting code from actions and judge whether a pattern feels appropriate in Python.
Read how Practices of the Python Pro explains design pattern →
Related concepts
- Singleton patternincludes · The Singleton pattern restricts a type or component to one shared instance within a defined scope and provides a way to access it.
- template method design patternincludes · The Template Method design pattern defines an algorithm's fixed sequence in a superclass while allowing subclasses to implement or customize selected steps.
- abstract factory design patternincludes · The Abstract Factory is a creational design pattern that provides an interface for creating families of related objects without specifying their concrete classes.
- backend-for-frontend patternincludes · The backend-for-frontend pattern provides a backend service tailored to a particular frontend or client, adapting or aggregating interactions with underlying services.
- retrieval-augmented generationincludes · Retrieval-augmented generation is a technique that retrieves relevant information from external sources and supplies it as context to a generative model when producing an output.
- event-driven architectureincludes · Event-driven architecture is a software architectural style in which components communicate or initiate processing by producing and responding to events.
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.