Complexity
Complexity is the degree to which interacting elements or factors make a system or problem difficult to understand, predict, change, operate, or solve.
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
- 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.
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.
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.
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.
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.
Also covered in
- Simple Object-Oriented Design: Create clean, maintainable applications
- Architecting an Apache Iceberg Lakehouse
- Generative AI in Action
- Retrieval Augmented Generation, The Foundational IdeasIn early access (MEAP)
- Unit Testing Principles, Practices, and Patterns
- Functional Design and Architecture: Examples in Haskell
- Grokking Machine Learning, Second EditionIn early access (MEAP)
- Object-Oriented Software Design in C++
- Software Architecture Decision-MakingIn early access (MEAP)
- Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
- Software Design for Python Programmers
- AI-Powered Developer: Build software with ChatGPT and Copilot
What to know first
- 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.
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- functional programmingFunctional programming is a programming paradigm that expresses computation through the evaluation and composition of functions, typically favoring immutable data and minimizing mutable state and side effects.
- abstractionAbstraction is a simplified representation that preserves relevant properties or behavior while omitting details unnecessary at a given level or for a given purpose.
Related concepts
- cyclomatic complexityincludes · Cyclomatic complexity is a software metric that measures the number of linearly independent execution paths through a program's control-flow graph.
- design patternaddressed by · A design pattern is a reusable, general solution structure for a recurring software design problem.
- refactoringaddressed by · Refactoring is the disciplined restructuring of existing software to improve its internal qualities while preserving its externally observable behavior.
- 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.
- simplicitycontrasts with · Simplicity is the quality of minimizing unnecessary complexity while preserving a system’s intended purpose and making it easier to understand.
- accidental complexityincludes · Accidental complexity is difficulty arising from implementation choices or technical constraints rather than from the essential requirements of the problem being solved.
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.














