Modeling Architectural Pattern Variants

Abstract

Systematic modeling of architectural patterns is a challenging task mostly because of the inherent pattern variability and because pattern elements do not match the architectural abstractions of modeling languages. In this paper, we describe an approach for systematic modeling of architectural patterns using a set of architectural primitives and a vocabulary of pattern-specific architectural elements. These architectural primitives can be used as the basic building blocks for modeling a number of architectural patterns. We introduce profiles for the UML2 meta-model to express the architectural primitives. The use of the primitives along with the stereotyping scheme is capable of handling some of the challenges for the systematic modeling of architectural patterns, such as expressing pattern participants in software design.

Keywords

• Architectural Pattern
• Architectural Primitive
• Modeling
• UML

-

Architectural patterns provide solutions to recurring problems at the architecture design level. These patterns not only document ’how’ solution solves the problem at hand but also ’why’ it is solved, i.e. the rationale behind this specific solution [ 14 ]. So far, a huge list of patterns has been documented in the literature [ 5,6 ]. These patterns have been successfully applied to design software in different domains and provide concrete guidelines for modeling the structural and behavioral aspects of software systems. Although at present, the practice of modeling architectural patterns is largely ad hoc and unsystematic, the topic of systematic pattern modeling is receiving increasing attention from researchers and practitioners [ 3 ].

In spite of the benefits that patterns offer for solving recurring design problems and the evergrowing list of documented patterns, there is not yet a proven approach for the systematic modeling of architectural patterns and pattern variants in software design. Some architecture description languages (ADLs), such as UniCon [ 13 ], Aesop [ 8 ], ACME [ 9 ], and Wright [ 2 ] capture specific concepts for modeling patterns. However, none of the approaches presented so far, for modeling architectural patterns, can effectively express the semantics of architectural patterns [ 11 ]. This is because each pattern addresses a whole solution space comprised of different variants of the same pattern, which are difficult to express in a specific ADL. In contrast to ADLs, UML offers a generalized set of elements to describe software architecture but UMLs support for modeling patterns is weak because pattern elements do not match the architectural abstractions provided in UML. In summary, both ADLs and the UML provide only limited support for modeling patterns.

In our previous work [ 14 ], we identified a set of architectural primitives. These primitives offer reusable modeling abstractions that can be used to systematically model solutions that are repetitively found in different patterns. In this paper, we introduce a few more primitives and use all the primitives discovered during our current and previous work to devise an approach that is capable of systematically modeling architectural patterns in system design. The main contribution of this paper lies in modeling pattern variants using primitives, identifying pattern aspects that are difficult to express using primitives, and devising a generalized scheme that uses a vocabulary of pattern-specific components and connectors (e.g., pipes, filters) in conjunction with primitives for systematically modeling architectural patterns.

The remainder of this paper is structured as follows: In Section 2 we present our approach for representing patterns and primitives as modeling abstractions, exemplified using an extension of the UML. Section 3 briefly introduces the primitives discovered in our previous work while Section 4 gives detailed information of the new primitives documented in this paper. In section 5, we give an overview of the relationships between patterns and primitives. Section 6 describes the modeling of few selected pattern variants using primitives and a pattern-elements vocabulary. Section 7 compares related work and Section 8 discusses future work and concludes this study. 2

Extending UML to Represent Patterns and Primitives

UML is a widely known modeling language and is highly extensible [ 3 ]. There are two approaches for extending UML: extending the core UML metamodel or creating profiles which extend metaclasses. Our work focuses on the second approach where we create profiles specific to the individual architectural primitives. Although this work is exemplified using UML 2.0, the same approach can be used for other modeling languages as long as the selected modeling language supports an extension mechanism to handle the semantics of the primitives. The key idea is that a modeling language can be extended to facilitate semantics of the architectural primitives and that these primitives can then be used to model patterns.

We extend the UML metamodel for each discovered architectural primitive using UML profiles. That is, we define the primitive as extensions of existing metaclasses of the UML using stereotypes, tagged values, and constraints: – Stereotypes: Stereotypes are one of the extension mechanisms to extend UML metaclasses.

We use stereotypes to extend the properties of existing UML metaclasses. For instance, the Connector metaclass is extended to generate a variety of primitive-specific specialized connectors. – Constraints: We use Object Constraint Language (OCL) [ 1 ] to place additional semantic restrictions on extended UML elements. For instance, constraints can be defined on associations between components, navigability, direction of communication, etc. – Tagged Values allow one to associate tags to architectural elements. For example, tags can be defined to represent individual layers in a layered architecture using layer numbers.

