← Back to list
SW Engineering & Management
#CBD#컴포넌트#소프트웨어재사용#인터페이스#SBOM
Last updated · 2026-11-10

Component-Based Development (CBD)

1. Overview

Component-Based Development is a development methodology that builds software by identifying, acquiring, and assembling "components" — reusable units that expose only specified interfaces and explicit context dependencies and that can be deployed and composed independently. In other words, instead of writing code from scratch, it completes a system by assembling verified parts, a "manufacturing-style software production" paradigm.

The background to CBD's emergence lies in the so-called "software crisis" of the late 1990s. Hardware performance grew exponentially along Moore's law, but software productivity was tied linearly to the headcount invested, while demand exploded. Object orientation (OOP) was celebrated as the answer to reuse, but class-level reuse relied on source-code-level inheritance and coupling, so it was hard to carry into a different context and its reuse scope stayed at "functions and classes." Beyond this limit, the recognition that a larger unit was needed — one deployed independently at the binary level and assembled through interfaces alone — is the starting point of CBD.

Here a "component" is not a mere module or library. Borrowing Clemens Szyperski's definition, a component is "a unit of composition with contractually specified interfaces and explicit context dependencies only, which can be deployed independently and is subject to composition by third parties." Three points are key. First, all that is visible externally is the interface (contract), and the internal implementation is fully hidden (black box). Second, independent deployment is possible, so it can be replaced or upgraded separately from other components. Third, it is designed on the premise of third-party composition, so its maker and its user may differ. Thanks to these properties, CBD established itself in the early 2000s as the standard development methodology for public-sector and financial SI projects as a means of improving productivity, quality, and delivery simultaneously, and it became the intellectual root of today's package ecosystems, microservices, and micro-frontends.

CBD's necessity is explained by the "economics of reuse." Rebuilding the same function in every project is an obvious waste, and reusing a component already verified in operation lowers defect density and raises quality. Reuse, however, is not free. As elaborated below, one must invest up front in the "cost of making something reusable," so CBD is as much a matter of organization and governance as it is of technology.

The core characteristics CBD puts forward compress into four. Reusability raises productivity and quality together by repeatedly leveraging verified assets; substitutability allows swapping in another implementation that satisfies the same interface; independence lets a component be developed, tested, deployed, and versioned individually; and composability lets these independent parts be combined by contract alone into a larger system. Only when these four characteristics interlock does CBD's ideal of "making software by assembling parts" hold. If any one collapses — for example, if independent deployment fails or an interface leaks — CBD retains only the name while its substance regresses into a giant single lump.

2. The Concept of a Component and Its Constituent Elements

A component-based system is a structure in which multiple components mesh and run through their respective interfaces. The figure below shows the core constituent elements that make up a system and their relationships.

flowchart TB
    subgraph SYS["Component-Based System"]
        A["Order component<br/>Provided IF: IOrder"]
        B["Payment component<br/>Provided IF: IPayment"]
        C["Stock component<br/>Provided IF: IStock"]
        CT["Container<br/>Provides lifecycle, transaction, security"]
        A -->|"Required IF: IPayment"| B
        A -->|"Required IF: IStock"| C
        CT -.->|"Runtime services"| A
        CT -.->|"Runtime services"| B
        CT -.->|"Runtime services"| C
    end
    CL["Client"] -->|"IOrder call"| A
    REPO[("Component repository<br/>specs, versions, metadata")] -.->|"search and compose"| SYS

The component implementation is the binary artifact that holds the actual function. A user cannot look inside it and accesses it only through the interface. Thanks to this black-box nature, even a full rewrite of the internals leaves the user unaffected as long as the interface is kept. This is the fundamental principle by which CBD suppresses the "ripple of change."

The interface is the contract a component forms with the outside. CBD distinguishes two kinds of interface. The provided interface is the function this component gives to others, and the required interface is the function this component demands from others in order to operate. In the figure above, the order component provides IOrder but cannot perform payment or stock itself, so it requires IPayment and IStock. This duality is exactly why a UML component diagram expresses it with the "lollipop (provided)" and "socket (required)" symbols.

