liveBook · Manning

Design pattern

A design pattern is a reusable, general solution structure for a recurring software design problem.

How 9 Manning books explain it

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.

Read how Idiomatic Rust explains design pattern →

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.

Read how API Design Patterns explains design pattern →

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.

Read how The Art of Code explains design pattern →

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

What to know first

Related concepts

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.