We chose the UML profiles extension mechanism due to the following reasons: – A large community of software architects understands UML as a software modeling language. This enables us to use the existing set of UML elements as the basis for extensions.

Thus, the time needed to learn a new language and the risks of a novel approach are reduced. – UML allows the creation of profiles without changing the semantics of the underlying elements of the UML metamodel. Profiles are good enough to serve for this purpose. – A number of UML tools are available to design software architecture and support profiles out-of-the-box. In contrast, a metamodel extension would require an extension of the tools.

In the architectural primitives, presented in this paper, we mainly extend the following classes of the UML 2 metamodel to express the primitives: – Components are associated with required and provided interfaces and may own ports. Components use connectors to connect with other components or with its internal ports. – Interfaces provide contracts that classes (and components as their specialization) must comply with. We use the interface meta-class to support provided and required interfaces, where provided interfaces represent functions offered by a component and required interfaces represents functions expected by a component from its environment. – Ports are the distinct points of interaction between the component that owns the ports and its environment. Ports specify the required and provided interfaces of the component that owns them. – Connectors connect the required interfaces of one component to the provided interfaces of other matching components. 3

Architectural Primitives

This section provides an extension to our previous work [ 14 ] where we listed nine architectural primitives along with the mechanism to discover primitives in architectural patterns. We have used the same mechanism to discover new primitives in this paper. We first present five primitives discovered in the Component-Connector view that are repetitively found as abstractions in modeling variants of a number of patterns. Moreover some patterns documented in [ 7 ] are used as solution participants of other patterns, hence we consider their modeling solution as primitives and include them in our collection. Subsequently, in the next section, we extend the set of primitives with five new primitives.

Our original set of primitives was comprised of the following [ 14 ]: – Callback: A component B invokes an operation on Component A, where Component B keeps a reference to component A in order to call back to component A later in time. – Indirection: A component receiving invocations does not handle the invocations on its own, but instead redirects them to another target component. – Grouping: Grouping represents a Whole-Part structure where one or more components work as a Whole while other components are its parts. – Layering: Layering extends the Grouping primitive, and the participating components follow certain rules, such as the restriction not to bypass lower layer components. – Aggregation Cascade: A composite component consists of a number of subparts, and there is the constraint that composite A can only aggregate components of type B, B only C, etc. – Composition Cascade: A Composition Cascade extends Aggregation Cascade by the further constraint that a component can only be part of one composite at any time. – Shield: Shield components protect other components from direct access by the external client. The protected components can only be accessed through Shield. – Typing: Using associations, custom typing models are defined with the notion of super type connectors and type connectors. – Virtual Connector: Virtual connectors reflect indirect communication links among components for which at least one additional path exists from the source to the target component.

Description and Modeling Solutions to Architectural Primitives in the Component-Connector View

In this section, we present five primitives that are repetitively found among a number of architectural patterns. For the first selected primitive, we briefly describe the primitive, discuss the issues of modeling the primitive in UML, present UML profile elements as a concrete modeling solution for expressing the primitive, and motivate known uses of the primitive in architectural patterns. For the sake of simplicity, the modeling issues and modeling solutions of remaining primitives are detailed in the Appendix. 4.1

Push-Pull

Context: Push, Pull, and Push-Pull structures are common abstractions in many software patterns. They occur when a target component receives a message on behalf of a source component (Push), or when a receiver receives information by generating a request (Pull). Both structures can also occur together at the same time (Push-Pull).

Modeling Issues: Semantics of push-pull structures are missing in UML diagrams. It is difficult to understand whether a certain operation is used to push data, pull data, or both. A major problem in modeling the patterns using Pushs or Pulls in UML is that although Push-Pull structures are often used to transmit data among components, it cannot be explicitly modeled in UML.

Modeling Solution: To properly capture the semantics of Push-Pull in UML, we propose a number of new stereotypes for dealing with the three cases Push, Pull, and Push-Pull. Figure 1 illustrates these stereotypes according to the UML 2.0 profile package, while Figures 2 and 3 depict the notation used for the stereotypes.

