Complexity
Complexity is the degree of difficulty in understanding, analyzing, changing, or operating a system or problem, arising from its structure, behavior, or interacting parts.
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.
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
- Frames complexity as an inevitable design constraint that microservices can manage despite their higher initial cost.
- How deep it goes
- Explains architectural tradeoffs, service sizing, and incremental development without defining a numerical complexity measure.
- Examples
- Traces growth from one microservice through Docker and Docker Compose to a cloud deployment on Kubernetes.
- What you can do after
- Practice/perform complexity management by making small, recoverable changes and sizing services around domain concepts.
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.
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.
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.
"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.
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.
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.
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.
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.
Related concepts
- cyclomatic complexitymeasured by · Cyclomatic complexity is a software metric that measures the number of linearly independent execution paths through a program's control-flow graph.
- refactoringaddressed by · Refactoring is the restructuring of existing software or code to change its internal organization and improve its design, typically while preserving externally observable behavior.
- design patternaddressed by · A design pattern is a reusable, general solution structure for a recurring software design problem in a particular context.
- simplicitycontrasts with · Simplicity is the quality of minimizing unnecessary complexity while preserving a system’s intended purpose and making it easier to understand.
- essential complexityincludes · Essential complexity is the unavoidable difficulty inherent in a problem’s domain, rules, and required outcomes, which cannot be removed without sacrificing necessary behavior.
- abstractioncontrasts with · Abstraction is a simplified representation that exposes relevant properties or behavior while omitting lower-level details unnecessary for a given purpose.
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.