Modularity
Modularity is the property of a system being organized into separable components with distinct responsibilities and defined interactions.
Architecture Modernization: Socio-technical alignment of software, strategy, and structure
A modular architecture organizes a system into separable modules with well-defined responsibilities and limited dependencies between them.
- How it is used
- Positions modular architecture as a response to fragile changes, slow delivery, and difficulty scaling team productivity.
- How deep it goes
- Explains the organizational rationale and a phased transition, but does not specify how to implement module boundaries.
- Examples
- Uses Vinted’s expanding category tree and CloudSuite’s shared backend API to show different pressures on modularity.
- What you can do after
- Practice/perform phased modularization by planning collaboration where team boundaries still cross shared technical artifacts.
React Quickly, Second Edition
A software architecture that organizes functionality into reusable, loosely coupled components with separated responsibilities.
- How it is used
- Organizes React web-app functionality into components as part of a simpler development approach.
- How deep it goes
- Introduces component-based architecture and JavaScript components, but does not specify component boundaries or coupling rules.
- Examples
- Illustrates a JavaScript condition that selects a login or logout link.
- What you can do after
- Evaluate/understand component-based organization as one reason React can simplify web-app development.
Read how React Quickly, Second Edition explains modularity →
Get Programming: Learn to code with Python
Modularity is the organization of software into separate components with distinct responsibilities and interfaces.
- How it is used
- Organizes large programming tasks into smaller, testable units that can be combined into complete programs.
- How deep it goes
- Explains modules through inputs, tasks, outputs, testing, functions, classes, and reuse, without detailing formal interface design.
- Examples
- Uses attendance, car assembly, arithmetic operations, document similarity, card games, and a two-player shape-moving game.
- What you can do after
- Build programs from reusable functions, classes, and libraries while testing smaller pieces independently.
Read how Get Programming: Learn to code with Python explains modularity →
Functional Design and Architecture: Examples in Haskell
Modularity is a structural property in which a program is divided into relatively independent parts with separable responsibilities.
- How it is used
- Organizes programs into independent parts to reduce complexity and make responsibilities easier to maintain.
- How deep it goes
- Defines decomposition, interface boundaries, and implementation hiding, but stops short of a detailed modularity procedure.
- Examples
- Uses C opaque types, Linux kernel-style procedures, sensor interfaces, and adapter-based object-oriented designs.
- What you can do after
- Evaluate designs by identifying separable responsibilities, stable interfaces, hidden implementations, coupling, and cohesion.
Read how Functional Design and Architecture: Examples in Haskell explains modularity →
Software Security for Developers
A modular monolith is a single application organized into well-defined independent modules that communicate through clean interfaces and own specific domains or features.
- How it is used
- Organizes authorization by domain while keeping the application in one deployable unit.
- How deep it goes
- Explains module ownership, authorization placement, encapsulation, auditing, and testing, but does not specify implementation mechanics.
- Examples
- Uses Users, Invoices, Reports, and Teams modules plus a department-based invoice authorization decision.
- What you can do after
- Designs and audits module-local authorization without introducing distributed-service enforcement complexity.
Read how Software Security for Developers explains modularity →
The Joy of JavaScript
A software design approach that structures a program as separate modules with well-defined responsibilities and interfaces.
- How it is used
- Organizes JavaScript code to separate concerns, isolate behavior, and manage application design beyond framework-level structure.
- How deep it goes
- Explains pre-module patterns and their function-scope rationale, but stops short of detailed native module mechanics.
- Examples
- Uses global scripts, object namespaces, IIFEs, IIFE mixins, factory functions, and fine-grained functional decomposition.
- What you can do after
- Evaluate/understand how function scope and pre-module patterns isolate code and organize small JavaScript applications.
Functional Programming in Scala, Second Edition
A modular program is composed of components whose meanings and reuse can be understood independently and combined through explicit composition rules.
- How it is used
- Uses pure functions to separate computation from effects, improving testing, reuse, parallelization, and composition.
- How deep it goes
- Explains independent components, composition rules, effect separation, and local reasoning, stopping short of implementation mechanics.
- Examples
- Uses coffee purchasing, substitution of string expressions, and high-level parallel mapping as concrete modularity examples.
- What you can do after
- Apply effect separation and pure-function composition to make computations easier to test, reuse, reason about, and parallelize.
Read how Functional Programming in Scala, Second Edition explains modularity →
The Well-Grounded Rubyist, Fourth Edition
Modularization is the organization of software functionality into separate reusable modules.
- How it is used
- Organizes large Ruby programs by separating behavior into reusable modules and combining those behaviors with classes.
- How deep it goes
- Explains modules through class comparison and a Stack mixin, while signposting deeper method-lookup mechanics.
- Examples
- Uses a Stacklike module, a Stack class, include, and equivalent modular and nonmodular implementations.
- What you can do after
- Apply Ruby modules with include to share a general behavior across multiple classes without duplicating implementation.
Read how The Well-Grounded Rubyist, Fourth Edition explains modularity →
Introduction to Generative AI, Second Edition
A modular architecture divides a system into separate components that perform distinct functions and can be designed or modified independently.
- How it is used
- Organizes generative AI systems into coordinated components for retrieval, generation, validation, safety filtering, and targeted intervention.
- How deep it goes
- Explains component separation, advantages, and failure risks, but stops short of implementation details.
- Examples
- Uses document retrieval, draft generation, safety screening, persistent audit logs, and runtime safeguards as system components.
- What you can do after
- Evaluate modular and end-to-end architectures by comparing control, reliability, interpretability, complexity, and deployment demands.
Read how Introduction to Generative AI, Second Edition explains modularity →
Building LLM Applications with DSPy
Modular organization is a structural pattern that separates an application into composable components with distinct responsibilities.
- How it is used
- Uses modularity to make DSPy applications easier to develop, test, debug, review, and monitor.
- How deep it goes
- Explains component boundaries and substitution, but does not detail implementation internals.
- Examples
- Uses interchangeable language models and predictors, with scikit-learn model swaps and PyTorch architecture changes as comparisons.
- What you can do after
- Apply modular organization by swapping DSPy language models or prompting techniques without changing other code.
Read how Building LLM Applications with DSPy explains modularity →
Related concepts
- functionuses · A function is a callable program unit that performs an operation, may accept inputs, and can produce a result or side effect.
- Reactused by · React is an open-source JavaScript library for building user interfaces from declarative, reusable components.
- lazy evaluationaddressed by · Lazy evaluation is an evaluation strategy that defers computing an expression or value until its result is needed, potentially avoiding the computation entirely.
- DSPypart of · DSPy is a Python framework for declaratively programming, composing, evaluating, and optimizing language-model applications and pipelines.
- monolithic architecturekind of · Monolithic architecture is a software architecture in which an application's major functionality is organized and deployed as a single integrated unit.
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.