Augmenting UML to Support the Design and Evolution of User Interfaces

The primary focus in UML has been on support for the design and implementation of the software comprising the underlying system. Very little support is provided for the design or evolution of the user interface. This chapter commences with a brief review of UML and its support for user interface modeling. Lean Cuisine+, a notation capable of modeling both dialogue structure and high-level user tasks, is described. It is shown through a case study that Lean Cuisine+ can be used to augment UML and provide the user interface support that is currently lacking.

XML-Based Analysis of UML Models for Critical Systems Development

High-quality development of critical systems poses serious challenges. Formal methods have been proposed to address them, but their use in industry is not as widespread as originally hoped. This chapter proposes to use the Unified Modeling Language (UML), the de-facto industry standard specification language, as a notation together with a formally based tool-support for critical systems development. The authors extend the UML notation with new constructs for describing criticality requirements and relevant system properties, and introduce their formalization in the context of the UML executable semantics. Furthermore tool-support concepts for this approach are presented, which facilitate transfer of the methodology to industrial applications.

PRAISE

Responding to the fact that software systems become more and more complex and mutable, not only the software-standards-related technologies should be adopted, but the environments for software development and evolution should also be flexible and integratable. These facts make software development and maintenance difficult and costly. In this chapter, we first illustrate the activities and studies for software standards, processes, CASE toolsets, and environments. Then, we propose a process and an environment for evolution-oriented software development, called the PRocess and Agent-based Integrated Software development Environment (PRAISE). PRAISE advocates software development with popular software methodologies, and it uses an XML-based mechanism to unify the various paradigms with different standards. It integrates processes, roles, toolsets, and work products to make software development more efficient. With PRAISE, users are encouraged to adopt familiar mechanisms and formal approaches as they wish. PRAISE maintains the consistency of the paradigms so that users do not need to worry about conflicts with other paradigms that are built in or added later. PRAISE meets the need for evolving software development and maintenance.

A Reuse Definition, Assessment, and Analysis Framework for UML

This chapter examines a formal framework for reusability assessment of development-time components and classes via metrics, refactoring guidelines, and algorithms. It argues that software engineers seeking to improve design reusability stand to benefit from tools that precisely measure the potential and actual reuse of software artifacts to achieve domain-specific reuse for an organization’s current and future products. The authors consider the reuse definition, assessment, and analysis of a UML design prior to the existence of source code, and include dependency tracking for use case and class diagrams in support of reusability analysis and refactoring for UML. The integration of these extensions into the UML tool Together Control Center to support reusability measurement from design to development is also considered.

Variability Expression within the Context of UML

Time-to-market is one of the most severe constraints imposed on today’s software engineers. The increasing complexity of systems has also shortened the time available for designing them. Several solutions have therefore been proposed to decrease the time and cost of producing applications. This chapter presents the product line paradigm as an effective solution for managing both the variability of products and their evolutions. The product line approach calls for designing a generic and parameterized model that specifies a family of products. It is then possible to instantiate a member of that family by specializing the “parent” model or “framework.” In describing the latter, designers need to explicitly model variability and commonality points among applications. The following discussion explains in detail how UML models express these different requirements. We then describe specific extensions of UML profiles and the way they are used in various product line methodologies.

Visualising COBOL Legacy Systems with UML

This chapter presents a report of an experimental approach that uses WSL as an intermediate language for the visualisation of COBOL legacy systems in UML. Key UML techniques are identified that can be used for visualisation. Many cases were studied, and one is presented in detail. The report concludes by demonstrating how this approach can be used to build a software tool that automates the visualisation task. Furthermore, understanding a system is of critical importance to a developer who must be able to understand the business processes being modeled by the system along with the system’s functionality, structure, events, and interactions with external entities. Such an understanding is of even more importance in reverse engineering. Although developers have the advantage of having the source code available, system documentation is often missing or incomplete, and the original users, whose requirements were used to design the system, are often long gone.

Developing Requirements Using Use Case Modeling and the Volere Template

A major contributor to the development of a quality final product is a complete, consistent, and detailed requirement specification (Pressman, 2000). No matter how good the specification and its translation into an initial system, it will evolve once it is released to users as the requirements and the environment change and the users develop. The aim of this chapter is to provide a method of establishing the baseline in terms of the requirements of a system from which evolution metrics can be effectively applied. UML (Rumbaugh, Jacobson, & Booch, 1999) provides a series of models that can be used to develop a specification which will provide the basis of the baseline system. This can then be used as a datum from which measurements can be made. One of the starting points for modeling is use case analysis. Other models can then be developed based on these initial models. One of the difficulties with this approach is that once the initial models have been agreed upon, they are not maintained as the later more detailed models evolve. The methods described in this chapter show how this can be achieved and measured.

Version Control of Software Models

We review the main concepts and algorithms behind a software repository with version control capabilities for UML and other MOF-based models. We discuss why text- and XML-based repositories cannot be used to manage models and present alternative solutions to build a model repository that takes into account specific details of MOF-based modeling languages.

Migration of Persistent Object Models Using XMI

Embrace the change! Change is a constant reality of software development, a reality that must be reflected in not only our software process but also our software production environment. With ever-changing customer requirements, modifications to the object model are required during software development as well as after product distribution. The associated migration of existing persistent object data is a nontrivial problem. This chapter presents the conceptualization and implementation of a tool for the automated migration of persistent object models. The migration is controlled by an XMI-based description of the difference between the old and the new object model. Both, the schema and the data of the persistent object model are migrated efficiently and reliably.

Using a Graph Transformation System to Improve the Quality of Characteristics of UML-RT Specifications

This chapter presents the concept of graph-based architecture evolution and how this concept can be applied to improve the quality characteristics of a software system. For this purpose, the UML-RT used as an architectural specification language is mapped to a hypergraph-based data structure. Thus, transformation operators can be specified as hypergraph transformation rules and applied automatically.