Software Engineering Institute | Carnegie Mellon University
Software Engineering Institute | Carnegie Mellon University

Digital Library

Javascript is currently disabled for your browser. For an optimal search experience, please enable javascript.

Advanced Search

Basic Search

Content Type


Publication Date


Introducing Design Pattern-Based Abstraction Modeling Construct as a Software Architecture Compositional Technique

  • This presentation was created for a conference series or symposium and does not necessarily reflect the positions and views of the Software Engineering Institute.
  • Abstract

    We propose a technique using design patterns as abstract modeling constructs to assemble collaborative subsystems built independently in large software applications. Given a set of requirements structured as design problems, we can solve each problem individually. This activity results in creating components whose solutions are based on design patterns. Much of the published literature on design patterns spends much effort in describing this problem—pattern association. However, there is no systematic and practical way that shows how to integrate those individual solutions together. The use of patterns as integration mechanisms is different from using them, as originally conceived, as solutions to design problems. Our compositional model is based on design patterns by abstracting their collaboration model using role-modeling constructs. To describe this collaboration model, we specify design patterns as role models. For each design pattern, we examine its participants' collaboration behavior and factor out their responsibilities. A responsibility is a collection of behaviors, functions, tasks, or services. We then specify the resulting role model much like a collaboration model in UML. Our approach describes how to transform a design pattern into a role model that we can use to assemble software architecture. The proposed approach offers a complete practical design and implementation strategies, adapted from DCI (Data, Context, and Interaction) architecture, with a set of techniques with which most software engineers are familiar. We demonstrate our technique by presenting a simple case study complete with design and implementation code. To provide support in following our proposed approach, we also present a simple process that provides guidelines of what to do and how to do it.

    The approach presented in this research is of practical importance. The theory serves only to validate the concrete implementation and provides generalization to a variety of implementation strategies. The key concepts to take away are these. First, design patterns' key principal properties are used as abstraction modeling constructs through collaboration. Second, the proposed approach allows for partial and evolutionary design. Third, role to object mapping is really a binding mechanism that could be utilized effectively by this duality principle: either domain-objects discovery or object-roles allocation can be deferred. The approach is scalable without adding complexity and should work with any design pattern once its collaboration model is identified. The rationale used to select a design pattern to solve design problems should also work for selecting a design pattern to solve integration problems. The design and the implementation approach that we present creates a new design paradigm that appears complex at first but once learned it becomes another powerful tool added to designers' skill sets. The compositional model requires creating abstractions out of behavioral collaboration models of design patterns; therefore, it is not as straightforward as traditional techniques like aggregation or generalization. Furthermore, since the implementation strategy follows, more or less, the DCI architecture's footsteps, it also suffers from the same added overhead introduced by that architecture.

  • Download