liveBook · Manning

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.

How 24 Manning books explain it

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.

Read how Simple Object-Oriented Design: Create clean, maintainable applications explains abstraction →

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.

Read how Robotics for Programmers explains abstraction →

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.

Read how LLMs in Production explains abstraction →

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.

Read how Learn Haskell by Example explains abstraction →

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.

Read how The Art of Code explains abstraction →

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.

Read how Designing AI Systems explains abstraction →

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.

Read how Machines that Think explains abstraction →

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.

Read how The Coder Cafe explains abstraction →

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.

Read how The Art of Unit Testing 3e explains abstraction →

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

What to know first

Related concepts

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.