Abstraction
Abstraction is a simplified representation that preserves relevant properties or behavior while omitting details unnecessary at a given level or for a given purpose.
Get Programming: Learn to code with Python
An abstraction is a simplified representation that preserves essential characteristics while hiding unnecessary implementation detail.
- How it is used
- Helps organize larger programs by letting code use smaller tasks and objects without following every implementation detail.
- How deep it goes
- Defines abstraction through inputs, behavior, and outputs, then applies it to function docstrings and classes.
- Examples
- Uses online ordering, attendance documentation, a stack of pancakes, and card-game objects to show hidden details in use.
- What you can do after
- Build it from scratch by dividing a task into modules, documenting function behavior, and using classes to separate gameplay from object definitions.
Read how Get Programming: Learn to code with Python explains abstraction →
Simple Object-Oriented Design: Create clean, maintainable applications
An abstraction is a simplified model that exposes relevant behavior or structure while hiding unnecessary implementation details.
- How it is used
- Controls complexity by adding variable functionality without repeatedly modifying existing classes.
- How deep it goes
- Defines abstractions, contracts, extension points, decision triggers, and maintenance tradeoffs, while deferring implementation and design-pattern instruction.
- Examples
- Uses bookstore discount rules, growing conditional classes, databases, remote services, caching, and file storage.
- What you can do after
- Apply it by identifying variability or leaking details, then introducing a small stable contract and concrete implementations.
Deep Learning with R, Third Edition
An abstraction is a compact, reusable representation of underlying structures, principles, or invariants extracted from experience or data.
- How it is used
- Uses abstraction to explain how intelligence can adapt to novel situations by reusing and recombining experience.
- How deep it goes
- Defines acquisition and recombination, compares two types of abstraction, and discusses their roles in cognition and deep learning.
- Examples
- Illustrates prototypes with beetle categories and analogy with a car described as a horseless carriage.
- What you can do after
- Enables readers to evaluate how abstraction and recombination might support generalization beyond familiar examples.
Read how Deep Learning with R, Third Edition explains abstraction →
Robotics for Programmers
An abstraction is a simplified interface or representation that hides irrelevant implementation details.
- How it is used
- Keeps raw sensor details out of robot movement and planning logic.
- How deep it goes
- Shows encapsulation through sensor predicates, subsystems, conversions, and thresholding, without developing larger layered robot architectures.
- Examples
- Uses collision switches, analog distance conversion, coffee supply thresholds, and computer-activity detection.
- What you can do after
- Apply it by replacing raw input checks with meaningful sensor interfaces and domain-level predicates.
100 Go Mistakes and How to Avoid Them
A software design technique that represents essential behavior or structure while hiding implementation details.
- How it is used
- Uses abstraction to make Go code reusable and decouple it from concrete implementations.
- How deep it goes
- Explains interface behavior and design trade-offs through examples, including unnecessary indirection and interface-return exceptions.
- Examples
- Illustrates abstraction with I/O copying and an in-memory test, sorting behavior, and a customer service storage dependency.
- What you can do after
- Evaluate when a Go interface improves reuse or testing and when it adds unnecessary complexity.
Read how 100 Go Mistakes and How to Avoid Them explains abstraction →
Spring Start Here, Second Edition
An abstraction is a representation that separates the behavior an object requires from the details of how that behavior is implemented.
- How it is used
- Uses abstractions to decouple application components and provide a common approach to persistence.
- How deep it goes
- Works through interface-based design and Spring bean selection, then introduces common persistence abstractions.
- Examples
- Uses a comment-publishing service with repository and notification interfaces, including email and push implementations.
- What you can do after
- Apply abstractions using Java interfaces and Spring dependency injection, including selection among matching beans.
Read how Spring Start Here, Second Edition explains abstraction →
Grokking Software Architecture
An abstraction is an interface or simplified representation that exposes relevant behavior while hiding implementation details.
- How it is used
- Uses shared contracts to separate business logic from implementation details and make systems easier to change and test.
- How deep it goes
- Explains dependency inversion through before-and-after implementations and highlights hidden performance and debugging costs.
- Examples
- Uses a coach and player contracts, database fakes, payment integrations, and ORM-generated SQL to illustrate abstraction.
- What you can do after
- Evaluate and understand where contracts aid substitution and where hidden implementation details may complicate debugging.
Read how Grokking Software Architecture explains abstraction →
Unit Testing Principles, Practices, and Patterns
An abstraction is a representation that captures common behavior across multiple implementations while hiding implementation-specific details.
- How it is used
- Guides interface design, dependency boundaries, and extraction of complex logic for maintainable unit tests.
- How deep it goes
- Distinguishes genuine from speculative abstractions and demonstrates extraction, but stops short of formal abstraction theory.
- Examples
- Uses single-implementation interfaces and extracts Order.GetPrice into PriceCalculator.
- What you can do after
- Apply abstraction by recognizing real variation, avoiding speculative interfaces, and extracting complex logic into independently testable classes.
Read how Unit Testing Principles, Practices, and Patterns explains abstraction →
BDD in Action, Second Edition
Abstraction is the software design practice of separating an interface or high-level behavior from the details of its implementation.
- How it is used
- Improves automated acceptance tests by separating readable business rules from volatile UI and integration details.
- How deep it goes
- Explains layered decomposition and reusable abstractions, stopping short of a general software-design treatment beyond test automation.
- Examples
- Uses flight-search scenarios, sign-up task decomposition, Page Elements, and Serenity/JS interactions such as Click.on and Text.of.
- What you can do after
- Build it from scratch by modeling business tasks as reusable layers that keep acceptance scenarios readable and implementations maintainable.
Read how BDD in Action, Second Edition explains abstraction →
LLMs in Production
An abstraction is a generalized representation that captures relevant properties while omitting particular details.
- How it is used
- Frames language modeling as a sequence of representational layers whose omissions affect how meaning reaches a working model.
- How deep it goes
- Traces abstraction from cognition through programming representations and meaning-making, but stops short of fully developing semiotic philosophy.
- Examples
- Uses feelings, language, mathematics, binary, assembly, C, Python, Java, and recursive semiotic triangles as layered examples.
- What you can do after
- Evaluate how information loss and failure points accumulate between human experience, language, programming, and model output.
Learn Haskell by Example
A programming abstraction is a simplified interface or representation that hides implementation details while exposing useful behavior.
- How it is used
- Uses abstraction to turn complexity into reusable functionality and model domain problems without irrelevant implementation details.
- How deep it goes
- Explains abstraction through Haskell constructs, practical use cases, and a music-modeling design, while leaving low-level implementations behind the interface.
- Examples
- Uses reusable sorting, UNIX-style tools, document conversion, and a digital music box modeled with types, values, functions, and transformations.
- What you can do after
- Evaluate/understand when to hide irrelevant details and organize reusable Haskell models around a problem domain.
Machine Learning System Design
Abstraction is a technique for managing complexity by exposing higher-level operations while encapsulating lower-level implementation details.
- How it is used
- Uses abstraction to manage software complexity and shape simple, predictable APIs for machine learning systems.
- How deep it goes
- Defines abstraction, contrasts upfront architecture with agile change, and works through leaky interfaces, defaults, overrides, and model versioning.
- Examples
- Uses black-box software blocks, prediction functions, configurable parameters, and versioned model interfaces.
- What you can do after
- Apply it via API design by hiding unnecessary internals, choosing useful defaults, and preserving targeted controls for debugging.
Read how Machine Learning System Design explains abstraction →
The Art of Code
Abstraction is the representation of essential behavior or properties while concealing implementation details that are not necessary to a given user or level of reasoning.
- How it is used
- Separates system behavior from implementation to reduce cognitive load and keep growing code organized.
- How deep it goes
- Demonstrates interface-based refactoring and tradeoffs, but stops short of formal abstraction theory or debugging techniques.
- Examples
- Uses PDF, CSV, and Excel report generators to contrast conditional branching with a shared interface.
- What you can do after
- Apply abstraction via interfaces and polymorphism, while containing unavoidable complexity behind focused boundaries and documentation.
Designing AI Systems
Model abstraction is an interface design that hides provider-specific model details so applications can work with interchangeable models.
- How it is used
- Protects AI applications from vendor lock-in while supporting routing, fallback, experimentation, and cost optimization.
- How deep it goes
- Explains the shared interface, adapters, provider-format differences, routing, and fallback, but does not provide adapter code.
- Examples
- Contrasts OpenAI, Anthropic, and Google Gemini request, response, system-prompt, and token formats.
- What you can do after
- Apply it via a Model Service to add providers, evaluate models, and switch configurations without rewriting application logic.
Python Workout, Second Edition
Abstraction is the representation of functionality at a level that hides lower-level implementation details.
- How it is used
- Reduces repetition and cognitive load by packaging behavior behind names, functions, objects, and interfaces.
- How deep it goes
- Explains the purpose and maintenance benefits of abstraction through functions and objects, but does not develop formal abstraction theory.
- Examples
- Uses repeated code, named programming actions, a bookshelf, and a replaceable average calculation to illustrate abstraction.
- What you can do after
- Apply abstraction by packaging repeated behavior in functions and separating object interfaces from changeable implementations.
Read how Python Workout, Second Edition explains abstraction →
Shipping Go: Develop, deliver, discuss, design, and go again
An abstraction is a simplified interface or representation that exposes essential behavior while hiding implementation details.
- How it is used
- Uses abstractions to isolate integrations, support testing, and choose how much deployment infrastructure developers manage.
- How deep it goes
- Explains interfaces and deployment trade-offs with analogies, but stops short of detailed implementation code.
- Examples
- Uses electrical outlets, integration stubs and mocks, cloud service layers, buildpacks, and containers as concrete examples.
- What you can do after
- Apply it via interfaces to modularize code, substitute test dependencies, and evaluate deployment trade-offs.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains abstraction →
Deep Learning with Python, Third Edition
An abstraction level that exposes simpler interfaces while hiding low-level implementation details.
- How it is used
- Explains how intelligence extracts reusable structures and recombines them to handle uncertainty, novelty, perception, and reasoning.
- How deep it goes
- Distinguishes acquisition from recombination and develops similarity-based prototypes versus exact structural matches, without implementation details.
- Examples
- Uses beetle clustering and prototypes, ARC-AGI, mathematical proof, and object recognition to contrast abstraction modes.
- What you can do after
- Evaluate unfamiliar problems by separating reusable abstraction acquisition from on-the-fly recombination and choosing similarity or structural comparison.
Read how Deep Learning with Python, Third Edition explains abstraction →
Machines that Think
Abstraction is the formation of a more general representation by omitting incidental details while preserving relevant structure.
- How it is used
- Uses abstraction to examine generalization, simplified neural models, and the limits of language-mediated experience.
- How deep it goes
- Compares compression, human abstraction, and simplified artificial neurons without giving a mathematical implementation.
- Examples
- Uses a computational neuron and a language model’s description of a cat to illustrate different reductions.
- What you can do after
- Evaluate/understand how useful generalization can coexist with incidental correlations and limits on grounding or understanding.
Platform Engineering on Kubernetes
An infrastructure abstraction is a simplified interface that hides the implementation details of underlying infrastructure resources.
- How it is used
- Reduces developer cognitive load by presenting infrastructure as simple platform resources instead of underlying cloud tooling.
- How deep it goes
- Defines interfaces, parameters, and JSON representation, but does not detail the complete provisioning implementation.
- Examples
- Uses Conference development environments with infrastructure installation and frontend debugging as configurable parameters.
- What you can do after
- Build it from scratch by defining a small environment API and encoding requests as JSON or YAML.
Read how Platform Engineering on Kubernetes explains abstraction →
Build High Value Software Systems
A software-design technique that hides implementation details behind a simplified model or interface.
- How it is used
- Removes indirection that does not serve a stated requirement or demonstrated need.
- How deep it goes
- Distinguishes unnecessary layers from required behavior and gives a specification-based deletion heuristic.
- Examples
- Illustrates an order service with caching, validation, and invented tax logic.
- What you can do after
- Apply specification-based questions to identify and remove abstractions that add no required value.
Read how Build High Value Software Systems explains abstraction →
The Coder Cafe
An abstraction is a simplified representation that exposes essential features while hiding implementation details.
- How it is used
- Guides software design toward interfaces, modules, and functions that expose useful behavior while controlling complexity.
- How deep it goes
- Defines abstraction, identifies common forms, and explains readability and premature-design consequences without examining implementation internals.
- Examples
- Uses interfaces, modules, functions, generic future-facing designs, meaningful abstractions, and readable code as examples.
- What you can do after
- Evaluate abstractions for clarity and current value, then apply them through meaningful interfaces, modules, functions, or classes.
Software Architecture Decision-Making
An abstraction is a deliberately simplified interface or representation that hides implementation details and permits variation behind a stable boundary.
- How it is used
- Guides architectural decisions about when complexity and stable boundaries are warranted during delivery.
- How deep it goes
- Explains trade-offs, diagnostic questions, and deferral strategies but stops short of implementation mechanics.
- Examples
- Uses an internal workflow system, speculative services, messaging, future scale, and a perfection-drift diagnostic table.
- What you can do after
- Evaluate abstraction choices using evidence, reversal cost, concrete variation, and the team's ability to operate them.
Read how Software Architecture Decision-Making explains abstraction →
The Art of Unit Testing 3e
A simplified boundary that hides implementation details while exposing a controlled interface to underlying behavior or dependencies.
- How it is used
- Protects maintainability by placing controlled internal interfaces between application code, third-party dependencies, and tests.
- How deep it goes
- Shows dependency wrappers and test factories with JavaScript examples, while deferring broader architecture discussion.
- Examples
- Uses logging adapters, a moment.js date dependency, fake weekend dates, and test factories for verifier construction.
- What you can do after
- Apply it through internal adapters and test helpers to limit widespread changes when external APIs or constructors change.
Data-Oriented Programming in Java
An abstraction is a simplified representation that hides selected implementation details behind a more general concept or interface.
- How it is used
- Guides architectural design by delaying generalization and focusing first on data ownership, movement, and boundaries.
- How deep it goes
- Contrasts premature and data-oriented abstraction through a repository refactoring, but stops short of formal abstraction theory.
- Examples
- Uses a FileRepository, typed domain collections, and a generic parser-based loader to expose abstraction trade-offs.
- What you can do after
- Evaluate abstractions by whether they clarify data boundaries rather than merely increase reuse or extensibility.
Read how Data-Oriented Programming in Java explains abstraction →
Also covered in
- Grokking Simplicity
- Practices of the Python Pro
- Functional Design and Architecture: Examples in Haskell
- Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
- Elixir in Action, Third Edition
- Build AI-Enhanced Web Apps
- Causal AI
- Developer Experience on KubernetesIn early access (MEAP)
- Investing for Programmers
- 100 SQL Server Mistakes and How to Avoid Them
- Vibe EngineeringIn early access (MEAP)
- ASP.NET Core in Action, 3e
What to know first
- 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.
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- software testingSoftware testing is the systematic evaluation of software under specified inputs or conditions to assess its behavior against expected results or requirements and identify defects.
Related concepts
- event processingused by · Event processing is the computation that captures, interprets, filters, transforms, routes, or responds to discrete events as they arrive or occur.
- leaky abstractionincludes · A leaky abstraction is an abstraction whose behavior, limitations, or interface exposes details of its underlying implementation to its users.
- object-oriented programmingpart of · Object-oriented programming is a programming paradigm that organizes software around objects combining state and behavior, often using encapsulation, classes, inheritance, or polymorphism.
- dependency inversionused by · Dependency inversion is a software design principle in which high- and low-level components depend on abstractions rather than directly on implementation details.
- contractincludes · A contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- cognitive loadaddresses · Cognitive load is the mental effort required to process information, retain it in working memory, or perform a task.
Questions about abstraction
What is abstraction?
Abstraction is a simplified representation that preserves relevant properties or behavior while omitting details unnecessary at a given level or for a given purpose.
Which Manning books explain abstraction?
Get Programming: Learn to code with Python, Simple Object-Oriented Design: Create clean, maintainable applications, Deep Learning with R, Third Edition, Robotics for Programmers, 100 Go Mistakes and How to Avoid Them, Spring Start Here, Second Edition, Grokking Software Architecture, Unit Testing Principles, Practices, and Patterns and 16 more.
What should I know before learning abstraction?
Manning books that teach abstraction usually introduce function, language model, contract and software testing first.
What kinds of abstraction are there?
Kinds of abstraction include leaky abstraction and contract.
What is abstraction part of?
Abstraction is part of object-oriented programming. Object-oriented programming is a programming paradigm that organizes software around objects combining state and behavior, often using encapsulation, classes, inheritance, or polymorphism.
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.























