Search

Quality management is an important aspect of business processes. Organizations must implement quality requirements, e.g., according to standards like ISO 9001. Existing approaches on business process modeling provide no explicit means to enforce such requirements. UML Activity Diagrams are a well recognized way of representing those business processes. In this paper, we present an approach for enforcing quality requirements in such business processes through the application of process quality patterns to Activity Diagrams. These patterns are defined using a pattern description language, being a light-weight extension of UML Activity Diagrams. Accordingly, such patterns can be used in forward-engineering of business processes that incorporate quality constraints right from the beginning. Keywords: UML Activity Diagrams, Business Process, Process Quality, ISO 9001 [ABSTRACT FROM AUTHOR]

The MoDELS 2005 conference provides six half-day tutorials on advanced topics related to model-driven engineering, presented by recognized worldwide experts. Here, there is a short summary of each tutorial and the list of presenters. [ABSTRACT FROM AUTHOR]

It was a tradition in the previous UML series to host a number of workshops. Workshops provide the opportunity for a small group of people to exchange recent or preliminary results and to conduct intensive discussions on a particular topic. They complement in a sense the main conference and are generally very appreciated by attendees, most of them also attending the main conference. [ABSTRACT FROM AUTHOR]

In this paper we present a framework for the evaluation and (re)design of modeling languages. We focus here on the evaluation of the suitability of a language to model a set of real-world phenomena in a given domain. In our approach, this property can be systematically evaluated by comparing the level of homomorphism between a concrete representation of the worldview underlying the language (captured in a metamodel of the language), with an explicit and formal representation of a conceptualization of that domain (a reference ontology). The framework proposed comprises a number of properties that must be reinforced for an isomorphism to take place between these two entities. In order to illustrate the approach proposed, we evaluate and extend a fragment of the UML static metamodel for the purpose of conceptual modeling, by comparing it with an excerpt of a philosophically and cognitive well-founded reference ontology. [ABSTRACT FROM AUTHOR]

Multimedia applications are a branch of software development with growing importance. Typical application areas are training applications and simulations, infotainment systems - e.g. in cars - or computer games. However, there is still a lack of tailored concepts for a structured development of this kind of application. The current paper proposes a modeling approach for the user interface of multimedia applications with the goal of a model-driven development. We identify the special properties of multimedia application development and the resulting aspects to be covered by the user interface model. Existing conventional user interface modeling approaches are not sufficient, as they do not cover the media-specific aspects of the application. However, a multimedia application usually includes conventional user interface elements as well. Thus, we first propose a solution for the media-specific part. Second, we elaborate an integration of our approach with existing conventional approaches. Finally, we discuss the overall model-driven development approach and outline its benefits. [ABSTRACT FROM AUTHOR]

As model-driven development promotes metamodels as key assets it raises the issue of their reuse throughout a model-driven product line life cycle. One recurrent reuse need occurs when metamodeling integrated multi-language platforms: one construct from one language is integrated to constructs from other languages by generalizing it, making it more expressive. None of the metamodel assembly facilities provided by MOF and UML (import, merge and combine) or others proposed in previous work adequately addresses this need. We thus propose a new reuse and generalize facility for such purpose. [ABSTRACT FROM AUTHOR]

This paper discusses the applicability of modeling methods originally meant for business applications, on the design of the complex markup vocabularies used for XML Web-content production. We are working on integrating these technologies to create a dynamic and interactive environment for the design of document markup schemes. This paper focuses on the analysis, design and maintenance of XML vocabularies based on UML. It considers the automatic generation of Schemas and DTDs from a visual UML model of the markup vocabulary, as well as pieces of software, like input forms. Additionally, we integrate these UML design capabilities with other handy tools like automatic Schema simplification and multilingual markup. [ABSTRACT FROM AUTHOR]

Model-Driven Engineering (MDE) advocates the generation of software applications from models, which are views on certain aspects of the software. In this paper, we focus on a particular setup which consists of a graphical data modeling view and a view on an object-oriented implementation, which can be either textual or graphical. A challenge that arizes in the context of MDE is the notion of Round-Trip Engineering (RTE), where elements from both views can be manipulated and thus need to be synchronized. We systematically identify four fundamental RTE scenarios. In this paper, we employ the framework of these scenarios for explaining SelfSync, our approach and tool for providing dynamic support for RTE. In SelfSync, the entities of the data modeling view and the corresponding implementation objects are one and the same. Additionally, we present a comparison with related work accompanied by an extensive discussion. [ABSTRACT FROM AUTHOR]