The Push-Pull primitive consists of the following stereotypes and constraints: – IPush: A stereotype that extends the Interface metaclass and contains methods that Push data among components. – IPull: A stereotype that extends the Interface metaclass and contains methods that Pull data among components. – PushPort: A stereotype that extends the Port metaclass and is supported by IPush as provided interface and IPull as required interface. This can be formalized using two OCL constraints:

A Push port is typed by IPush as a provided interface

inv: self.basePort.provided->size() = 1 and self.basePort.provided->forAll( i:Core::Interface |

IPush.baseInterface->exists (j | j=i))

A Push port is typed by IPull as a required interface

inv: self.basePort.required->size() = 1 and self.basePort.required->forAll( i:Core::Interface |

IPull.baseInterface->exists (j | j=i))

PullPort: A stereotype that extends the port metaclass and is supported by IPush as required interface and IPull as provided interface. This can be formalized using two OCL constraints for the Pull port:

A Pull port is typed by IPull as a provided interface inv: self.basePort.provided->size() = 1 and self.basePort.provided->forAll( i:Core::Interface |

IPull.baseInterface->exists (j | j=i))

A Pull port is typed by IPush as a required interface

inv: self.basePort.required->size() = 1 and self.basePort.required->forAll( i:Core::Interface |

IPush.baseInterface->exists (j | j=i)) inv: self.baseConnector.end->size() = 2

Push: A stereotype that extends the Connector metaclass and connects a PushPort with a matching PullPort of another component.

A Push connector has only two ends.

A Push connector connects a PushPort of a component to a matching PullPort of another component. A PushPort matches a PullPort if the provided interface of the former matches the required interface of the later inv: self.baseConnector.end->forAll( e1,e2:Core::ConnectorEnd | e1 <> e2 implies ( (e1.role->notEmpty() and e2.role->notEmpty()) and (if PushPort.basePort->exists(p | p.oclAsType(Core::ConnectableElement) = e1.role) then (PullPort.basePort->exists(p | p.oclAsType(Core::ConnectableElement) = e2.role) and e1.role.oclAsType(Core::Port).required = e2.role.oclAsType(Core::Port).provided) else

PullPort.basePort->exists(p|

Modeling Architectural Pattern Variants 7

p.oclAsType(Core::ConnectableElement) = e1.role) endif)))

Pull: A stereotype that extends the Connector metaclass and connects a PullPort with a matching PushPort of another component.

A Pull connector has only two ends.

inv: self.baseConnector.end->size() = 2

A Pull connector connects a PullPort of a component to a matching PushPort of another component. A PushPort matches a PullPort if the provided interface of the former matches the required interface of the later inv: self.baseConnector.end->forAll( e1,e2:Core::ConnectorEnd | e1 <> e2 implies ( (e1.role->notEmpty() and e2.role->notEmpty() ) and (if PushPort.basePort->exists(p | p.oclAsType(Core::ConnectableElement) = e1.role) then (PullPort.basePort->exists(p | p.oclAsType(Core::ConnectableElement) = e2.role) and e1.role.oclAsType(Core::Port).required = e2.role.oclAsType(Core::Port).provided) else

PullPort.basePort->exists(p| p.oclAsType(Core::ConnectableElement) = e1.role) endif)))

Known uses in patterns: – In the Model-View-Controller [ 4 ] pattern, the model pushes data to the view, and the view can pull data from the model. – In the Pipes and Filters [ 4 ] pattern, filters push data, which is transmitted by pipes to other filters. In addition, pipes can request data from source filters (Pull) to transmit it to the target filters. – In the Publish-Subscribe [ 4 ] pattern, data is pushed from a framework to subscribers and subscribers can pull data from the framework. – In the Client-Server [ 4 ] pattern, data is pushed from the server to the client, and the client can send a request to pull data from the server. 4.2

Virtual Callback

Context: Consider two components are connected via a callback mechanism. In many cases the callback between components does not exist directly, rather there exist mediator components between the source and the target components. Such information should be represented at the design level. For instance, in the MVC pattern, a model may call a view to update its data but this data may be rendered first by the mediator components before it is displayed on the GUI.

Modeling Issues: The virtual relationship is an important aspect to show collaborating elements. The standard UML supports connector or association links to model virtual relationships. However, such a relationship cannot be made explicit in standard UML as it may become difficult to determine which components have subscribed to other components to be called back virtually.

Modeling Solution: To capture the semantics of Virtual Callback properly in UML, we extend the Callback [ 14 ] primitive with constraints that a virtual callback can only be used between two components where there is a path of components and connectors that links A to B using following constraints:

