is an OMG standard for defining meta-models, i.e., the abstract syntax of a modeling language. The problem of model transformation is similar to,the one of program transformation and it also makes use of metaprogramming techniques [CH03, SK03]. However, it takes a slightly different direction by working with object-oriented metamodels, which define object graphs rather than syntax trees. We define the term model transformation in the following way: A model transformation is a mapping of a set of models onto another set of models or onto themselves, where a mapping defines correspondences between elements in the source and target models. There are a number of different contexts of use that are applicable to QVT model

E-business software systems are typically incorporated in complex concurrent and interacting business activities. Understanding the concurrent and interactive demands of the environment and tracing these requirements down to implementation is an important and necessary part of developing these types of systems. In this paper, we illustrate how concurrency concerns can be integrated in a UML-based software development method, and how these concerns can be incrementally refined from requirements to implementations. Our proposed approach not only offers a much needed holistic approach to concurrency in software development, but it also offers some novel techniques to describe concurrency concerns at each level of UML description.

Business process integration and automation are among the most significant factors driving the information technology industry today. In addressing the manifold technology challenges of integration and automation, new standardization efforts aim at improving the interoperability of businesses by moving toward a declarative specification of business processes, that is, one which describes what a business process does and not how it is implemented. At the same time, Model Driven Architecture® focuses on improving the software-engineering methods with which business process solutions are implemented by separating the business or application logic from the underlying platform technology and representing this logic with precise semantic models. In this paper, we present an approach to the model-driven generation of programs in the Business Process Execution Language for Web Services (BPEL4WS), which transforms a graphically represented control-flow model into executable code by using techniques that originated in compiler theory. We discuss the underlying algorithms as well as general questions concerning the representation and analysis of model transformations. We study a declarative representation of transformation rules, where preconditions and postconditions are represented in the Object Constraint Language. By adopting a declarative approach, we pave the way for future automatic consistency checking of transformation rules and bidirectional reconciliation of evolving models.

For the MDA vision to become a reality, there must be a viable means to perform model-to-model transformation. In this paper, we compare and contrast two approaches to model transformation: one is a graph transformation-based approach, and the other is a relational approach, based on the QVT-Merge submission for OMG’s MOF 2.0 Query/View/Transformation Request for Proposal. We apply them both to a common example, which involves transforming UML statemachines to a CSP specification, and we look at some of the concrete and conceptual differences between the approaches.

Round-trip engineering is a challenging task that will become an important enabler for many Model-Driven Software Development approaches. Model round-trip engineering involves synchronizing models by keeping them consistent, thus enabling the software engineer to freely move between different representations. The vision of model round-trip engineering (MRTE) is only realized to a limited degree in Integrated Development Environments (IDE) nowadays, and it proves to be a very difficult problem to solve in general. In this paper, our goal is to clarify some of the issues in automating MRTE and point out some of the high-level qualities that are desirable for MRTE approaches to possess. Clarifying this domain is an important first step towards being able to automate round-trip engineering of models.

Software development teams are faced with bridging the gap between the problem, as envisaged by the stakeholders and constrained by the environment, and a software solution, which is built upon the abstractions offered by current software technologies. Unfortunately, too often the abstractions offered are limited and disparate with respect to the problem space. Reducing this gap would facilitate more sophisticated problems to be tackled in software development projects, and it would comparatively reduce development costs and time-to-market, and remove errors caused by the disparity. In this talk, I will explore a number of techniques for improving current software development practice, which relate to the theme of domain-driven software development. Domain-driven software development is concerned with making use of languages that better capture the problem by using abstractions that are more familiar to experts in the domain. These domain-specific languages are made executable either directly (compilation or interpretation) or through tool-supported refinement/elaboration to computational models that can be executed, e.g., to a mainstream programming language where one can make use of existing frameworks, components, services, etc. In the later case, real value is added to software development only if we can automate as much as possible the transformation step(s). Automating these steps requires languages that can express such transformations in a concise and maintainable manner. The principles of abstraction, separation of concerns, and problem decomposition are essential in providing intuitive and manageable domain-specific languages. The practice of software modeling has become a significant way of applying these principles to software development. Over the last few years, the software development industry has gone through the process of standardizing visual modeling notations. The Unified Modeling Language (UML) is the product of this effort, and it unifies scores of notations that were proposed in the '80s and '90s. The language has gained significant industry support and became an object management group (OMG) standard in 1997. Nowadays, the majority of software modeling techniques and approaches use UML.

Nowadays, the complexity of the software systems that needs to be produced is staggering. Developing such systems requires that the development team first understands the problem, i.e., they have a global picture of what is required to be built, before they can make a sensible judgment on an architecture for the solution. Use cases offer a simple, storytelling-like way to capture the requirements. They provide a means for facilitating the capture and validation of requirements from stakeholders, technical and non-technical alike, which makes them an important tool to have in one’s development kit. The simplicity of the use case concept is nevertheless deceptive, because writing effective use cases requires much practice and experience. In fact, there are many issues that must be addressed on the road to mastering requirements elicitation with use cases. In this tutorial, a number of these issues will be raised and addressed, giving the participants a better understanding of what an effective use case is, how to produce them, and where use cases in general can be appropriately applied.