UML design models, specifically their declarative OCL invariants, must be refined into delivered code. A key problem is the need to integrate this logic with programmer-written code in a non-intrusive way. We recently developed an approach, called mode components, for compiling OCL constraints into modules that implement logic for transparently maintaining these constraints at run time. Specifically, mode components are implemented as nested C++ class template instantiations. The approach makes use of a key device-status variables. The attributes of a component to which other components are sensitive are called its status. A status variable is a lightweight wrapper on a status attribute that detects changes to its value and transparently invokes a method to handle announcements to dependent components. A mode component is a wrapped code unit containing one or more status variables. The contribution of this paper is a technique for achieving this integration using metaprogramming techniques. [ABSTRACT FROM AUTHOR]

Autonomic computer systems aim to reduce the configuration, operational, and maintenance costs of distributed applications by enabling them to self-manage, self-heal, self-optimize, self-configure, and self-protect. This pa-per provides two contributions to the model-driven development (MDD) of autonomic computing systems using Enterprise Java Beans (EJBs). First, we describe the structure and functionality of an MDD tool that formally captures the design of EJB applications, their quality of service (QoS) requirements, and the autonomic properties applied to the EJBs to support the rapid development of autonomic EJB applications via code generation, automatic checking of model correctness, and visualization of complex QoS and autonomic properties. Second, the paper describes how MDD tools can generate code to plug EJBs into a Java component framework that provides an autonomic structure to monitor, configure, and execute EJBs and their adaptation strategies at run-time. We present a case study that evaluates how these tools and frameworks work to reduce the complexity of developing autonomic applications. [ABSTRACT FROM AUTHOR]

This paper describes and empirically evaluates a new model-driven development framework, called Modeling Turnpike (or mTurnpike). It allows developers to model and program domain-specific concepts (ideas and mechanisms specific to a particular business or technology domain) and to transform them to the final (compilable) source code. By leveraging UML metamodeling and attribute-oriented programming, mTurnpike provides an abstraction to represent domain-specific concepts at the modeling and programming layers simultaneously. The mTurnpike frontend system transforms domain-specific concepts from the modeling layer to programming layer, and vise versa, in a seamless manner. Its backend system combines domain-specific models and programs, and transforms them to the final (compilable) source code. This paper focuses on the frontend system of mTurnpike, and describes its design, implementation and performance implications. In order to demonstrate how to exploit mTurnpike in application development, this paper also shows a development process using an example DSL (domain specific language) to specify service-oriented distributed systems. [ABSTRACT FROM AUTHOR]

Many exceptional situations arise during the execution of an application. When developing dependable software, the first step is to foresee these exceptional situations and document how the system should deal with them. This paper outlines an approach that extends use case based requirements elicitation with ideas from the exception handling world. After defining the actors and the goals they pursue when interacting with the system, our approach leads a developer to systematically investigate all possible exceptional situations that the system may be exposed to: exceptional situations arising in the environment that change user goals and system-related exceptional situations that threaten to fail user goals. Means are defined for detecting the occurrence of all exceptional situations, and the exceptional interaction between the actors and the system necessary to recover from such situations is described in handler use cases. To conclude the requirements phase, an extended UML use case diagram summarizes the standard use cases, exceptions, handlers and their relationships. [ABSTRACT FROM AUTHOR]

In this paper, a domain model of dynamic system reconfiguration is presented. The intent of this model is to provide a comprehensive conceptual framework within which to address problems and solutions related to dynamically reconfigurable systems in a systematic and consistent manner. The model identifies and categorizes the various types of change that may be required, the relationship between those types, and the key factors that need to be considered and actions to be performed when such changes take place. A rigorous formal methodology, based on the Alloy language and tools, is employed to specify precisely and formally the detailed relationships between various parts of the model. [ABSTRACT FROM AUTHOR]