The connector/binding is the glue that connects one component's required interface to another's provided interface. It matters that the binding can be decided not at compile time but at execution and deployment time. Changing the connection target through a configuration file or a dependency injection (DI) container lets you replace the payment component from vendor A's module with vendor B's module without touching the code. This "late binding" realizes substitutability.

The container is the runtime environment that provides components with common runtime services such as lifecycle management, transactions, security, and pooling. The EJB container, .NET's CLR, and the OSGi framework are typical. Because the container takes on cross-cutting concerns, component developers can focus solely on business logic. Today's servlet containers and Kubernetes are likewise modern variants of the same role.

The component specification and repository are the apparatus that turns reuse into an organizational asset. A specification holds not only the interface signatures but also pre/post conditions (Design by Contract), quality attributes, dependencies, and version information. The repository keeps these specifications in a searchable form so that a developer can find a "shopping-cart calculation function" by keyword and assemble it. Maven Central and the npm registry are the industrial embodiment of this repository concept.

A design issue that must be addressed here is component granularity. Splitting components too finely causes the number of parts to assemble to explode, raising dependency-management and integration costs, while bundling them too coarsely strengthens internal coupling and makes reuse and replacement hard. In practice, the level "holding one business capability fully but no more" is taken as the balance point. This granularity judgment reduces to the classic design measures of cohesion and coupling, and in that a component whose boundary is drawn wrong is not reused no matter how well it is packaged, it is the starting line of CBD's success or failure.

Element Role Modern example
Component implementation Black-box binary unit holding a function JAR, DLL, npm package, container image
Provided/required interface Contract with the outside (what is given/received) Java interface, REST/gRPC contract, Web Components API
Connector/binding Connection between interfaces (late binding) DI container, service discovery
Container Provides common runtime services EJB container, CLR, OSGi, servlet container
Repository Keeps and searches specs and versions Maven Central, npm, in-house Nexus

3. The CBD Development Process

The CBD process has a point that decisively differs from the traditional waterfall. Namely, "development for reuse" and "development with reuse" coexist as two separated life cycles. The former is a supply-side activity that makes general-purpose components for others to use, and the latter is a demand-side activity that assembles those components to make a specific product. Without understanding this duality, one mistakes CBD for mere "modularization."

flowchart LR
    subgraph REUSE["Development for reuse"]
        D1["Domain analysis"] --> D2["Identify commonality/variability"]
        D2 --> D3["Component design/implementation"]
        D3 --> D4["Specify, test, register in repository"]
    end
    subgraph WITH["Development with reuse"]
        W1["Requirements analysis"] --> W2["Identify/search components"]
        W2 --> W3["Evaluate/select"]
        W3 --> W4["Adapt/compose"]
        W4 --> W5["Integration test/deploy"]
    end
    D4 -.->|"Asset supply"| W2
    W3 -.->|"Gap feedback"| D1

Domain analysis and component identification are the starting point. One finds business concepts that appear in common across multiple applications and bundles them into component candidates. Drawing the boundary "high cohesion, low coupling" is key here, and a boundary drawn wrong mass-produces entangled parts rather than reusable ones. Dividing components by core business entities such as "customer, account, transaction, limit" in the financial sector is a typical case.

The acquisition (make/buy) stage decides whether to develop an identified component directly, buy a commercial off-the-shelf (COTS) product, or adopt open source. This decision is a trade-off synthesizing cost, time, control, licensing, and security. For example, a reasonable split is to use COTS/open source for general-purpose, verification-critical functions such as PDF generation or payment-gateway integration, and to develop in-house the business rules that embody core competitiveness.

Evaluation and selection is the gate that governs quality in CBD. One looks not only at whether a candidate component meets the required function but also at whether its required interface fits our environment, and at its licensing, security vulnerabilities, and maintenance continuity (community activity). For open source, the number of GitHub stars, the time of the last commit, and the presence of known CVEs become practical evaluation indicators.

Adaptation and composition resolves interface mismatch with a wrapper or adapter pattern when a selected component is hard to use as is, and then connects it with a connector. Absorbing the "architectural mismatch" that arises when assembling components from different vendors — for example, when one side assumes callbacks and the other assumes polling — into a mediation layer is the crux of composition quality.