To capture the semantics of callback primitive properly in UML, we use the following stereotypes: VirtualCallback, EventEnd, and CallbackEnd. The VirtualCallback extends the Connector metaclass while the EventEnd and CallbackEnd extend the ConnectorEnd metaclass where the EventOccurence takes place at the sender component (EventEnd) while the EventExecution takes place at the receiver end (CallbackEnd).

Known Uses in Patterns: – In the MVC [ 4 ] pattern, the view and model components may communicate to each other virtually using callback operation. – In the Observer [ 6 ] pattern, the subjects may observe the target objects virtually. – In the Publish-Subscribe [ 4 ] pattern, the publishers may callback subscribers virtually. Context: This primitive converts the provided interface of a component into the interface the clients expect. The Delegation Adaptor primitive is a close match to the Object Adaptor [?] pattern.

Modeling Issues: Adaptors shield the underlying system implementation from its surroundings. However, adaptors can not be explicitly modeled using the architectural abstractions present in UML as their task is more focused on conversion rather than computation.

Modeling Solution: To capture the semantics of Adaptor properly in UML, we propose the following new stereotypes: AdaptorPort extends the Port metaclass and is typed by the IAdaptor as provided interface and IAdaptee as required interface. Both the IAdaptor and IAdaptee stereotypes extend the Interface metaclass.

Known Uses in Patterns: – In the Layers [ 4 ] pattern, the adaptor supports the separation of explicit interface of a layer from its implementation. – In the Broker [ 4 ] pattern, the adaptor translates the messages coming from remote services to the underlying system. – In the Microkernel [ 4 ] pattern, the adaptor is used to map communication between external and internal servers.

– In the Proxy [ 6 ] pattern, the adaptor is used to separate the interface from the implementation. 4.4

Passive Element

Context: Consider an element is invoked by other elements to perform certain operations. Passive elements do not call operations of other elements.

Modeling Issues: UML components do not structurally differentiate between active and passive elements. Such a differentiation is important to understand clearly the responsibility of individual elements in the design.

Modeling Solution: To capture the semantics of Passive Element properly in UML, we use the following new stereotypes: PElement extends the Component metaclass and attaches the PassivePort. The IPassive stereotype extends the Interface metaclass and types the PassivePort, which extends the Passive metaclass.

Known Uses in Patterns: – In the Pipes and Filters [ 4 ] pattern, the passive filter cannot pull or push data to its neighboring filters. – In the MVC [ 4 ] pattern, the passive view only receives or displays data to the user and does not invoke any operation on a model or controller elements. – In the Client-Server [ 4 ] pattern, the passive server does not invoke any operation on clientside and responds only to the client requests. 4.5

Interceder

Context: Sometimes certain objects in a set of objects cooperate with several other objects. Allowing direct link between such objects can overly complicate the communication and result in strong coupling between objects [ 6 ]. To solve this problem, Interceder components are used.

Modeling Issues: Interceder components are typically involved in decoupling components and store the collective behavior of interacting components. The structural representation of mediator components in UML diagrams is hard to understand.

Modeling Solution: To capture the semantics of Interceder primitive properly in UML, we propose following new stereotypes: Incdr, IncdrPort, and IFIncdr. Incdr extends the Component metaclass and attaches IncdrPort. IncdrPort extends the Port metaclass and is typed by the provided interface IFIncdr.

Known Uses in Patterns: – In the PAC [ 4 ] pattern, a controller is used to intercede communication between agents in the PAC hierarchy. – In the Microkernel [ 4 ] pattern, an interceder component receives requests from external server and dispatches these requests to one or more internal servers. – In the Reflection [ 4 ] pattern, the meta level components intercede communication by providing interfaces to facilitate modification in underlying components. 5

The Pattern-Primitive Relationship

Architectural patterns and architectural primitives are complementary concepts. Modeling patterns in a system design is applying one of the alternate solutions to solve specific problems at hand [ 4 ] where as primitives serve as the building blocks for expressing architectural patterns. In this context, patterns offer general solutions while primitives offer relatively more specific solutions. Similar to the selection of architectural patterns among complementary patterns, primitives might also need to be selected among complementary primitives, e.g., based on the system requirements you might choose either Shield or Indirection. Such a decision to select the appropriate primitive involves the context in which the pattern is applied, and the specific solution variant addressed by the pattern. Moreover, certain primitives can be used in combination with

