liveBook · Manning

Complexity

Complexity is the degree to which interacting elements or factors make a system or problem difficult to understand, predict, change, operate, or solve.

How 15 Manning books explain it

Architecture Modernization: Socio-technical alignment of software, strategy, and structure

System complexity is the degree to which a software system's components, integrations, data, and behaviors interact in difficult-to-understand ways.

How it is used
Guides subdomain investment, team ownership, and architectural boundary decisions during modernization.
How deep it goes
Defines model complexity as lifecycle effort, offers collaborative assessment questions, and distinguishes local from global complexity without a precise scoring formula.
Examples
Uses an accounting-system boundary exercise, an airline modernization, and a character limit enforced across legacy layers.
What you can do after
Practice/perform collaborative subdomain assessment and use real scenarios to test whether proposed boundaries reduce overall complexity.

Read how Architecture Modernization: Socio-technical alignment of software, strategy, and structure explains complexity →

Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform

The difficulty of understanding, changing, operating, scaling, and coordinating the components and interactions of a software system.

How it is used
Uses complexity management to motivate microservices architecture and incremental development as applications grow.
How deep it goes
Explains architectural tradeoffs and service sizing, then gives practical guidance for keeping iterations simple and recoverable.
Examples
Follows a single microservice through Docker packaging, multi-service development with Docker Compose, and deployment to Kubernetes.
What you can do after
Evaluate microservice and monolith tradeoffs, including initial difficulty, later conversion costs, and service sizing.

Read how Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform explains complexity →

Vibe Engineering

Software complexity is the degree of difficulty involved in understanding, changing, operating, or coordinating a software system.

How it is used
Frames complexity as a cost to weigh against measured performance gains.
How deep it goes
Explains code and operational costs through a benchmarked concurrency example, then gives measurement and workload checks.
Examples
Compares sequential and parallel account lookups and examines LLM-generated concurrent strategies under assumed workloads.
What you can do after
Evaluate performance proposals against workload evidence and the operational costs they introduce.

Read how Vibe Engineering explains complexity →

Sutskever's List

Model complexity is the structural and parametric richness of a model that determines the range of functions it can represent.

How it is used
Uses complexity to distinguish model size from the information cost of a learned fit and to examine generalization.
How deep it goes
Explains a bit-based training objective, its weight distributions and KL cost, then interprets complexity through double descent without a full derivation.
Examples
Compares cream mixing in coffee, peptide prediction with and without a description-length penalty, and ResNet test error across widths.
What you can do after
Evaluate/understand why penalizing weight information can improve generalization and why increasing model width need not steadily increase test error.

Read how Sutskever's List explains complexity →

Effective Conversational AI

The degree of structural difficulty in a conversational task or interaction, determined by the number, interdependence, length, branching, or sequencing of steps.

How it is used
Guides decisions about which conversational steps help users complete a task and which create avoidable friction.
How deep it goes
Works through claim-search and delivery redesigns with observed outcomes, rather than specifying an implementation method.
Examples
Contrasts FAQ and self-service balance checks, then follows a claim lookup shortened by conditional questions and earlier delivery of results.
What you can do after
Practice/perform flow simplification by removing unnecessary requests, deferring optional choices, and checking completion and escalation outcomes.

Read how Effective Conversational AI explains complexity →

Machine Learning System Design

The degree of structural or parametric richness in a machine learning model that determines the range of functions it can represent.

How it is used
Uses learning curves to diagnose underfitting or overfitting and choose an appropriate model size.
How deep it goes
Explains complexity through parameters, performance curves, and bias-variance behavior, without mathematical derivations.
Examples
Uses tree depth, feature count, regularization strength, neural-network layers, and parameter-count curves as concrete complexity examples.
What you can do after
Diagnose model-size problems with learning curves and select complexity settings using validation performance.

Read how Machine Learning System Design explains complexity →

React in Depth

Software complexity is the degree to which a software system has many interacting elements, conditions, and behaviors that make it harder to understand and maintain.

How it is used
Uses complexity to assess expanding React components, styling choices, and the scope of an application project.
How deep it goes
Works through concrete implementation and team trade-offs rather than defining a quantitative complexity metric.
Examples
Illustrates complexity with a feature-rich breakfast-ordering radio group, a shared CSS file, and three expense-tracker starting points.
What you can do after
Evaluate/understand it by identifying where added features or tooling increase maintenance effort and choosing an achievable implementation scope.

Read how React in Depth explains complexity →

"Looks Good to Me"

The degree to which a code structure has numerous or intricate elements and relationships that make it harder to understand or change.

How it is used
Guides teams in deciding what code reviews should examine for understandability, future changeability, and maintainable structure.
How deep it goes
Defines review questions and recognizable structural symptoms, then stops short of prescribing a universal refactoring method.
Examples
Uses giant classes, excessive layers, over-abstraction, unclear intent, and temporary workarounds as review examples.
What you can do after
Evaluate code during review and identify opportunities to make it clearer and easier to change.

Read how "Looks Good to Me" explains complexity →

Practices of the Python Pro

A complexity measurement is a quantitative assessment of the structural or computational complexity of software or an algorithm.

