Eunjee Song

A UML-based pattern specification technique

Informally described design patterns are useful for communicating proven solutions for recurring design problems to developers, but 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. 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.

Directives for composing aspect-oriented design class models

An aspect-oriented design model consists of a set of aspect models and a primary model. Each aspect model describes a feature that crosscuts elements in the primary model. Aspect and primary models are composed to obtain an integrated design view. In this paper we describe a composition approach that utilizes a merging algorithm and composition directives. Composition directives are used when the default merging algorithm is known or expected to yield incorrect models. Our prototype tool supports default class diagram composition.

A metamodeling approach to pattern-based model refactoring

Design patterns capture development solutions to design problems in forms that make the designs more modular, modifiable, reusable, and understandable. This metamodeling approach to pattern-based refactoring of design models incorporates the precise specification of design patterns and transformation rules.

Model Composition Directives

An aspect-oriented design model consists of a set of aspect models and a primary model. Each of these models consists of a number of different kinds of UML diagrams. The models must be composed to identify conflicts and analyze the system as a whole. We have developed a systematic approach for composing class diagrams in which a default composition procedure based on name matching can be customized by user-defined composition directives. This paper describes a set of composition directives that constrain how class diagrams are composed.

Verifiable composition of access control and application features

Access control features are often spread across and tangled with other functionality in a design. This makes modifying and replacing these features in a design difficult. Aspect-oriented modeling (AOM) techniques can be used to support separation of access control concerns from other application design concerns. Using an AOM approach, access control features are described by aspect models and other application features are described by a primary model. Composition of aspect and primary models yields a design model in which access control features are integrated with other application features. In this paper, we present, through an example, an AOM approach that supports verifiable composition of behaviors described in access control aspect models and primary models. Given an aspect model, a primary model, and a specified property, the composition technique produces proof obligations as the behavioral descriptions in the aspect and primary models are composed. One has to discharge the proof obligations to establish that the composed model has the specified property.

Aspect-driven, data-reflective and context-aware user interfaces design

The increasing use of Web-based applications continues to broaden the user groups of enterprise applications at large. Since ordinary users often equate the quality of user interface (UI) with the quality of the entire application, the importance of providing easy-to-use UIs has been significantly increasing. Unfortunately, designing a single UI satisfying all end users remains challenging. To address this issue, researchers and developers are looking to Context-aware/Adaptive UIs (CUIs) that aim to provide end users with more personalized user interaction experiences. Although multiple proposals have been made, very few production systems provide such malleable interfaces due to the excessive cost of development and maintenance. In this paper, we propose a technique that aims to reduce development and maintenance efforts of CUI to a level comparable with a single UI. Unlike most of the existing CUI approaches, our technique does not involve an external UI model. Instead, it aims to reflect runtime-information and structures already captured in the application, while extending them to provide an appropriate CUI. With this technique, developers do not design forms or tables directly for each page or panel. Instead they design generic and reusable transformation rules capable of presenting application data instances in the UI while considering the runtime context. To demonstrate our technique and its impact on CUI development and maintenance, we provide a case study. Moreover, we present our experience from its application to an existing production-level enterprise application, with high demands on performance.

Using UML to model relational database operations

The Unified Modeling Language (UML) is being used as the de-facto standard in the software industry. With the adoption of UML 2.0, the new enhancements allow this version to describe many of the elements found in todays software technology as well as Model Driven Architecture and Service-Oriented Architecture. Although the Object Management Group (OMG) has released several UML Profiles to tailor the language to specific areas, relational database modeling is not fully addressed in these profiles. Many existing software applications involve complex application layer implemented in object-oriented programming languages and at the same time use relational database systems as the back-end data store. Modeling the whole system in a consistent manner will help developers and end users better understand the application. In this work we show how to model relational database operations using UML. Atomic database operations are modeled based on our framework and are used as building blocks to model more complex database operations.

Using Roles to Characterize Model Families

The development of reusable requirements and design artifacts often requires one to characterize families of problem and solution models. This paper presents a metamodeling approach to characterizing a family of models. A characterization is expressed as a Role Model that consists of roles that can be played by UML model elemets. In this paper we describe how a family of UML static structural diagrams that have the structural properties defined by a pattern can be characterized by a Static Role Model (SRM). The Abstract Factory pattern is used to illustrate how SRMs can be used to specify reusable designs expressed as patterns.

Towards effective adaptive user interfaces design

The increasing use of Web-based applications continues to broaden the user groups of enterprise applications at large. The importance of providing easy-to-use user interfaces (UIs) that conform to each users specific preferences, such as different skill levels, capabilities and physical locations has, therefore, been significantly increasing. Unfortunately, designing a single UI satisfying all end users remains challenging. To address this issue, researchers and developer are looking to Adaptive User Interfaces (AUIs) that aim to provide end users with more personalized user interaction experiences. However, very few production system provide such malleable interfaces due to the excessive cost for the development and maintenance. In this paper, we propose a technique that provides AUIs for production enterprise systems while reducing development and maintenance efforts to a level comparable with a single UI development, called Rich Entity Aspect/Audit Design (READ). READ complies with application development standards used in industry to support an easy transition from design to production systems. We conclude by evaluating our approach along with a case study that demonstrates reduction in development and maintenance efforts while preserving performance.

An Approach to Verifying Security and Timing Properties in UML Models

In this paper, we present an approach to verify whether a UML design model satisfies its domain-specific security and time-related requirements in an integrated tool environment. This approach is based on a UML metamodel extension mechanism given as profiles. As a model verification tool, we chose the USE (UML-based Specification Environment) since additional functional and non-functional constraints in a UML model should be formally specified using the OCL (Object Constraint Language). In order to address both security and timing properties together in a model, we combine two profiles, UMLsec for security and MARTE (UML profile for Modeling and Analysis of Real-Time and Embedded systems) for time, into the UML metamodel. Then, this combined metamodel is converted to a form of USE specification so that it can be used for verifying models using USE. In this approach, however, this combined metamodel is considered as a large class model in USE because USE does not support profiles. Therefore, models to be verified are created as object models that are instances of the given class model, i.e. the extended metamodel in our case. Our approach is illustrated with a distributed, interoperable wireless communications-based railroad control system called the Positive Train Control (PTC) System.