ead ead llackb tiirceon ignup iregn itrsacaognC tiissacoonC trecnonoC lllaaacbkC tro litseeevnEm tlro reecd aC Ind roG ayL eggA opCm ilehdS iypngT iltrauV suhP lluP tiruV adpA aP onC tIren

s other primitives. For example, the Callback and Push-Pull primitives can work in conjunction to serve a common purpose.

Table 1 provides a patterns-to-primitives mapping, which is based on the primitives discovered so far in our work. The detailed discussion about the discovery of each primitive in the related patterns is already documented in the Known Uses in Patterns subsections of our current and previous work (see Section 3 and [ 14 ] for details). The intention is to use the pool of all available primitives to model several architectural patterns. However, the mapping from patterns to primitives is not one-to-one: rather different variants of the patterns can be modeled using a different combination of primitives. Thus, the decision to apply a specific primitive for modeling patterns lies with the architect who selects primitive(s) that best meet the needs to model the selected pattern(s).

The issues addressed above directly deal with the traditional challenge of modeling pattern variability. The solution variants entailed by a pattern can be applied in infinite different ways and so is the selection of primitives for modeling pattern variants. More important is that whichever pattern variant is applied in system design, it should address the solution clearly with structural and semantic presence. Using our primitives allows an architect to apply a near infinite solution variants with certain level of reusability. Such a reusability support also depends on the context in which the pattern is applied as in some cases extra constraints or missing pattern semantics may be required. 5.1

Expressing Missing Pattern Semantics in UML

An important aspect of modeling architectural patterns is the explicit demonstration of patterns in system design and support for automated model validation. Such a representation helps in better understanding of the system by allowing the user to visualize and validate the patterns. The primitives described above capture recurring building blocks found in different patterns. However, it may be the case that certain pattern aspects of a specific solution variant may not be fully expressed by the existing set of primitives. Therefore, for expressing missing pattern semantics that are not covered by the primitives, we provide support to the user with a vocabulary of design elements that can be used alongside with the primitives to fully express pattern semantics such as pipes, filters, client, server etc. For this purpose, we define few stereotype in UML with known semantics of the selected architectural patterns. For instance, a component can be stereotyped as filter and a connector can be stereotyped as pipe. The stereotyping scheme presented here is further complimented by using these stereotypes for modeling the example patterns in the next section.

The use of pattern-specific design elements for expressing pattern variants has a number of significant benefits. First, it offers reusability support for expressing patterns in system design. The well-known properties entailed by documented pattern variants can be reapplied in system design as a solution to new problems. Second, this makes it easier for a stakeholder to understand design of the system. For example, the use of design vocabulary to express pipes and filters in system design makes an architecture more explicit to understand and the way different architectural elements fit in the structure. Third, it offers a good support for automated model validation by ensuring that selected patterns are correctly applied in a system design. All of these three benefits compliment our use of primitives for modeling patterns. The intention is that though primitives offer good reusability and model validation support, as advocated in our current and previous work [ 14 ], the stereotyping scheme presented in this section makes the story complete for the systematic modeling of architectural patterns and pattern variants.

Modeling Architectural Patterns Using Primitives

In this section, we use the primitives and stereotyping scheme described in the previous sections to model specific pattern variants. The patterns modeled in this section are specialization to the patterns documented in POSA [ 4 ] and hence are called pattern variants. We do not claim to cover all the variability aspects of the selected patterns. However, an effort to describe selected pattern variants using primitives provides a solid base for modeling unknown pattern variants as well. To serve this purpose, we have selected three traditional architectural patterns namely the Layers, Pipes and Filters, and Model-View-Controller (MVC). We use the following guidelines to model each selected pattern variant: – A brief description of selected pattern variants – Mapping selected pattern variants to the list of available primitives – Highlight the issues in modeling pattern variants using primitives – Use stereotyping scheme to capture the missing pattern semantics. The Pipes and Filters pattern consists of a chain of data processing filters, which are connected through pipes. The filters pass the data output to the adjacent filters through pipes. The elements in the Pipes and Filters pattern can vary in the functions they perform e.g. pipes with data buffering support, feedback loops, forks, active and passive filters etc. The primitives discovered so far address many such variations for systematically modeling Pipes and Filters pattern. However, certain aspects of the Pipes and Filters pattern may not be fully expressed by the primitives e.g. feedback loops, forks, etc. The requirements we consider in this section for modeling the specific Pipes and Filters pattern variant are: a) filters can push or pull data from the adjacent filters; b) filters can behave as active or passive elements; and c) feedback loop.

