Design pattern
A design pattern is a reusable, general solution structure for a recurring software design problem.
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 →
Effective Behavior-Driven Development
A reusable description of a solution to a recurring software design problem.
- How it is used
- Preserves successful solutions to recurring challenges for future use in similar contexts.
- How deep it goes
- Defines patterns and outlines documentation contents, but does not prescribe a single format.
- Examples
- Uses a team discussion about capturing automation-POC findings in a project wiki as its illustration.
- What you can do after
- Apply it by recording a solution’s problem, applicability, usage, trade-offs, and code examples.
Read how Effective Behavior-Driven Development 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 →
Microservices Patterns, Second Edition
A design pattern is a reusable solution to a recurring software design problem, often expressed through collaborating object-oriented elements.
- How it is used
- Solves recurring software architecture or design problems by defining collaborating software elements.
- How deep it goes
- Defines patterns through collaborating elements and outlines Strategy components without detailing implementation.
- Examples
- Uses banking overdraft policies with varying limits and fees to illustrate Strategy.
- What you can do after
- Evaluate a reusable solution by checking the context in which it applies.
Read how Microservices Patterns, Second Edition explains design pattern →
Also covered in
- Build High Value Software SystemsIn early access (MEAP)
- Vanilla WebIn early access (MEAP)
- Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
- The Design of Web APIs, Second Edition
- HTML5 in Action
- Web Components in Action
- Simple Object-Oriented Design: Create clean, maintainable applications
- AI-Powered Developer: Build software with ChatGPT and Copilot
- "Looks Good to Me"
- Distributed Machine Learning Patterns
- Coding with AI
- React in Depth
What to know first
- PythonPython is a high-level, general-purpose, dynamically typed programming language with readable syntax and support for multiple programming paradigms.
- abstractionAbstraction is a simplified representation that preserves relevant properties or behavior while omitting details unnecessary at a given level or for a given purpose.
- object-oriented programmingObject-oriented programming is a programming paradigm that organizes software around objects combining state and behavior, often using encapsulation, classes, inheritance, or polymorphism.
- HTMLHTML is the standard markup language for structuring content and elements in documents on the web.
Related concepts
- Model–view–controllerincludes · Model–view–controller is a software architectural pattern that separates application data and behavior, presentation, and interaction handling into model, view, and controller responsibilities.
- Singleton patternincludes · The Singleton pattern restricts a type or component to one shared instance within a defined scope and provides a way to access that instance.
- 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.
- model-view-presenterincludes · Model-View-Presenter is a user-interface architectural pattern that separates model logic, view concerns, and presentation coordination into distinct responsibilities.
- template method design patternincludes · The Template Method design pattern defines an algorithm’s structure and sequence of steps while allowing selected steps to be implemented or customized by subclasses.
- antipatternincludes · An antipattern is a recurring approach to solving a problem that may appear reasonable but tends to produce undesirable or counterproductive results in a given context.
Questions about design pattern
What is design pattern?
A design pattern is a reusable, general solution structure for a recurring software design problem.
Which Manning books explain design pattern?
Idiomatic Rust, API Design Patterns, Software Design for Python Programmers, Object-Oriented Software Design in C++, Functional Design and Architecture: Examples in Haskell, Effective Behavior-Driven Development, The Art of Code, Practices of the Python Pro and 1 more.
What should I know before learning design pattern?
Manning books that teach design pattern usually introduce Python, abstraction, object-oriented programming and HTML first.
What kinds of design pattern are there?
Kinds of design pattern include Model–view–controller, Singleton pattern, abstract factory design pattern, model-view-presenter, template method design pattern and antipattern.
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.