For the Model Driven Architecture (MDA) vision to become a mainstream reality, high-level languages are needed to concisely express and execute model transformations. Both generative and graph transformation approaches for model transformation specification and execution have much to offer in this regard. If one were to combine techniques from both worlds, would one end up with a powerful and effective tool or a complicated and inconsistent mess? In this short paper, I briefly highlight how I have combined some of these techniques in a model transformation language called Genermorphous (Gmorph for short), which attempts to package these two powerful techniques into a single coherent language. My goal with this short paper is to stimulate discussion in the workshop towards the discovery of optimal ways to use generative and graph rewriting techniques together for MDA-oriented transformation languages.

The model-driven approach can increase development productivity and quality by describing important aspects of a solution with human-friendly abstractions and by generating common application fragments with templates. This article examines different approaches to model transformations and recommends desirable language characteristics for describing them.

The model-driven architecture approach (MDA) promotes software development as driven by a thorough modeling phase where application code is automatically generated from a platform specific UML model (PSM). The idea is that the PSM is itself derived from a platform independent UML model (PIM). Such code generation and model derivation are examples of model-to-model transformations. This paper presents the Visual Model Transformation (VMT) approach, which includes a transformation language and a tool to support UML model transformations. The transformation language is a visual declarative language that supports the specification, composition and reuse of model transformation rules. These rules make use of the OCL language and a visual notation to indicate the selection, creation, modification and removal of model elements. An abstract denotational semantics based on graph transformation is sketched for the VMT language. We also present the MEDAL tool, which is a prototype build on top of IBM/Rational XDE development environment, and is a first step towards tool support for the VMT approach.

In recent times, there has been an increased requirement for software to be distributed. The well-known Fusion development method, however, can only be used to develop sequential reactive systems, and certain restricted kinds of concurrent systems. In contrast, the Unified Modeling Language (UML) provides a rich set of notations that can be used to model systems that are distributed. In addition, UML provides the ability to introduce rigor into diagrams through its constraint language OCL. In this paper, we present a UML-based Fusion analysis phase by way of a simple bank case study, and we discuss some enhancements that were made in addition to a mapping of notations; our proposal is the first step towards providing a Fusion-based analysis phase which supports high-level modeling of distributed systems.

A lot of attention has been paid to software architecture issues in academia, industrial research and standardization organizations working in the software area. The software architecture research community has focused on the creation and improvement of special-purpose languages: architecture description languages (ADLs). However, ADLs lack adequate support for separating various kinds of stakeholders’ concerns along different viewpoints. But also, they do not address the difference between the architecture of a software system and its representations. In contrast, ANSI/IEEE-Std-1471 makes a clear distinction between the architecture and the architectural description of a software system. In this paper, we propose ConcernBASE, a UML-based approach to software architecture, which instantiates the conceptual framework defined in ANSI/IEEE-Std-1471 and complements the abstractions and mechanisms found in current ADLs. ConcernBASE provides a viewpoint for structural descriptions of software architectures that supports key concepts of ADLs and defines a UML profile as a viewpoint language. We validate this profile through a mapping between a representative ADL, called Structural ADL (SADL), and the new profile and by providing a UML-based tool prototype, called ConcernBASE Modeler, which integrates with SADL tools.

Use cases are an excellent tool for capturing behavioral requirements of software systems, but they are not an ideal work product for driving design activities. We believe that there is value from complementing use case descriptions with pre- and postcondition descriptions, not only to better support reasoning about system properties and a basis for testing and debugging, but also to better support a predictable decomposition level on which one can base a systematic transition to design. Nevertheless, we recognize that pre- and postcondition descriptions are not widely used in practice. We believe this is in part due to the formalism used. Either the formalism is too heavy to learn and use, or the formalism does not offer sufficient abstraction from the vocabulary of implementation.Via an example, the paper highlights our approach for specifying system behavior, which uses the Unified Modeling Language (UML) and its Object Constraint Language (OCL). We focus the paper on pre- and postconditions descriptions and in particular propose a number of enhancements and interpretations to OCL that we made while refining our approach. In particular, we describe a number of issues that cover areas such as the frame problem, incremental descriptions, structuring schemas, and events and exceptions.

What constitutes a good example in the context of teaching design patterns? How can instructors judge whether one example is better than another one for teaching a design pattern to students? How might an example be presented to best connect with students, equipping them with the necessary know-how? In this paper, I address these questions by offering a means to judge the quality of examples for teaching design patterns: a list of desirable characteristics. The proposed list can be used to gauge the quality of examples and/or it can be used to guide the development of examples.

%675$&7 We describe ConcernBASE, a UML-based approach that is an instantiation of the IEEE’s Conceptual Framework (Std 1471) for describing software architectures. We show how the approach supports advanced separation of concerns in software architecture by allowing one to identify and define multiple viewpoints, concern spaces and views of an architecture. Our work focuses on integrating the ConcernBASE approach with the Structural Architecture Description Language (SADL) in order to make the verification capabilities of SADL available to those who develop in UML. The result is a UML profile for structural description of software architecture. The paper also presents a prototype tool that supports this UML profile.