Several research efforts from different areas have focused on the execution of UML models, resulting in a diverse and complex scientific body of knowledge. With this work, we aim at identifying, classifying, and evaluating existing solutions for the execution of UML models. We conducted a systematic review in which we selected 63 research studies and 19 tools among over 5400 entries by applying a systematic search and selection process. We defined a classification framework for characterizing solutions for UML model execution, and we applied it to the 82 selected entries. Finally, we analyzed and discussed the obtained data. From the analyzed data, we drew the following conclusions: (i) There is a growing scientific interest on UML model execution; (ii) solutions providing translational execution clearly outnumber interpretive solutions; (iii) model-level debugging is supported in very few cases; (iv) only a few research studies provide evidence of industrial use, with very limited empirical evaluations; (v) the most common limitation deals with coverage of the UML language. Based on these observations, we discuss potential research challenges and implications for the future of UML model execution. Our results provide a concise overview of states of the art and practice for UML model execution intended for use by both researchers and practitioners.

In order to achieve effective support for software development, the transition between an informal and provisional mode of tool operation, which is conducive to design exploration, and a formal mechanistic mode required for computer-based design capture is crucial. This contribution proposes a smooth transition for designing class models starting from informal, sketchy object models. We propose a lenient development approach and discuss the possibilities and problems of a transformation from object diagrams to class diagrams. While classes describe abstract concepts, objects are representations of what can be seen in the real world, so it might be easier to start modeling with objects instead of classes. An object diagram can however not describe a whole system, it is only used as the first step of an iterative process to create a complete model. During this process, our object and class diagrams provide a notation for highlighting missing or conflicting parts. Based on these imperfect object diagrams, educated guesses can be made for resulting, imperfect class diagrams, which can then be refined to a complete, formal description of the modeled system.

Complex software systems often suffer from flaws arising either during the design or the development stages. In many cases due to the lack of formal underpinning it is difficult to assuredly define the model from which the system is generated. In our work, we investigated the suitability of mathematical situation theory as a formal foundation for a computer modelling language. This paper describes our empirical evaluation of this thesis in the real-time domain using Infon Lab, a tool based upon situation theory.

Cyber-Physical Systems (CPSs) are the future generation of highly connected embedded systems having applications in diverse domains including Oil and Gas. Employing Product Line Engineering (PLE) is believed to bring potential benefits with respect to reduced cost, higher productivity, higher quality, and faster time-to-market. However, relatively few industrial field studies are reported regarding the application of PLE to develop large-scale systems, and more specifically CPSs. In this paper, we report about our experiences and insights gained from investigating the application of model-based PLE at a large international organization developing subsea production systems (typical CPSs) to manage the exploitation of oil and gas production fields. We report in this paper 1) how two systematic domain analyses (on requirements engineering and product configuration/derivation) were conducted to elicit CPS PLE requirements and challenges, 2) key results of the domain analysis (commonly observed in other domains), and 3) our initial experience of developing and applying two Model Based System Engineering (MBSE) PLE solution to address some of the requirements and challenges elicited during the domain analyses.

In recent years, High Performance Computing (HPC) systems have been shifting from expensive massively parallel architectures to clusters of commodity PCs to take advantage of cost and performance benefits. Fault tolerance in such systems is a growing concern for long-running applications. In this paper, we briefly review the failure rates of HPC systems and also survey the fault tolerance approaches for HPC systems and issues with these approaches. Rollback-recovery techniques which are most often used for long-running applications on HPC clusters are discussed because they are widely used for long-running applications on HPC systems. Specifically, the feature requirements of rollback-recovery are discussed and a taxonomy is developed for over twenty popular checkpoint/restart solutions. The intent of this paper is to aid researchers in the domain as well as to facilitate development of new checkpointing solutions.