Many of today's software applications require a high-level of security, defined by a detailed policy and attained via mechanisms such as role-based access control (RBAC), mandatory access control, digital signatures, etc. The integration of the design/implementation processes of access-control policies with runtime enforcement mechanisms is crucial to achieve an acceptable level of security for a software application. Our prior research focused on formalizing the concept of a role slice, which is a unified modeling language (UML) artifact that captures RBAC security requirements by defining permissions in the form of allowable or prohibited methods, and by specifying roles as specialized class diagrams that contain those methods. This paper augments this effort by introducing a formal framework for the security of software applications that supports the automatic translation of a role-slice access-control policy (RBAC requirements) into aspect-oriented programming (AOP) enforcement code that is seamlessly integrated with the application. The formal framework provides the necessary underpinnings to automate the integration of security policies into software. A prototyping effort based on Borland's UML tool Together Control Center for defining role-slice diagrams and the associated AOP code generator is under development. [ABSTRACT FROM AUTHOR]

Current software systems increasingly consist of distributed interacting components. The use of web services and similar middleware technologies strongly fosters such architectures. The complexity resulting from a high degree of interaction between distributed components - that we face with web service orchestration for example - poses severe problems. A promising approach to handle this intricacy is service-oriented development; in particular with a do-main-unspecific service notion based on interaction patterns. Here, a service is defined by the interplay of distributed system entities, which can be modeled using UML Sequence Diagrams. However, we often face functionality that affects or is spanned across the behavior of other services; a similar concept to aspects in Aspect-Oriented Programming. In the service-oriented world, such aspects form crosscutting services. In this paper we show how to model those; we introduce aspect-oriented modeling techniques for UML Sequence Dia-grams and show their usefulness by means of a running example. [ABSTRACT FROM AUTHOR]

We propose bottom-up support for modeling crosscutting structure in UML by adding a simple join point model to the meta-model. This supports built-in crosscutting modeling constructs such as sequence diagrams. It also facilitates adding new kinds of crosscutting modeling constructs such as role bindings, inter-type declarations, and advice. A simple weaver produces a uniform representation of the crosscutting structure, which can then be displayed or analyzed in a variety of ways. [ABSTRACT FROM AUTHOR]

A commercial Customer Relationship Management application of approx. 1.5 MLOC of C++ code is being reimplemented, in stages, as a service-oriented, multi-tier application in C# on Microsoft .NET. We have chosen to use a domain-specific language both to model the external service-oriented interfaces, and to manage the transition to the internal, object-oriented implementation. Generic UML constructs such as class diagrams do not capture enough semantics to model these concepts. By defining a UML Profile that incorporates the concepts we wish to model, we have in effect created a Domain-Specific Language for our application. The models are edited using Rational XDE, but we have substituted our own code generator. This generator is a relatively generic text-substitution engine, which takes a template text and performs substitutions based on the model. The generator uses reflection to convert the UML and Profile concepts into substitution tags, which are in turn used in the template text. In this way, we can translate the semantics of the model into executable code, WSDL or other formats in a flexible way. We have successfully used this approach on a prototype scale, and are now transitioning to full-scale development. [ABSTRACT FROM AUTHOR]

In an ongoing effort to reduce development costs in spite of increasing system complexity, Motorola has been a long-time adopter of Model-Driven Engineering (MDE) practices. The foundation of this approach is the creation of rigorous models throughout the development process, thereby enabling the introduction of automation. In this paper we present our experiences within Motorola in deploying a top-down approach to MDE for more than 15 years. We describe some of the key competencies that have been developed and the impact of MDE within the organization. Next we present some of the main issues encountered during MDE deployment, together with some possible resolutions. [ABSTRACT FROM AUTHOR]

Collaborations and collaboration uses are features new to UML 2.0. They possess many properties that support rapid and compositional service engineering. The notion of collaboration corresponds well with the notion of a service, and it seems promising to use them for service specification. We present an approach where collaborations are used to specify services, and show how collaborations enable high level feature composition by means of collaboration uses. We also show how service goals can be combined with behavior descriptions of collaborations to form what we call semantic interfaces. Semantic interfaces can be used to ensure compatibility when binding roles to classes and when composing systems from components. Various ways to compose collaboration behaviors are outlined and illustrated with telephony services. [ABSTRACT FROM AUTHOR]

