Jürgen Dingel

Understanding and improving UML package merge

Package merge allows the content of one package to be combined with that of another package. Package merge is used extensively in the UML 2 specification to modularize the definition of the UML 2 meta model and to define the four compliance levels of UML 2. Package merge is a novel construct in UML and currently not well understood. This paper summarizes our work to understand and improve package merge. First, we identify ambiguous and missing rules in the package merge definition and suggest corrections. Then, we formalize package merge and analyze it with respect to some desirable properties. Our analyses employs Alloy, a first-order modelling language with tool support, and concepts from mathematical logic which allow us to develop a general taxonomy of package extension mechanisms. The analyses reveal the unexpected failure of important properties.

Towards a model transformation intent catalog

We report on our ongoing effort to build a catalog of model transformation intents that describes common uses of model transformations in Model-Driven Engineering (MDE) and the properties they must or may possess. We present a preliminary list of intents and common properties. One intent (transformation for analysis) is described in more detail and the description is used to identify transformations with the same intent in a case study on the use of MDE techniques for the development of control software for a power window.

A Refinement Calculus for Shared-Variable Parallel and Distributed Programming

Abstract. Parallel computers have not yet had the expected impact on mainstream computing. Parallelism adds a level of complexity to the programming task that makes it very error-prone. Moreover, a large variety of very different parallel architectures exists. Porting an implementation from one machine to another may require substantial changes. This paper addresses some of these problems by developing a formal basis for the design of parallel programs in the form of a refinement calculus. The calculus allows the stepwise formal derivation of an abstract, low-level implementation from a trusted, high-level specification. The calculus thus helps structuring and documenting the development process. Portability is increased, because the introduction of a machine-dependent feature can be located in the refinement tree. Development efforts above this point in the tree are independent of that feature and are thus reusable. Moreover, the discovery of new, possibly more efficient solutions is facilitated. Last but not least, programs are correct by construction, which obviates the need for difficult debugging. Our programming/specification notation supports fair parallelism, shared-variable and message-passing concurrency, local variables and channels. The calculus rests on a compositional trace semantics that treats shared-variable and message-passing concurrency uniformly. The refinement relation combines a context-sensitive notion of trace inclusion and assumption-commitment reasoning to achieve compositionality. The calculus straddles both concurrency paradigms, that is, a shared-variable program can be refined into a distributed, message-passing program and vice versa.

Engineering Associations: From Models to Code and Back through Semantics

Association between classes is a central construct in OO modeling. However, precise semantics of associations has not been defined, and only the most basic types are implemented in modern forward and reverse engineering tools. In this paper, we present a novel mathematical framework and build a precise semantics for several association constructs, whose implementation has been considered problematic. We also identify a number of patterns for using associations in practical applications, which cannot be modeled (reverse engineered) in UML.

A Survey of Using Model-Based Testing to Improve Quality Attributes in Distributed Systems

This paper provides a detailed survey of how Model- Based Testing (MBT) has been used for testing different quality attributes of distributed systems such as security, performance, reliability, and correctness. For this purpose, three additional criteria are added to the classification. These criteria are: the purpose of testing, the test case paradigm, and the type of conformance checking. A comparison between different MBT tools based on the classification is also given.

Bridging the gap: Discrete-Event Systems for software engineering (short position paper)

Discrete-Event System Theory (DES) allows the automatic control of a system with respect to a specification describing desirable sequences of events. It offers a large body of work with strong theoretical results and tool support. In this paper, we advocate the application of DES to software engineering problems. We summarize preliminary results and provide a list of directions for future research.

A Customizable Execution Engine for Models of Embedded Systems

In the Model Driven Development MDD paradigm analysis of models is important. We propose an approach to the analysis which uses a customizable execution engine. Such customization can improve scalability and provide more support for variations of semantics. We exemplify these benefits with several customizations of semantics that are abstractions. They are applied to models of embedded systems implemented in the UML-RT language. The goal of abstractions is to replace original semantics with semantics that generates smaller state spaces. Different execution semantics of UML-RT models are provided terms of operational semantics style execution rules. We describe the design of the toolset called Toolset for UML-RT Execution, illustrate execution rules with examples, and present the results of preliminary evaluation.

Using Fuzzy Logic and Symbolic Execution to Prioritize UML-RT Test Cases

The relative ease of test case generation associated with model-based testing can lead to an increased number of test cases being identified for any given system; this is problematic as it is becoming near impossible to run (or even generate) all of the possible tests in available time frames. Test case prioritization is a method of ranking the tests in order of importance, or priority based on criteria specific to a domain or implementation, and selecting some subset of tests to generate and run. Some approaches require the generation of all tests, and simply prioritize the ones to be run, however we propose an approach that would prevent unnecessary generation of tests through the use of symbolic execution trees to determine which tests provide the most benefit to coverage of execution. Our approach makes use of fuzzy logic, specifically fuzzy control systems, to prioritize test cases generated from these execution; the prioritization is based on natural language rules about testing priority. Within this paper we present our motivation, some background research, our methodology and implementation, results, and conclusions.

Towards a Unified Development Methodology for Shared-Variable Parallel and Distributed Programs

A formal framework for the design of distributed, message-passing programs from shared-variable parallel programs is presented. Based on a uniform semantic model for both paradigms and a trace-based refinement calculus, we show how a shared-variable parallel program can be refined into a distributed program. The calculus is used to introduce iteration, parallelism, and local channels, to replace access to shared variables by message-passing primitives, and to update the channels such that processes find the expected information on the expected channels at the right time. The methodology is illustrated with the development of a distributed implementation of an all-pair, shortest-paths algorithm.