At first, we map the selected Pipes and Filters pattern variant to the list of available primitives. We select the Push, Pull, and Passive Element primitives from the existing pool of primitives. The rationale behind the selection of these primitives is as follows: – The Push and Pull primitives are used to express the pipes that transmit streams of data between filters. – The filters that are not involved in invoking any operations on their surrounding elements are expressed using the Passive Element primitive.

Missing Semantics: As described in section four, the challenge to model missing pattern semantics is solved by stereotyping UML elements. In the current example, the selected primitives are sufficient to express the Push, Pull, and Passive Elements in the Pipes and Filters pattern. However, we identify that the feedback loop cannot be fully expressed using the existing set of primitives. The existing primitives can express that the data is pushed or pulled between the filters but this does not express the presence of a feedback structure. Similarly, the semantics of the Pipe and Filter elements are not applied using the existing set of primitives.

Additional Stereotypes: We apply the Feedback stereotype on the Push primitive to capture the structural presence of feedback loop in the Pipes and Filters pattern. Such a structure represents that the data is pushed from one filter to another filter using the feedback loop. The original Push primitive, as described in section four, extends the UML metaclasses of connector, interface, and port. While the feedback stereotype further specializes the Push primitive by labeling it as Feedback. The introduction of feedback stereotype does not introduce new constraints nor affects the underlying semantics of the Push primitive. Figure 5 shows the stereotypes used for expressing Pipes and Filters pattern. Feedback: A stereotype that is applied to the Push primitive for expressing the Feedback structure in the Pipes and Filters pattern variant. Feedback stereotype extends the Connector metaclass of UML.

The second stereotype named Filter that we use from the existing vocabulary of design elements is defined as follows:

Filter: A stereotype that extends the Component metaclass of UML and attaches input and output ports.

A Filter component is formalized using the following OCL constraints: An Input port is typed by Iinput as a provided interface inv: self.basePort.provided->size() = 1 and self.basePort.provided->forAll( i:Core::Interface |

Iinput.baseInterface->exists(j | j = i))

The third stereotype that we use from the existing vocabulary of design elements is Pipe that is defined as follows: Pipe: A stereotype that extends the Connector metaclass of UML and connects the output port of one component to the input port of another component.

A Pipe is formalized using following OCL constraints:

As shown in figure 6, the first filter in the chain works as a passive filter and does not invoke any operations on its surrounding filters. While the second filter is an active filter, which pulls data from the passive filter and after processing pushes this data to the next filter in the chain. The third filter in the chain sends data back to the passive filter for further processing, and sends the final processed data to the sink. The structure of the MVC pattern consists of three components namely the Model, View, and Controller. The Model provides functional core of an application and notifies views about the data change. Views retrieve information from the Model and display it to the user. Controllers translate events into requests to perform operations on View and Model elements. Usually a change propagation mechanism is used to ensure the consistency between the three components of the MVC pattern [ 4 ].

As a first step, we map the MVC pattern to the list of available primitives as shown in the table in section four. We select the Callback, Passive Element and Control primitives for modeling the MVC pattern. The rationale behind the selection of these primitives is as follows: – The View subscribes to the model to be called back when some data change occurs and works as passive object by not invoking any operation on the Model.

Missing Semantics: However, not every aspect of the MVC pattern can be modeled using the existing set of primitives. For instance, the Model, View, and Controller components are not mapped to any primitives discovered so far. Keeping in view the general nature of these components, there is a need to provide reusability support by including these three pattern elements in the existing vocabulary of design elements.

Additional Stereotypes: As described above, despite the reusability support offered by the selected primitives, the MVC pattern semantics are not structurally distinguishable. We use the following three stereotypes from the existing set of design elements:

Model: A stereotype that extends the Component metaclass of UML and attaches ports for interaction with the Controller and View components.

Controller: A stereotype that extends the Component metaclass of UML and attaches ports for interaction with the Model and View components.

View: A stereotype that extends the Component metaclass of UML and attaches ports for interaction with the Model and Controller components.