The MARTE RFP (Modeling and Analysis of Real-Time and Embedded systems) was issued by the OMG in February 2005. This request for proposals solicits submissions for a UML profile that adds capabilities for modeling Real Time and Embedded Systems (RTES), and for analyzing schedulability and performance properties of UML specifications. One of the particular request of this RFP concerns the definition of common high-level modeling constructs for factorizing repetitive structures, for software, hardware and allocation modeling of RTES. We propose an answer to this particular requirement, based on the introduction of multi-dimensional multiplicities and mechanisms for the description of regular connection patterns between model elements. This proposition is domain independent. We illustrate the use of these mechanisms in an intensive computation embedded system co-design methodology. We focus on what these factorization mechanisms can bring for each of the aspects of the co-design: application, hardware architecture, and allocation. [ABSTRACT FROM AUTHOR]

The Unified Modeling Language (UML) is the accepted standard for object-oriented modeling across the software design industry. Version 2.0 of the UML represents a major new revision to this standard and includes many changes to the current industry state of the practice (UML 1.4). These revisions include the removal or renaming of some existing features as well as the addition of several new capabilities. As tool vendors and software engineers begin to adopt UML 2.0, there is a potential to greatly impact legacy systems and practitioners employing UML 1.4. This report aims at providing an understanding of the changes made in UML 2.0 and their potential impacts, both positive and negative, to the UML 1.4 modeling community. [ABSTRACT FROM AUTHOR]

Scenario based notations are becoming more and more popular as means for user requirements elicitation. They can be used in more formal specifications as part of detailed use case templates or in agile processes to capture informal user stories. Despite their significance in software engineering, scenarios seem not to be properly supported by appropriate tools. This paper describes a scenario construction tool that offers clear separation of the actual story from notions used therein. The tool is constructed as an extension to visual notation of UML's use cases. It is based on an extended UML metamodel in the area of activities and classifiers. This formal basis makes the tool capable of supplying the existing UML tools with an additional layer of requirements models based on scenarios and notions. This layer makes it possible to transform requirements directly into design-level models. The tool offers such transformation capabilities based on a simple model mapping. This transformation supports human efforts to keep the system's design consistent with the user's needs expressed through scenarios. [ABSTRACT FROM AUTHOR]

As model-driven development techniques grow in importance so do the capabilities and features of the tools that support them, especially tools that allow users to customize their modeling language. Superficially, many modeling tools seem to offer similar functionality, but under the surface there are important differences that can have an impact on tool builders and users depending on the tool architecture chosen. At present, however, there is no established conceptual framework for characterizing and comparing different tool architectures. In this paper we address this problem by first introducing a conceptual framework for capturing tool architectures, and then — using this framework — discuss the choices available to designers of tools. We then compare and contrast the main canonical architectures in use today. [ABSTRACT FROM AUTHOR]

In this paper we describe a framework for robust system maintenance that addresses specific challenges of data-centric applications. We show that for data-centric applications, classical simultaneous roundtrip engineering approaches are not sufficient. Instead we propose an architecture that is an integrated model-based approach for software development, database access and data migration. We explain the canonical development process to exploit its features. We explain how the approach fits into the model-driven architecture vision. We report on experiences with the approach in the IMIS environmental mass database project. [ABSTRACT FROM AUTHOR]

The main drive for Model-Driven Architecture is that many software applications have to be deployed on a variety of platforms. The way MDA achieves this is by transforming a platform-independent model of the software to a platform-specific model, given a platform model. In current MDA approaches, the model transformations implicitly represent this platform model. Therefore, the number of different target platforms is limited to the number of supported model transformations. We propose a separate platform model, based on description logics, that can can be used to automatically select and configure a number of reusable model transformations for a concrete platform. This platform model can be extended to describe the relevant platform information, including concrete platform instances as well as platform constraints for each model transformation. This separates the model transformation concern from the platform concern and, since the model transformations are no longer limited to targeting one platform, more platforms can be supported with the same set of transformations. [ABSTRACT FROM AUTHOR]

Scalability is one of the crucial nonfunctional requirements that must be evaluated in the Inception Phase of the Rational Unified Process [9]. This is the phase in which the least information is generally available to form a principled evaluation. We demonstrate how an estimate of user scalability can be formed using sequence diagrams of the common user scenarios, together with experimentation (ranging from simple timing measurements to more complex architectural prototypes), published study data, and performance data from baseline systems. Despite being quite inexpensive, the techniques used by our team enabled us to identify and guide corrective actions for major bottlenecks before they became serious design flaws in the Elaboration and Construction phases of the Unified Process. The same techniques also allowed us to quickly evaluate the effects of high-level architecture and technology alternatives on user scalability and response time. [ABSTRACT FROM AUTHOR]

