Informally described design patterns are useful for communicating proven solutions for recurring design problems to developers, but they are inadequate for more rigorous use of design patterns. For example, they cannot be used as compliance points against which solutions that claim to conform to the patterns are checked. Pattern specification languages that utilize mathematical notation provide the needed formality but often at the expense of usability. In this paper we present a rigorous and practical technique for specifying pattern solutions expressed in the Unified Modeling Language (UML). The specification technique paves the way for the development of tools that support rigorous application of design patterns to UML design models. The technique has been used to create specifications of solutions for several popular design patterns. We illustrate the use of the technique by specifying Observer and Visitor pattern solutions.

Refactoring is an essential approach toward improving the internal structure of a software system while preserving its external behavior. Traditional refactoring techniques have focused on the implementation stage, with source code as the primary artifact of the refactoring process. However, a recent trend is to apply the concepts of refactoring to higher levels of abstraction. Consequently, model refactoring is emerging as a desirable means to improve design models using behavior-preserving transformations.

Abstract not found

This paper formalizes the notion of a design model structurally conforming to a design pattern by representing the model as a logic program whilst the pattern as a query. The conformance of a model to a design pattern is equivalent to the satisfaction of the query by the logic program. Harnessing logic inference capability of logic programming languages, we obtain an automated method that infers all the instances of a design pattern in a UML class diagram. We use the Visitor pattern and a price calculation application to demonstrate the technique.

A design pattern is realized in various forms depending on the context of the applications. There has been intensive research on detecting pattern instances in models and in implementations. However, little work addresses variations of pattern realization. This paper describes an approach for evaluating conformance of pattern variations. This approach uses a divide-and-conquer strategy to evaluate the structural conformance of a UML class diagram to the solution of a design pattern. A design pattern is specified in an extension of the UML that defines the pattern in terms of roles. To demonstrate the approach, we use the Visitor pattern and two case studies of a price calculator and a word processor. We also present a prototype tool that supports the approach.

An innovative middleware transparent approach to developing distributed applications is presented. The approach uses an aspect-oriented software development technique to separate an application’s middleware-independent functionality from its middleware-specific functionality. Application elements that are specific to the middleware are localized in aspects that can be seamlessly integrated into middleware-independent application designs. The middleware transparent approach is used to decouple business functionality from middleware-specific functionality. The decoupling allows developers to change mid-dleware application elements without significantly modifying business functionality. Middleware tech-nologies such as Java RMI, Jini, SOAP-RPC and.Net are used as examples to illustrate the approach.

This chapter describes a UML-based pattern specification language called the role-based metamodeling language (RBML), which defines the solution domain of design patterns in terms of roles at the metamodel level. The goal of the RBML is to support the development of precise pattern specifications that can be used for the development of pattern tools. The author describes the approaches and benefits of the RBML, and demonstrates the notation for capturing various perspectives of pattern properties using the Observer, Interpreter, and Iterator patterns. The author also discusses tool support for the RBML and the future trends in pattern specification. Copyright © 2007, Idea Group Inc. Copying or distributing in print or electronic forms without written permission of Idea Group Inc. is prohibited. Kim

A domain model captures concepts that are common to applications in the domain. The development of an application model can be greatly eased if domain models are efficiently reused. In this work, we present a metamodeling approach to developing domain models and its tool support for automatic instantiation of application models from a domain model. We use the Role-Based Metamodeling Language (RBML) to define a domain model at the metamodel level. With the structural constraints of the application under development, the domain model is instantiated to generate an initial model for the application. The generated model is then completed by adding application specific properties which are not captured in the domain model. To demonstrate the approach, we consider the CheckIn-CheckOut (CICO) domain to build a domain model and use the domain model to develop a library system and a vehicle rental system.

Abstract: This paper formalizes UML class diagrams and structural patterns as mathematical objects and provides a precise notion of conformance of a structural model specified as a class diagram to a structural pattern. We also present a conformance verification method which represents a class diagram as a logic program and a structural pattern as a query. The conformance of the class diagram to the structural pattern is verified by computing all the answers to the query by the logic program and checking the satisfaction of realization multiplicity constraints imposed by the pattern.

Test-first strategy and code refactoring are both important features in Extreme Programming methodology. In the test-first strategy, test cases are designed before system implementation. If we want to improve certain non-functional attributes of the programs which are revised by refactoring, the original test cases may be broken or inefficient for testing the new programs. In this paper, we propose an approach for test case traceability in a test-driven development and a plug-in of eclipse for performing it semiautomatically. Finally, we evaluate test coverage to show the practicability of our approach. 1.