As shown in Figure 7, the Controller receives input and translates it into requests to the associated model using the Control primitive. While, the Model calls back View when a specific data change occurs. The Layers pattern groups elements at a certain level of abstraction where lower layers provide services to the adjacent upper layer. Such a structure is used to reduce dependencies between objects in different Layers. As a first step, we map the Layers pattern to the list of available primitives and select the Layering primitive. The rationale behind the selection of this primitive is as follows: – Components are members of specific layers where each lower layer provides services to the adjacent upper layer – A component can only be a member of one layer

Missing Semantics: In the Layers pattern, the high-level functions implementation relies on the lower level ones. Such system requires horizontal partitioning where each partition carries operations at a certain level of abstraction. As each layer in the Layers pattern is a virtual entity so it cannot exist without the presence of at least one component. Moreover, the upper layers cannot bypass the layers for using services in the bottom layers i.e. in Figure 8, the group members from layer3 can call components in layer2, but not into layer1.

Additional Stereotypes: Almost all structural characteristics of the Layers pattern are modeled using the Layering primitive as shown in Figure 8. Using the layering primitive, the constraints assure that within an individual layer all component work at the same level of abstraction and no component belongs to more than one layer at any time. Moreover, no additional stereotyping of UML elements is required to model this specific variant of the layers pattern. The approach described in this paper is based on our previous work [ 14 ] where we present an initial set of primitives for modeling architectural patterns. However, the idea to use primitives for software design is not novel and has been applied in different software engineering disciplines [ 12 ]. The novelty of our work lies in the use of primitives for systematically modeling architectural patterns, which has not be addressed before.

Using different approaches, a few other researchers have been working actively on the systematic modeling of architectural patterns [ 8 ]. Garlan et al. [ 8 ] proposes an object model for representing architectural designs. The authors characterize architectural patterns as specialization of the object models. However, each such specialization is built as an independent environment, where each specialization is developed from scratch using basic architectural elements. Our approach significantly differs in a way that our focus is on reusing primitives and pattern elements and only where required we extend the primitives and pattern elements to capture the missing pattern semantics.

Simon et al. [ 10 ] extends the UML metamodel by creating pattern-specific profiles. The work by Simon et al. maps the MidArch ADL to the UML metamodel for describing patterns in software design. However, this approach does not address the issue of modeling a variety of patterns documented in the literature rather manual work is required to create profiles for each newly discovered pattern. Our approach distinctively differs from this work as we focus on describing a generalized list of patterns using the primitives.

Mehta et al. [ 12 ] propose eight forms and nine functions as basic building blocks to compose pattern elements. Their approach focuses on a small set of primitives for composing elements of architectural styles. Our approach is different in the sense that we offer a more specialized set of primitives that are captured at a rather detail level of abstraction. Moreover, we use vocabulary of pattern elements in parallel to architectural primitives to capture the missing semantics of architectural patterns. 8

Conclusion

Using architectural primitives and pattern-specific design elements vocabulary in combination offers a systematic way to model patterns in system design. We have extended the existing pool of primitives with the discovery of five more primitives. With the help of few examples, we show an approach for modeling architectural pattern variants using primitives. The scheme to use stereotyping in conjunction with primitives offers: a) reusability support by providing vocabulary of design elements that entail the properties of known pattern participants; b) automated model validation support by ensuring that the patterns are correctly modeled using primitives; and c) explicit representation of architectural patterns in system design.

To express the discovered primitives and design elements vocabulary, we have used UML2.0 for creating pattern-specific profiles. As compared with the earlier versions, UML2.0 has come up with many improvements for expressing architectural elements. However, we still find UML as a weak option in modeling many aspects of architectural patterns e.g. weak connector support. As a solution to this problem, the extension mechanisms of the UML offers an effective way for describing new properties of modeling elements. Moreover, the application of the profiles to the primitives allows us to maintain the integrity of the UML metamodel. By defining primitivespecific profiles, we privilege a user to apply selective profiles in the model.

As future work, we would like to advance in the automation of our approach by developing a tool, which supports modeling pattern variability, documentation, analyzing the quality attributes, source code generation, etc. We believe that we can discover more primitives in different architectural views in near future, which will provide a better re-usability support to architects for systematically expressing architectural patterns.

Appendix

For the architectural primitives presented in this work, following we provide the OCL constraints used to express the semantics of architectural primitives precisely in a system design. We use the following OCL constraints to define the semantics of callback primitive: inv: self.baseConnector.end.role.oclAsType(

Core::Property).class->forAll( c1,c2:Core::Component | c1 <> c2 implies

c1.oclAsType(Core::Component).connects(c2))