Cloud computing offers new capacity and flexibility solution to high performance computing (HPC) applications with provisioning of a large number of virtual machines for computational intensive applications. Fault tolerance allows HPC systems on cloud with multiple of nodes to complete execution of computational intensive applications in the present of fault. The most commonly used fault tolerance techniques for HPC is checkpoint/restart. However, checkpoint/restart increases the wall clock time of the execution of applications which increases the execution cost. In this paper we present a fault tolerance framework for high performance computing in Cloud. This framework proposes using process level redundancy (PLR) techniques to reduce the wall clock time of the execution of computational intensive applications.

One pillar of Model-Driven Development for real-time embedded software is the separation of concerns between application model and target platform. This requires definition of model transformations realizing the mapping of the application model onto the target platform. Real-Time and Embedded Systems design means coping with different target platforms and with heterogeneous constraints related to time, synchronization and memory footprint. However, different target platforms have APIs and implementation patterns that vary significantly so that it is necessary to develop several dedicated model transformations in order to achieve portability between them. Although this is one way to achieve portability, we show in this paper that the cost of portability can be reduced by providing domain-independent model transformations while still ensuring performance requirements are satisfied.

In recent years, High Performance Computing (HPC) systems have been shifting from expensive massively parallel custom architectures to clusters of commodity personal computers to take advantage of cost and performance benefits. To avoid having to restart an application in case of sudden failure, checkpointing/restart fault tolerance mechanisms are commonly implemented. One drawback to checkpointing/restart is that it creates an overhead which increases the execution time of an application. We present a theoretical analysis of our technique. The results show that the PLR checkpointing/restart can significantly improve the overall reliability of an HPC system.

Summary form only given. Abstraction is the very essence of architectural specification and modeling. Consequently, as we develop a proper theoretical underpinning for model-based engineering methods, it is crucial for us to understand more precisely what is involved in moving from a concrete specification of some system to a more abstract one (or vice versa). Well-known abstraction patterns, such as layering, encapsulation, hierarchical (de)composition, and the like are quite common and have been used since the earliest days of software design. However, they are typically specified informally using ambiguous inconclusive language, which can lead to confusion and misunderstandings that are difficult to detect. For example, hierarchical decomposition and layering, which are semantically distinct patterns, are often confused with each other due to their syntactical similarity. In this talk, we identify a starter set of common and reversible abstraction patterns - that is, patterns that relate a concrete representation with a corresponding abstract one - giving precise formal descriptions of the mappings involved in each. This serves not only to clarify what actually happens in the process of abstraction but, perhaps even more importantly, it can serve as a basis for automating some of the mechanical aspects involved in moving between models at different levels of abstraction. This, in turn, enables computer-based traceability between such models. Moreover, such a precise specification of these transformations can mitigate one of the major hazards of abstraction whereby highly relevant information is erroneously dropped from consideration.

This short panel position paper outlines the vision of modern development methods and supporting technologies for the development of modern and future real-time and embedded software applications. It is argued that these should be based on so-called model-based software engineering techniques and service-oriented principles.

With society's increasing dependence on software, the issue of software quality is becoming more prominent. The term quality of service (QoS) has been used in conjunction with software to cover a broad range of characteristics, such as dependability, responsiveness, security, etc. Historically, the technical challenge of achieving a desired QoS in conditions of limited resources (e.g., finite computing power, memory capacity, communication bandwidth) was primarily relegated to the specialized domain of real-time and embedded software systems, that is, systems involved in continuous and timely interaction with the physical world. The "mainstream7" view and dominant software design philosophy are still based on the flawed premise that software should be developed without any considerations given to the characteristics and limitations of the hardware and software platforms that give it life. The important and useful principle of platform independence is being tragically misinterpreted as implying platform ignorance.

Summary form only given. The adoption of model-driven methods for software development is rapidly gaining momentum, stimulated greatly by the emergence of new modeling language standards and corresponding tools. The ability of models to highlight the important aspects of a system while abstracting away the irrelevant bits provides a very effective means of coping with the often overwhelming complexity of modern software systems. However, model-driven development (MDD) is still deemed inappropriate for real-time and embedded software by many practitioners even though the complexity of their systems often exceeds that encountered in other domains.

