Christian Glodt

Models within models: taming model complexity using the sub-model lattice

Model-driven software development aims at easing the process of software development by using models as primary artifacts. Although less complex than the real systems they are based on, models tend to be complex nevertheless, thus making the task of comprehending them non-trivial in many cases. In this paper we propose a technique for model comprehension based on decomposing models into sub-models that conform to the same metamodel as the original model. The main contributions of this paper are: a mathematical description of the structure of these sub-models as a lattice, a linear-time algorithm for constructing this decomposition and finally an application of our decomposition technique to model comprehension.

Using VCL as an aspect-oriented approach to requirements modelling

Software systems are becoming larger and more complex. By tackling the modularisation of crosscutting concerns, aspect orientation draws attention to modularity as a means to address the problems of scalability, complexity and evolution in software systems development. Aspect-oriented modelling (AOM) applies aspect-orientation to the construction of models. Most existing AOM approaches are designed without a formal semantics, and use multi-view partial descriptions of behaviour. This paper presents an AOM approach based on the Visual Contract Language (VCL): a visual language for abstract and precise modelling, designed with a formal semantics, and comprising a novel approach to visual behavioural modelling based on design by contract where behavioural descriptions are total. By applying VCL to a large case study of a car-crash crisis management system, the paper demonstrates how modularity of VCLs constructs, at different levels of granularity, help to tackle complexity. In particular, it shows how VCLs package construct and its associated composition mechanisms are key in supporting separation of concerns, coarse-grained problem decomposition and aspect-orientation. The case studys modelling solution has a clear and well-defined modular structure; the backbone of this structure is a collection of packages encapsulating local solutions to concerns.

Building VCL models and automatically generating Z specifications from them

VCL is a visual and formal language for abstract specification of software systems. Its novelty lies in its capacity to describe predicates visually. This paper presents work-in-progress on a tool for VCL; the tool version presented here supports the VCL notations of structural and assertion diagrams (a subset of the whole VCL suite), enabling the generation of Z specifications from them.

A generic model decomposition technique and its application to the Eclipse modeling framework

Model-driven software development aims at easing the process of software development by using models as primary artifacts. Although less complex than the real systems, they are based on models tend to be complex nevertheless, thus making the task of handling them non-trivial in many cases. In this paper, we propose a generic model decomposition technique to facilitate model management by decomposing complex models into smaller sub-models that conform to the same metamodel as the original model. The technique is based upon a formal foundation that consists of a formal capturing of the concepts of models, metamodels, and model conformance; a formal constraint language based on EssentialOCL; and a set of formally proved properties of the technique. We organize the decomposed sub-models in a mathematical structure as a lattice, and design a linear-time algorithm for constructing this decomposition. The generic model decomposition technique is applied to the Eclipse modeling framework, and the result is used to build a solution to a specific model comprehension problem of Ecore models based upon model pruning. We report two case studies of the model comprehension method: one in BPMN and the other in fUML.

Designing languages using lightning

Modelling languages are defined by specifying their abstract syntax, concrete syntax and semantics. In the Lightning tool the definition of all these language components is based on the lightweight formal language Alloy. Lightning makes use of the powerful automatic analysis features of Alloy to allow language designers to develop and validate the definition of a modelling language in an incremental fashion. By providing immediate visual feedback, it allows errors in the language definition to be quickly identified and corrected. Furthermore Lightning introduces F-Alloy, a new Alloy based model transformation language. Transformations expressed in F-Alloy can be efficiently interpreted in Lightning. We illustrate the use of the tool on the language of structured business processes.

A tool for visual and formal modelling of software designs

Diagrams are ubiquitous in software engineering and widely used for software modelling. The visual contract language (VCL) enables an approach to software design modelling that is entirely graphical and has a mathematical basis. VCLs main novelties lie in its capacity to describe predicates visually and in its graphical front-end to formal modelling. VCL is brought to life in the visual contract builder (VCB) tool presented in this paper. VCB provides diagram editors for the whole VCL suite, it type-checks diagrams and generates Z formal specifications from them; the Z specification enables formal verification and validation using Z theorem provers. The paper evaluates VCB based on the results of a survey carried out in the context of a controlled experiment. The work presented here is a contribution to the area of visual design modelling: the paper presents a state of the art tool supporting the novel VCL language and concrete empirical results on the usefulness and effectiveness of tool and language in particular, suggesting benefits of visual modelling in general. The paper presents the Visual Contract Builder (VCB) tool supporting the Visual Contract Language (VCL).VCL is a graphical language for describing software designs formally.VCL and VCB have been applied to several case studies.The paper evaluates VCB based on a survey carried out in the context of a controlled experiment.The paper includes several reflections on strengths and weaknesses of VCB and lessons learnt.

DEMOCLES: a tool for executable modeling of platform-independent systems

The main goal of model-driven architecture is the generation of the full implementation of a systembased on a precise description of a platform-independent model and a platform model. Such a description must accurately specify the static structure as well as the dynamic behavior of the system. We present a tool -- called DEMOCLES -- that realizes a hybrid approach to platform-independent modeling. It describes the static structure using a modified UML class diagram that separates query operations from modifier operations. The former are defined in the class diagram via OCL constraints, while the latter are defined using a MOF-based metamodel that contains modifier operations and properties as first-class entities and augments them with associations and OCL expressions. The tool is an Eclipse-plugin that offers overlay views of the structure and behavior with visual editing capabilities and permits execution of a platform-independent system.

Specifying Executable Platform-Independent Models using OCL

Model-driven architecture aims at describing a system using a platform-independent model in sufficient detail so that the full implementation of the system can be generated from this model and a platform model. This implies that the platform-independent model must describe the static structure as well as the dynamic behavior of the system. We propose a declarative language for describing the behavior of platform-independent models based on a hybrid notation that uses graphical elements as well as textual elements in the form of OCL code snippets. Compared to existing approaches based on action languages it is situated at a higher level of abstraction and, through a clean separation of modifier operations and query operations, simplifies the comprehension of the behavioral aspects of the platform-independent system.

DEMOS: a tool for declarative executable modeling of object-based systems

The recently introduced EP-model citeeptr proposes a declarative executable model for engineering object-based systems which achieves executability through a hybrid approach that annotates model elements with Java code snippets. Current modeling tools are not appropriate for this hybrid approach which requires graphical model editing, code generation and tight IDE integration to provide an effective modeling environment. DEMOS citedemostool is an Eclipse-based tool which supports editing and executing EP models with rule-based background code generation, and which provides immediate feedback on the syntactic validity of both model elements and user-supplied code snippets. The tool, which features an AOM-based architecture that renders it adaptable to different metamodels, enables EP-models to be used as first-class artifacts in the software engineering process.

Platform-Variant Applications from Platform-Independent Models via Templates

By raising the level of abstraction from code to models, model-driven development (MDD) emphasises design rather than implementation and platform-specificity. This paper presents an experiment with a MDD approach, which takes platform-independent models and generates code for various platforms from them. The platform code is generated from templates. Our approach is based on EP, a formal executable modelling language, supplemented with OCL, and FTL, a formal language of templates. The paper?s experiment generates code for the mobile platforms Android and iPhone from the same abstract functional model of a case study. The experiment shows the feasibility of MDD to tackle present day problems, highlighting many benefits of the MDD approach and opportunities for improvement.