9.2 Delegation Adaptor

AdapteePort is typed by IAdaptor as a required interface

9.3 Passive Element

To capture the semantics of Passive Element properly in UML, we use the following OCL constraints:

PassivePort provides the IPassive interface inv: self.basePort.provided->size() = 1 and self.basePort.provided->forAll( i:Core::Interface |

IPush.baseInterface->exists (j | j=i))

PElement attaches the PassivePort inv: self.baseComponent.ownedPort.name = ’PassivePort’ Modeling Architectural Pattern Variants 21

9.4 Interceder

To capture the semantics of Interceder primitive properly in UML, we use the following OCL code:

A IncdrPort is typed by IRIncdr as a provided interface inv: self.basePort.provided->size() = 1 and self.basePort.provided->forAll( i:Core::Interface |

IRIncdr.baseInterface->exists (j | j=i))

A IncdrPort is typed by IFIncdr as a provided interface

inv: self.basePort.provided->size() = 1 and self.basePort.provided->forAll( i:Core::Interface |

IFIncdr.baseInterface->exists (j | j=i))

References

1. Object constraint language specification . OMG Standard , 1 .1.

2. R. Allen and D. Garlan . A formal basis for architectural connection . ACM Transactions on Software Engineering and Methodology , Volume 6 , No. 3(ACM Transactions on Software Engineering and Methodology): 213 - 249 , 1997 .

3. M. Bjorkander and C. Kobryn . Architecting systems with uml 2.0 . IEEE Softw ., 20 ( 4 ): 57 - 61 , 2003 .

4. F. Buschmann , R. Meunier , H. Rohnert , P. Sommerlad , and M. Stal . Pattern-Oriented Software Architecture , Volume 1 : A System of Patterns . Wiley & Sons, 1996 .

5. D. C. S. Frank Buschmann , Kevlin Henney . Pattern-Oriented Software Architecture: A Pattern Language for Distributed Computing . Wiley Series in Software Design Patterns , 2007 .

6. D. C. S. Frank Buschmann , Kevlin Henney . Pattern-Oriented Software Architecture: On Patterns and Pattern Languages. Wiley Series in Software Design Patterns , 2007 .

7. E. Gamma , R. Helm , R. Johnson , and J. Vlissides . Design Patterns: Elements of Reusable Object-Oriented Software . Addison-Wesley , 1994 .

8. D. Garlan , R. Allen , and J. Ockerbloom . Exploiting style in architectural design environments . SIGSOFT Softw. Eng. Notes , 19 ( 5 ): 175 - 188 , 1994 .

9. D. Garlan , R. Monroe , and D. Wile . Acme: an architecture description interchange language . In CASCON '97: Proceedings of the 1997 conference of the Centre for Advanced Studies on Collaborative research, page 7 . IBM Press, 1997 .

10. S. Giesecke , F. Marwede , M. Rohr , and W. Hasselbring . A style-based architecture modelling approach for uml 2 component diagrams . In Proceedings of the 11th IASTED International Conference Software Engineering and Applications (SEA' 2007 ), pages 530 - 538 . ACTA Press, Nov . 2007 .

11. A. W. Kamal and P. Avgeriou . An evaluation of adls on modeling patterns for software architecture design . In 4th International Workshop on Rapid Integration of Software Engineering Techniques, 26 November 2007 .

12. N. R. Mehta and N. Medvidovic . Composing architectural styles from architectural primitives . In ESEC/FSE-11: Proceedings of the 9th European software engineering conference held jointly with 11th ACM SIGSOFT international symposium on Foundations of software engineering , pages 347 - 350 , New York, NY, USA, 2003 . ACM.

13. M. Shaw , R. DeLine, D. V. Klein , T. L. Ross , D. M. Young , and G. Zelesnik . Abstractions for software architecture and tools to support them . IEEE Trans. Softw . Eng., 21 ( 4 ): 314 - 335 , 1995 .

14. U. Zdun and P. Avgeriou . Modeling architectural patterns using architectural primitives . Proceedings of the 20th annual ACM SIGPLAN conference on Object oriented programming, systems, languages, and applications , pages 133 - 146 , 2005 .

9 An Interceder component owns IncdrPort inv: self .baseComponent.ownedPort.name = 'IncdrPort'