Bran Selic

The pragmatics of model-driven development

The potential benefits of using models are significantly greater in software than in other engineering disciplines because of the potential for a seamless link between models and the systems they represent. Unfortunately, models have rarely produced anticipated benefits. The key lies in resolving pragmatic issues related to the artifacts and culture of the previous generation of software technologies.

Using UML for Modeling Complex Real-Time Systems

Real-time software systems encountered in telecommunications, aerospace, and defense often tend to be very large and extremely complex. It is crucial in such systems that the software has a well-defined architecture. This not only facilitates construction of the initial system, it also simplifies system evolution. We describe a set of modeling constructs that facilitate the specification of complex software architectures for real-time systems. These constructs are derived from field-proven concepts originally defined in the ROOM modeling language. Furthermore, we show how they can be represented using the industry-standard Unified Modeling Language (UML) by using the powerful extensibility mechanisms of UML.

Unified Modeling Language (UML)

The Unified Modeling Language is a language used for analysis and design of software-based systems. This is an entry for the Software Engineering Encyclopedia that gives an overview of UML. Keywords: software modeling; modeling languages; UML; unified modeling language; model-driven development; MDD; model driven architecture; MDA

A Systematic Approach to Domain-Specific Language Design Using UML

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

A survey of fault tolerance mechanisms and checkpoint/restart implementations for high performance computing systems

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.

A generic framework for modeling resources with UML

Current wisdom encourages designers to first focus on the logical aspects of their problem and then defer platform and technology issues until the concluding phases of development. This behavior is reasonable, considering that devising logically sound solutions is frequently the most difficult aspect of development. Unfortunately-and this has been understated to date-there are many situations in which this approach is inappropriate. Real-time software design is one domain where this situation is particularly obvious because the domains requirements force software to interact with the physical world in some way. Recently, a generic object oriented framework has been proposed for modeling both physical and logical resources. Although the framework is generic, it is mainly used with the industry-standard Unified Modeling Language (UML). By providing a standard means for representing resources and their attributes, it becomes possible to seamlessly transfer UML models of real-time systems between design and specialized analysis tools. The author shows how developers can use the OMGs UML to model resources and thus predict crucial system properties before fully implementing a system.

Challenges in Combining SysML and MARTE for Model-Based Design of Embedded Systems

Using model-based approaches for designing embedded systems helps abstract away unnecessary details in a manner that increases the potential for easy validation and verification, and facilitates reuse and evolution. A common practice is to use UML as the base language, possibly specialized by the so-called profiles. Despite the ever increasing number of profiles being built in many domains, there is still insufficient focus on discussing the issue of combining multiple profiles. Indeed, a single profile may not be adequate to cover all aspects required in the multidisciplinary domain of embedded systems. In this paper, we assess possible strategies for combining the SysML and MARTE profiles in a common modelling framework, while avoiding specification conflicts. We show that, despite some semantic and syntactical overlapping, the two are highly complementary for specifying embedded systems at different abstraction levels. We conclude, however, that a convergence agenda is highly desirable to align some key language features.

Turning clockwise: using UML in the real-time domain

We must not be misled, however, into thinkingthat achieving timeliness is the sole source of com-plexity in real-time software. All real-time systemsultimately involve interaction with the physicalworld. This world, as the apocryphal Murphy sug-gests, can seem to conspire against us: events willoften occur at the wrong time or in the wrong order.The ultimate and inevitable source of complexity inreal-time software, therefore, is the physical worlditself. The sad fact is that no matter how hard we tryand no matter which technology we use this funda-mental complexity cannot be eliminated.Compounding this is our persistent demand forever-greater functionality. This is fueled in part bycompetitive business pressures but also by the naturalhuman propensity for increasingly sophisticatedmachinery. In telephony, for example, there are closeto 500 different types of “features” defined. These arespecialized services, such as call forwarding, voicemail, or mobile phone roaming, that we now take forgranted. Unfortunately, many of these features weredefined independently of each other and are oftenmutually incompatible. In spite of that, we expect thesoftware inside a communication system to provideall of these various features and somehow to resolvethe inconsistencies between them.

What will it take? A view on adoption of model-based methods in practice

Model-based engineering (MBE) has been touted as a new and substantively different approach to software development, characterized by higher levels of abstraction and automation compared to traditional methods. Despite the availability of published verifiable evidence that it can significantly boost both developer productivity and product quality in industrial projects, adoption of this approach has been surprisingly slow. In this article, we review the causes behind this, both technical and non-technical, and outline what needs to happen for MBE to become a reliable mainstream approach to software development.

Modeling and analysis of real-time and embedded systems

This paper presents an overview of the workshop MARTES on Modeling and Analysis of Real-time and Embedded Systems that has taken place for the first time in association with the MODELS/UML 2005 conference. The main themes discussed at this workshop concerned (1) methodologies and tools for quantitative analysis and (2) methodologies and languages for modeling quantitative aspects of real-time and embedded systems in the context of model driven development.