Integration testing and deployment verifies that the assembled whole operates correctly as one system. Even if individual components passed unit tests, defects arising from their interactions reveal themselves only at integration time. Thus CBD gives greater weight than traditional development to contract testing based on interface contracts and to interoperability testing. In Korea, a CBD-specific methodology such as MaRMI-III, propagated in the early 2000s by the agency lineage of the national IT industry promotion body, formalized this life cycle into standard deliverables.

4. Core Principles of Component Design

The design principles that distinguish a good component summarize into a few. The first is the separation of interface and implementation. Making a user depend on an abstract interface rather than an implementation (dependency inversion) means the user is not shaken even if the implementation is replaced. The second is explicit context dependency. If a component secretly depends on global state or a specific database, it cannot be moved to another environment, so everything needed must be surfaced as a required interface.

The third is Design by Contract. Specifying pre-conditions, post-conditions, and invariants on each interface operation lets the assembling side use it safely without knowing the internals. This is the foundation of trust that makes black-box reuse possible. The fourth is version management and compatibility discipline. Keeping a promise like semantic versioning's "a major version change may break compatibility" lets the hundreds of dependent projects upgrade with confidence.

The fifth is statelessness and an orientation toward idempotency. The longer a component keeps hidden internal state, the harder it is to compose and reuse in parallel. Aiming for pure operations whose output is determined by the input lets the same component be used safely and simultaneously in many contexts. Designing operations with side effects, such as payment or transfer, with an idempotency key so that retries produce no duplicates raises the reliability of an assembly-based system.

These principles are not abstract oughts but norms that hold an actual ecosystem from collapsing. For instance, if a popular package in the npm ecosystem violates semantic versioning and breaks compatibility in a minor-version upgrade, the builds of the tens of thousands of projects depending on it fail in a chain. CBD's design principles are, in effect, a matter of supply-chain stability. Conversely, in an ecosystem where this discipline is well kept, the flexibility to assemble thousands of parts yet replace and upgrade each one independently is secured.

5. Comparison with Similar Paradigms

CBD is often confused with object orientation (OOP), service orientation (SOA), microservices (MSA), and the software product line (SPL). These share the goal of "reuse" but diverge in the unit of reuse, the level of coupling, and the deployment boundary. The difference must be understood not as a bare list but as "why they split this way."

The difference from OOP comes from the "level" of reuse. OOP reuses by inheriting classes or pulling in source, so it is white box and strongly coupled. The "fragile base class problem," where a change in the inheritance hierarchy breaks subclasses, is the evidence. CBD, by contrast, is black-box reuse assembled only by interface at the binary level, so coupling is weak and replacement is easy. CBD does not negate OOP; it raises the unit of reuse larger and more independently atop OOP.

The difference from SOA/MSA comes from the "deployment and communication boundary." Traditional CBD's composition is usually done by function calls within one process, but SOA and MSA separate components into independent services across the network and connect them with remote calls. So MSA gains operational benefits of independent deployment, independent scaling, and fault isolation, but takes on the costs of network latency, distributed transactions, and observability. Put differently, MSA is a descendant that extends CBD's principles (interface-based composition, substitutability) to the distributed and operational level. Micro-frontends and Web Components are likewise in the same lineage.

The difference from SPL comes from the "scope of reuse and variability management." SPL has in mind not a single product but an entire product family, systematically managing commonality and variability to derive multiple variant products from core assets. CBD is closer to "the technique of assembling the parts" that make up those core assets. That is, if SPL is the strategy, CBD is the tactic that realizes it, and the two are closer to a containment relation than an opposition.

The practical implication of this comparison is clear. An organization must choose a reuse unit suited to each business domain along the axes of change isolation, scaling demand, and operational maturity — not along slogans like "everything to MSA" or "everything to components." A realistic mixed strategy treats a domain whose traffic explodes and demands independent scaling as a microservice, a domain served sufficiently within one process as a library component, and a domain needing variants across multiple products as an SPL variation point.

