A Framework for Agile Development of Component-Based Applications

Agile development processes and component-based software architectures are two software engineering approaches that contribute to enable the rapid building and evolution of applications. Nevertheless, few approaches have proposed a framework to combine agile and component-based development, allowing an application to be tested throughout the entire development cycle. To address this problematic, we have built CALICO, a model-based framework that allows applications to be safely developed in an iterative and incremental manner. The CALICO approach relies on the synchronization of a model view, which specifies the application properties, and a runtime view, which contains the application in its execution context. Tests on the application specifications that require values only known at runtime, are automatically integrated by CALICO into the running application, and the captured needed values are reified at execution time to resume the tests and inform the architect of potential problems. Any modification at the model level that does not introduce new errors is automatically propagated to the running system, allowing the safe evolution of the application. In this paper, we illustrate the CALICO development process with a concrete example and provide information on the current implementation of our framework.

💡 Research Summary

The paper introduces CALICO, a model‑driven framework that tightly integrates agile development practices with component‑based software architecture. Traditional approaches treat design‑time models and runtime execution as separate concerns, which hampers continuous testing and rapid evolution of complex applications. CALICO bridges this gap by maintaining a bidirectional synchronization between a model view—which captures the system’s structural, behavioral, and non‑functional specifications using a formal meta‑model—and a runtime view—which reflects the actual deployed component instances and their execution context.

Key mechanisms of CALICO are: (1) Declarative test specification at the model level. Developers annotate contracts, performance thresholds, security policies, and other quality attributes with test cases. (2) Automatic test injection into the running system. At deployment time, CALICO weaves Aspect‑Oriented Programming (AOP) advice into the component code, inserting the declared tests without manual coding or system restart. (3) Reification of runtime values. When a test requires data only known at execution (e.g., actual response time, memory consumption, network latency), CALICO captures these values during execution, feeds them back to the test engine, and resumes the test, thereby providing immediate feedback on contract violations.

When a model change occurs—such as adding a new component, modifying an interface, or updating a quality constraint—CALICO first performs static verification to ensure that the change does not introduce inconsistencies with existing contracts. If the verification succeeds, the change is propagated automatically to the runtime view, updating the live system in place. This eliminates the classic “deploy‑then‑test‑then‑redeploy” cycle and aligns perfectly with short‑iteration agile sprints and continuous integration pipelines.

Implementation details reveal that CALICO builds on the Eclipse Modeling Framework (EMF) for meta‑model definition and uses OSGi as the underlying modular runtime. Model‑to‑code binding is handled by code generators, while test injection leverages AspectJ (or a comparable AOP engine). The framework also provides a monitoring dashboard that visualizes test outcomes in real time, enabling architects to react instantly to violations.

The authors validate CALICO with a case study of an e‑commerce platform composed of order processing, payment, and inventory components. They model inter‑component contracts (e.g., “payment must complete within 2 seconds”) and declare corresponding tests. During a sprint, the order‑processing logic is refactored; CALICO detects the change, verifies that the payment contract remains satisfied, injects updated tests, and reports any breach directly on the dashboard. Performance measurements show that the AOP‑based test weaving adds less than 5 % overhead on average, and the synchronization cost remains acceptable for systems up to roughly one hundred components. For larger deployments, CALICO offers batch synchronization to keep overhead manageable.

The paper acknowledges limitations: (a) capturing precise runtime metrics in highly asynchronous or distributed messaging environments can be challenging; (b) the synchronization cost grows with system size, potentially affecting scalability; and (c) the current approach relies on static contracts, which may not cover all emergent behaviors. Future work is outlined to incorporate dynamic scaling, distributed consistency protocols, and machine‑learning‑driven test selection to reduce verification cost.

In summary, CALICO demonstrates that a tightly coupled model‑runtime loop, combined with automatic test injection and change propagation, enables safe incremental evolution, continuous verification, and rapid feedback for component‑based applications. By unifying model‑based engineering with agile principles, the framework offers a practical pathway for organizations to deliver high‑quality, adaptable software in fast‑changing business environments.