Evaluating the implications of an architecture design early in the software development lifecycle is important in order to reduce costs of development. Reliability is an important concern with regard to the correct delivery of software system service. Recently, the UML Profile for Modeling Quality of Service has defined a set of UML extensions to represent dependability concerns (including reliability) and other non-functional requirements in early stages of the software development lifecycle. Our research has shown that these extensions are not comprehensive enough to support reliability analysis for model-driven software engineering, because the description of reliability characteristics in this profile lacks support for certain dynamic aspects that are essential in modeling reliability. In this work, we define a profile for reliability analysis by extending the UML 2.0 specification to support reliability prediction based on scenario specifications. A UML model specified using the profile is translated to a labelled transition system (LTS), which is used for automated reliability prediction and identification of implied scenarios; the results of this analysis are then fed back to the UML model. The result is a comprehensive framework for addressing software reliability modeling, including analysis and evolution of reliability predictions. We exemplify our approach using the Boiler System used in previous work and demonstrate how reliability analysis results can be integrated into UML models. [ABSTRACT FROM AUTHOR]

Automated analysis of object-oriented design models can provide insight into the quality of a given software design. Data obtained from automated analysis, however, is often too complex to be easily understood by a designer. This paper examines the use of an automated analysis tool on industrial software UML class models, where one set of models was created as part of the design process and the other was obtained from reverse engineering code. The analysis was performed by DesignAdvisor, a tool developed by Siemens Corporate Research, that supports metrics-based analysis and detection of design guideline violations. The paper describes the lessons learned from using the automated analysis techniques to assess the quality of these models. We also assess the impact of design pattern use in the overall quality of the models. Based on our lessons learned, identify design guidelines that would minimize the occurrence of these errors. [ABSTRACT FROM AUTHOR]

With the advent of Model Driven Architecture, OCL constraints are no longer necessarily written by humans. They can be part of models that emerge from a chain of transformations. They might be the result of instantiating templates, of combining prefabricated parts, or of more general computation. Such generated specifications will often contain redundancies that reduce their readability. In this paper, we explore the possibilities of transforming OCL formulae to a simpler form through the repeated application of simple rules. We discuss the different kinds of rules that are needed, and we describe a prototypical implementation of the approach. [ABSTRACT FROM AUTHOR]

In Model Integrated Computing, it is desirable to evaluate different design alternatives as they relate to issues of scalability. A typical approach to address scalability is to create a base model that captures the key interactions of various components (i.e., the essential properties and connections among modeling entities). A collection of base models can be adorned with necessary information to characterize their replication. In current practice, replication is accomplished by scaling the base model manually. This is a time-consuming process that represents a source of error, especially when there are deep interactions between model components. As an alternative to the manual process, this paper presents the idea of a replicator, which is a model transformation that expands the number of elements from the base model and makes the correct connections among the generated modeling elements. The paper motivates the need for replicators through case studies taken from models supporting different domains. [ABSTRACT FROM AUTHOR]

Refactoring of UML class diagrams is an emerging research topic and heavily inspired by refactoring of program code written in object-oriented implementation languages. Current class diagram refactoring techniques concentrate on the diagrammatic part but neglect OCL constraints that might become syntactically incorrect by changing the underlying class diagram. This paper formalizes the most important refactoring rules for class diagrams and classifies them with respect to their impact on annotated OCL constraints. For refactoring rules, whose application on class diagrams could make attached OCL constraints incorrect, we formally describe how the OCL constraints have to be refactored to preserve their syntactical correctness. Our refactoring rules are defined in the graph-grammar based formalism proposed by the QVT Merge Group for the specification of model transformations. [ABSTRACT FROM AUTHOR]

Nowadays, object-oriented meta-languages such as MOF (Meta-Object Facility) are increasingly used to specify domain-specific languages in the model-driven engineering community. However, these meta-languages focus on structural specifications and have no built-in support for specifications of operational semantics. In this paper we explore the idea of using aspect-oriented modeling to add precise action specifications with static type checking and genericity at the meta level, and examine related issues and possible solutions. We believe that such a combination would bring significant benefits to the community, such as the specification, simulation and testing of operational semantics of metamodels. We present requirements for such statically-typed meta-languages and rationales for the aforementioned benefits. [ABSTRACT FROM AUTHOR]