How it is used
Uses quantitative measurements to identify code worth refactoring and monitor whether maintainability improves.
How deep it goes
Explains cyclomatic complexity through execution paths, control-flow graphs, conditionals, loops, nodes, and edges.
Examples
Uses a Python sentence-checking function containing input normalization, a loop, a length condition, and early returns.
What you can do after
Diagnose/debug with it: identify high-complexity code and prioritize refactoring by tracking scores over time.

Read how Practices of the Python Pro explains complexity →

The Art of Code

Software complexity is the degree of difficulty involved in understanding, changing, and maintaining a software system.

How it is used
Frames complexity as the problem that simplicity practices, metrics, and maintenance decisions must continually control.
How deep it goes
Defines causes and essential versus accidental forms, then measures structural and cognitive difficulty without detailing metric algorithms.
Examples
Uses deadline shortcuts, overengineering, inconsistent solutions, changing requirements, external dependencies, and six simplicity levers as concrete illustrations.
What you can do after
Diagnose complexity with cognitive-complexity measures and apply prevention, organization, reduction, hiding, investigation, or containment.

Read how The Art of Code explains complexity →

Experimentation for Engineers

The property of a system or procedure arising from many interacting components and making its behavior difficult to predict or execute reliably.

How it is used
Frames why experimental improvements often fail and why complex systems require controlled validation.
How deep it goes
Defines complexity through interacting components and procedural steps, then stops short of a formal complexity metric.
Examples
Uses weather effects, contextual-bandit policies, multi-step optimization procedures, and production version comparisons as examples.
What you can do after
Validate complex experimental changes through A/B tests, varied conditions, and cautious production rollout.

Read how Experimentation for Engineers explains complexity →

Kafka for Architects

Operational complexity is the difficulty of provisioning, configuring, securing, monitoring, maintaining, and recovering a system in production.

How it is used
Guides Kafka deployment choices by weighing infrastructure responsibility, scalability, security, fault tolerance, compliance, and cost.
How deep it goes
Enumerates on-premises responsibilities and managed-service trade-offs but does not provide implementation procedures or configuration detail.
Examples
Uses broker setup, SASL or SSL authentication, Prometheus and Grafana monitoring, and cross-data-center replication as operational examples.
What you can do after
Evaluate Kafka deployment models against team capability, control requirements, operational burden, and cost.

Read how Kafka for Architects explains complexity →

The Coder Cafe

Complexity is the degree to which a problem or system has interacting, changing factors that make its behavior difficult to predict or solve.

How it is used
Distinguishes predictable technical difficulty from evolving problems that require adaptive solutions.
How deep it goes
Defines complicated versus complex problems and gives navigation guidance, while deferring a full catalogue of complexity patterns.
Examples
Uses tax filing, climate change mitigation, driver matching, geo-hashing, and large-scale machine-learning infrastructure.
What you can do after
Evaluate whether a problem needs a repeatable solution or an adaptive approach, then reduce avoidable software complexity.

Read how The Coder Cafe explains complexity →

Data-Oriented Programming: Reduce software complexity

The degree to which a software system is hard to understand, rather than the computational resources it consumes.

How it is used
Defines complexity as a criterion for comparing software designs and motivating data-oriented alternatives.
How deep it goes
Distinguishes understandability from resource usage and traces complexity to mutable objects, mixed code and data, serialization, and hierarchies.
Examples
Uses mixed classes, mutable objects, locked data, locked code, serialization, synchronization, and class hierarchies as complexity examples.
What you can do after
Evaluate whether a design is easier to understand by identifying relationships, mutability, data access, and class-hierarchy costs.

Read how Data-Oriented Programming: Reduce software complexity explains complexity →

Grokking Simplicity

A measure of the difficulty of understanding or analyzing a piece of software based on its structure or behavior.

How it is used
Analyzes the behavior of asynchronous interfaces when rapid clicks and parallel requests interact.
How deep it goes
Works through timeline structure, parallel regions, and possible orderings, but does not provide the complete complexity formula.
Examples
Uses multiple shopping-cart clicks, two parallel AJAX responses, and two register-counting callbacks.
What you can do after
Diagnose asynchronous behavior by representing timelines, isolating parallel work, and counting relevant execution orderings.

Read how Grokking Simplicity explains complexity →

Also covered in

What to know first

Related concepts

Questions about complexity

What is complexity?

Complexity is the degree to which interacting elements or factors make a system or problem difficult to understand, predict, change, operate, or solve.

Which Manning books explain complexity?

Architecture Modernization: Socio-technical alignment of software, strategy, and structure, Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform, Vibe Engineering, Sutskever's List, Effective Conversational AI, Machine Learning System Design, React in Depth, "Looks Good to Me" and 7 more.

What should I know before learning complexity?

Manning books that teach complexity usually introduce software testing, language model, functional programming and abstraction first.

What is the difference between complexity and simplicity?

Complexity is the degree to which interacting elements or factors make a system or problem difficult to understand, predict, change, operate, or solve. Simplicity is the quality of minimizing unnecessary complexity while preserving a system’s intended purpose and making it easier to understand.

What kinds of complexity are there?

Kinds of complexity include cyclomatic complexity, essential complexity and accidental complexity.

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.