The limited processing power and memory capacities of early computing technologies often forced designers of real-time and embedded software to devise relatively sophisticated and complex architectural and programming patterns. The primary motivation, of course, was to eke out as much capability as the underlying implementation technologies could provide. Unfortunately, this tended to add complexity to the software, often making it very difficult to evolve, maintain, or port to different (e.g., more advanced) technologies. One of the primary sources of complexity in such systems is the intricate interleaving of application-specific concerns with implementation concerns that prevents easy distinction of one from the other.

UML includes special extensibility mechanisms, which are used to define domain-specific modeling languages that are based on UML. These mechanisms have been significantly improved in the latest versions of UML. Unfortunately, there is currently a dearth of published material on how to best exploit these capabilities and, consequently, many UML profiles are either invalid or of poor quality. In this paper, we first provide an overview of the new extensibility mechanisms of UML 2.1 and then describe a method for defining profiles that greatly increases the likelihood of producing technically correct quality UML profiles

Automation is the most successful technological means for achieving dramatic improvements in both productivity and quality. The displacement of manual manufacturing methods by automated processes is at the core of the Industrial Revolution and accounts for much of what we usually refer to progress over the past several centuries. The introduction of computers and computer software more than a half century ago create unprecedented opportunities in this regard: they can not only help us automate the physical processes involved in production but also many of the highly mechanistic and error-prone mental processes involved in design. The opportunity provided by software and computers in this regard is without precedent. Yet, when one reviews the history of computer-based automation in the process of software design, we find that, following the invention of compilers almost fifty years ago, the use of computer-based automation has made little difference in the lives and methods of the vast majority of software developers. This is not due to lack of opportunity - software is an eminently flexible medium limited mostly by imagination - but mostly due to often unrecognized social and cultural factors. In this talk, we first examine the history of the use of computer-based automation in software development and speculate on the reasons why the software development community has spurned the opportunities that it offers. Next, we identify the scope of opportunities offered by current computer-based technology and what could be done to exploit this potential to its fullest.

This half-day tutorial covers the salient features of the first major revision of the Unified Modeling Language - UML 2. This short note summarizes the major topics covered by the tutorial.

This paper gives a short overview of model-driven development - an approach to software development in which high-level models play a fundamental role. First, the problems that plague current programming approaches are analyzed. This is followed by a short description of the essential features of model-driven development and the potential benefits that it can bring. The results achieved in industrial practice are reviewed briefly, followed by an analysis of current impediments towards greater levels of adoption of this approach and what needs to be done about to overcome them

Provides an abstract of the keynote presentation and a brief professional biography of the presenter. The complete presentation was not made available for publication as part of the conference proceedings.

This paper defines a precise conceptual model of a software platform and the relationship that exists between platforms and software applications that use them. One of the key features of this model is that it allows formal verification of deployment specifications. The paper also describes how the proposed conceptual model can be represented directly using some of the new modeling features of the industry-standard UML 2.0 language. Finally, we briefly describe how this model can be used to support platform-independent design while still accounting for the potentially fundamental impact that platform characteristics can have on key design decisions.

This paper covers the salient aspects of the first major revision of the Unified Modeling Language - UML 2.0. In this brief summary, we briefly review some of the main points covered in the paper.

Real-time systems are among the most complex software systems to design and construct. This short position paper outlines some of the most pressing research problems that need to be addressed. They are all related to the concept of "temporal cost" of design choices and the ability to easily and directly track those costs during design

This half-day tutorial covers the salient aspects of the first major revision of the Unified Modeling Language, UML 2.0. It includes background information on what drove the requirements and the design rationale-from the point of view of one of its primary designers. The overall structure of UML 2.0 is described followed by a more detailed description of the most prominent new modeling features illustrated with many examples. The ability of UML 2.0 to deal with the needs of model-driven development methods is also covered.

The term "model-driven development" denotes an approach to software design and development characterized by the creation of software models as the focus and primary artifacts of development rather than programs. In this brief note, the essentials of model-driven development are explained first, followed by a discussion of how this approach is supported in the realtime and embedded system domains by two key OMG standards. A short overview of these standards is also included.