Model Transformation is a crucial part of Model-Driven Architecture (MDA). However, most of the current researches only focus on the transformation from PIM to PSM, and pay little attention to the CIM-to-PIM transformation. One of the results is that converting CIM to PIM will depend much on designers' personal experience or creativity, and thus the quality of PIM can not be well controlled. This paper presents a feature-oriented component-based approach to the CIM-to-PIM transformation. In this approach, features and components are adopted as the key elements of CIM and PIM, respectively. One important characteristic of this approach is that it provides a method to decompose the n-to-n relations between features and components into two groups of 1-to-n relations. The other important characteristic is that this approach proposes a way to create components by clustering responsibilities which are operationalized from features. These two characteristics partially resolve two basic problems related to the CIM-to-PIM transformation: one is the traceability problem between CIM and PIM, the other is the problem of CIM-based PIM construction. [ABSTRACT FROM AUTHOR]

This paper proposes an extension of the UML 2.0 profiling mechanism. This extension facilitates a language designer to introduce composite concepts as separate conceptual and notational elements in a modelling language. Composite concepts are compositions of existing concepts. To facilitate the introduction of composite concepts, the notion of stereotype is extended. This extension defines how a composite concept can be specified and added to a language's metamodel, without modifying the existing metamodel. From the definition of the stereotype, rules can be derived for transforming a language element that represents a composite concept into a composition of language elements that represent the concepts that constitute the composite. Such a transformation facilitates tool developers to introduce tool support for composite concepts, e.g., by re-using existing tools that support the constituent concepts. To illustrate our ideas, example definitions of stereotypes and transformations for composite concepts are presented. [ABSTRACT FROM AUTHOR]

Complex real-time system design needs to address dependability requirements, such as safety, reliability, and security. We introduce a modelling and simulation based approach which allows for the analysis and prediction of dependability constraints. Dependability can be improved by making use of fault tolerance techniques. The de-facto example in the real-time system literature of a pump control system in a mining environment is used to demonstrate our model-based approach. In particular, the system is modelled using the Discrete EVent system Specification (DEVS) formalism, and then extended to incorporate fault tolerance mechanisms. The modularity of the DEVS formalism facilitates this extension. The simulation demonstrates that the employed fault tolerance techniques are effective. That is, the system performs satisfactorily despite the presence of faults. This approach also makes it possible to make an informed choice between different fault tolerance techniques. Performance metrics are used to measure the reliability and safety of the system, and to evaluate the dependability achieved by the design. In our model-based development process, modelling, simulation and eventual deployment of the system are seamlessly integrated. [ABSTRACT FROM AUTHOR]

Stereotypes in object-oriented software development can be perceived in various ways and they can be used for various purposes. As a consequence of these variations, assessing quality of stereotypes needs to be purpose-specific. In this paper we identify eight types of stereotypes and provide a set of criteria for assessing quality of stereotypes. The criteria for each type are formed by a set of properties that characterizes its stereotypes. The identified types are based on the purpose of each stereotype (its role in designs) and its expressiveness. We identified the types of stereotypes and their properties in an empirical way by investigating stereotypes from UML profiles used in industrial software development. The properties are intended to be used in our further research for developing guidelines for creating and using stereotypes in a more efficient way. [ABSTRACT FROM AUTHOR]

Design patterns embody proven solutions to recurring design problems. Ever since the gang of four popularized the concept, researchers have been trying to develop methods for representing design patterns, and applying them to modeling problems. To the best of our knowledge, none of the approaches proposed so far represents the design problem that the pattern is meant to solve, explicitly. An explicit representation of the problem has several advantages, including 1) a better characterization of the problem space addressed by the pattern—better than the textual description embodied in pattern documentation templates, 2) a more natural representation of the transformations embodied in the application of the pattern, and 3) a better handle on the automatic detection and application of patterns. In this paper, we describe the principles underlying our approach, and the current implementation in the Eclipse Modeling FrameworkTM. [ABSTRACT FROM AUTHOR]