Complexity

As explained in 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.

Software complexity grows as an application gains features, customers, and teams. Microservices can help manage that growth by dividing an application into services with firm boundaries. They also make the system harder to build at first than an equivalent monolith. The practical question is not how to eliminate complexity, but when and how to take it on. section 1.0 section 1.10.4

Keep complexity manageable at two levels:

• Size services around domain concepts, not a goal of making every service as small as possible. Services that are too small need more communication and can increase overall system complexity. section 1.14.5
• Start with working code and make small, tested changes. Preserve each iteration in version control so a failed change is easy to reverse; introduce tools and patterns as the application needs them. section 2.4

Grow from one service

A practical progression starts with one microservice, packages it with Docker, runs multiple services locally with Docker Compose, and eventually deploys them to Kubernetes in the cloud. Each stage adds capabilities—and complexity—when they become useful. section 12.9

Figure 2.2 Start simple and work up to complexity through a series of small iterations.

The diagram shows the development approach: begin simply and reach a more complex application through small iterations. section 2.4

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

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 it assumes

Assumes version control for preserving iterations while introducing microservices, distributed applications, and monoliths.

What you can do after

Practice/perform complexity management by making small, recoverable changes and sizing services around domain concepts.

How it connects

Connects complexity to microservices, monoliths, domain-driven design, and iterative development.

liveBookmanning.com

Read Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform on liveBook Get the book at manning.com

Also explained in

• 

  liveBookmanning.com
  Architecture Modernization: Socio-technical alignment of software, strategy, and structureSystem complexity is the degree to which a software system's components, integrations, data, and behaviors interact in difficult-to-understand ways.
• 

  liveBookmanning.com
  Sutskever's ListModel complexity is the structural and parametric richness of a model that determines the range of functions it can represent.
• 

  liveBookmanning.com
  Effective Conversational AIThe degree of structural difficulty in a conversational task or interaction, determined by the number, interdependence, length, branching, or sequencing of steps.
• 

  liveBookmanning.com
  Machine Learning System DesignThe degree of structural or parametric richness in a machine learning model that determines the range of functions it can represent.
• 

  liveBookmanning.com
  React in DepthSoftware complexity is the degree to which a software system has many interacting elements, conditions, and behaviors that make it harder to understand and maintain.
• 

  liveBookmanning.com
  "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.
• 

  liveBookmanning.com
  Practices of the Python ProA complexity measurement is a quantitative assessment of the structural or computational complexity of software or an algorithm.
• 

  liveBookmanning.com
  The Art of CodeSoftware complexity is the degree of difficulty involved in understanding, changing, and maintaining a software system.
• 

  liveBookmanning.com
  Experimentation for EngineersThe property of a system or procedure arising from many interacting components and making its behavior difficult to predict or execute reliably.
• 

  liveBookmanning.com
  Kafka for ArchitectsOperational complexity is the difficulty of provisioning, configuring, securing, monitoring, maintaining, and recovering a system in production.
• 

  liveBookmanning.com
  Data-Oriented Programming: Reduce software complexityThe degree to which a software system is hard to understand, rather than the computational resources it consumes.
• 

  liveBookmanning.com
  Grokking SimplicityA measure of the difficulty of understanding or analyzing a piece of software based on its structure or behavior.

Compare how 13 books explain complexity →

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.

This explainer was generated by Manning's knowledge graph from the text of Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform. The section links point to the parts of the book it draws on.