Category Reuse unit Coupling/deployment Communication Representative tech
OOP Class (white box) Strong coupling, source sharing Local call Inheritance, polymorphism
CBD Component (black box) Weak coupling, independent deploy (in-process) Local/late binding EJB, COM, OSGi, npm
SOA Service Weak coupling, independent deploy Remote (ESB-mediated) WSDL/SOAP, ESB
MSA Microservice Weak coupling, independent deploy/scale Remote (lightweight HTTP/message) REST/gRPC, container
SPL Core asset + variation point Shared across product family Coupled at composition time Feature model, variability mgmt

6. Deep Dive — Package Ecosystems and Supply-Chain Security

As a "methodology," CBD may look like something that flourished and faded in the 2000s, but as an idea it is more dominant today than ever. Nearly every modern application is made by assembling hundreds to thousands of external components (packages). The npm registry has over three million packages registered, and it is not rare for a single mid-sized JavaScript project to pull in over 1,000 dependencies directly and transitively. In other words, CBD's ideal of "assembling verified parts" has already become the industry-wide default.

This success, however, bred a new risk. As the depth of reuse became the "depth of the supply chain," the structure now propagates a defect or vulnerability in a single lower component across the whole world. Log4Shell (CVE-2021-44228) at the end of 2021 is symbolic. A single vulnerability in the Java logging component Log4j plunged millions of systems that held it deep as a dependency into remote-code-execution risk all at once. That the majority of organizations did not even recognize they were using Log4j directly shows the essence of the problem.

The response that emerged from this incident is the SBOM (Software Bill of Materials). The idea is to transparently manage every component and version used in the assembly as a "bill of parts," making it traceable which component went where. The United States required an SBOM for federally procured software through Executive Order 14028 in 2021, a case in which CBD's reuse-repository and specification concepts were reborn in the language of "security and regulation." Recently, software signing (Sigstore), provenance attestation, and automated dependency inspection (SCA) tools have established themselves as essential hygiene measures of the CBD ecosystem.

Another recent current is the fusion of generative AI and reuse. Coding assistants learn vast public components and recommend and assemble appropriate libraries, but a new supply-chain threat called "slopsquatting" — where attackers exploit the "package hallucination" of plausibly inventing a nonexistent package name — is also being reported. The greater the convenience of reuse, the sharper CBD's intrinsic question of "what to trust and assemble" becomes.

7. Considerations and Implications

First, the economics of reuse is a matter of up-front investment and break-even. Making a component generally reusable costs extra in generalization, documentation, and testing. By rule of thumb that cost is around 1.5 times a one-off implementation, and it is generally held that it must be reused three or more times to pass break-even (the figures vary by context and should be taken as a generalization). Hence the greed to componentize everything is itself a waste, and one must make a focused choice on core assets likely to be reused frequently.

Second, CBD without governance becomes an uncontrollable heap of dependencies. Without the backing of quality management of the reuse repository, version/license policy, a deprecation procedure, and configuration management, "shadow dependencies" pile up and maintenance is paralyzed. The professional engineer must be able to design CBD not as a coding technique but as an organizational operating system that manages reuse assets.

Third, quality and security responsibility extends outward. A vulnerability in an assembled component is immediately a vulnerability of our system. One must embed SBOM, SCA, and signature verification into the development pipeline (DevSecOps) and put the sustainability of external components (the maintaining party, the community) into the selection criteria. The benefit of reuse and the supply-chain risk are two sides of the same coin.

Fourth, CBD's future lies in its linkage with MSA, cloud-native, and AI. Traditional in-process composition has evolved into distributed composition in containers, serverless, and micro-frontends, and the unit of reuse is expanding from packages to container images and further to reusable AI models, prompts, and agents. The professional engineer must be able to explain, as one continuous flow, how CBD's essence of "making software by assembling" is inherited and deepened as it shifts across technology stacks.

References


In one line: CBD is a methodology that supplies and assembles interface-specified, independently deployable black-box components across two life cycles — "development for reuse" and "development with reuse" — and it is the software-assembly paradigm inherited today by package ecosystems, MSA, and supply-chain security (SBOM).