This paper describes briefly the objectives, content, and usage of a real-time UML profile that has been standardized by the Object Management Group. This profile defines a common framework for describing the quantitative aspects of software systems. In addition, it provides specific facilities for analysing real-time systems for schedulability or performance.

The presence of a solid architectural vision is a key discriminator in the success or failure of a software project. This tutorial examines what software architecture is and what it is not. It discusses and illustrates how to describe architecture through a set of design viewpoints and views and how to express these views in the UML, in the spirit of the new IEEE Standard 1471:2000:Recommended practice for architectural description. The tutorial shows of how architectures drive the development process and how to capture architectural design patterns using the UML. It is illustrated by several widely applicable architectural patterns in different domain.

The presence of a solid architectural vision is a key discriminator in the success or failure of a software project. This tutorial examines what software architecture is and what it is not. It discusses and illustrates how to describe architecture through a set of design viewpoints and views and how to express these views in UML (Rumbaugh et al., 1998), in the spirit of the new IEEE Standard: Recommended practice for architectural description. The tutorial shows of how architectures drive the development process and how to capture architectural design patterns using UML (Unified Modeling Language). It is illustrated by several widely applicable architectural patterns in different domains.

One of the most crucial and complicated phases of real-time system development lies in the transition from system behavior (generally specified using scenario models) to the behavior of interacting components (typically captured by means of communicating hierarchical finite state machines). It is commonly accepted that a systematic approach is required for this transition. We overview such an approach, which we root in a hierarchy of "behavior integration patterns" we have elaborated. The proposed patterns guide the structuring of a component's behavior and help in integrating the behavior associated with new scenarios into the existing hierarchical finite state machine of a component. One of these patterns is discussed at length.

We introduce the concept of protocols. A protocol is a formal specification of potentially complex reusable pattern of inter-object behavior. To make it reusable, a protocol is defined independently of any specific object classes or instances. Even though they are defined independently of individual classes, we demonstrate how, using the notion of two-way interfaces called ports, protocols can be formally bound to structures of collaborating objects. This gives us a framework in which it is possible to formally verify if a particular combination of objects can indeed achieve the desired inter-object behavior. A further advantage is that programs with protocol specifications are more understandable and more maintainable than traditional object oriented programs since the required high level behavior is explicit. We describe both protocols and ports using the base concepts of the recent Unified Modeling Language (UML) standard.

One of the primary features of almost all physically distributed software is that it has to deal with the unpredictable nature and complexity of the physical world. For example, it has to detect failures and undertake recovery procedures, it may have to reconfigure itself dynamically, and so on. In effect, all such distributed systems are de facto real time systems. As more and more software systems become distributed, the issue of architecture becomes more critical. A good architecture minimizes complexity and increases the likelihood of run time controllability. It is also key to its ability to undergo evolutionary change. Consequently, the ability to model complex layered architectures in a formal and clear way is also important. The structural modeling concepts originally defined in the ROOM (real time object oriented modeling) language provide an excellent base for this purpose.

Most development and system specification languages do not provide facilities for a formal and complete declaration of the expected hardware and software environment for which a system is targeted. This type of information can be used to determine whether a software specification is compatible with a particular computing environment. In this paper we describe an approach, based on a generic "quality of service" framework, that provides such a facility for a broad category of object-oriented architectural definition languages. A formal model of this facility is also provided, including rules for determining compatibility between different computing environments.

The Northern Telecom SL-10 Packet Switching System is steadily enhanced to provide better access services for users. Equally important to them, but less visible, are enhancements to improve availability and increase throughput. To this end, intelligent peripheral devices, such as storage controllers and line servers, have been added to the Switch and new strategies, especially for software loading, have been devised. Such additions have had an impact on the software architecture. The Resource Subsystem now has to cope with a wider variety of devices, including intelligent peripheral devices. The File Subsystem has been generalized to accommodate files on different types of volumes, e.g., disks and tape cartridges. A whole new Subsystem has evolved to handle strategies for loading processors in parallel and to load intelligent peripherals. The SL-10 Packet Switch software architecture, with its process environment structured in Subsystems, has proven well suited to these requirements.