Showing papers in "Software and Systems Modeling in 2009"

From model transformation to incremental bidirectional model synchronization

Abstract: The model-driven software development paradigm requires that appropriate model transformations are applicable in different stages of the development process The transformations have to consistently propagate changes between the different involved models and thus ensure a proper model synchronization However, most approaches today do not fully support the requirements for model synchronization and focus only on classical one-way batch-oriented transformations In this paper, we present our approach for an incremental model transformation which supports model synchronization Our approach employs the visual, formal, and bidirectional transformation technique of triple graph grammars Using this declarative specification formalism, we focus on the efficient execution of the transformation rules and how to achieve an incremental model transformation for synchronization purposes We present an evaluation of our approach and demonstrate that due to the speedup for the incremental processing in the average case even larger models can be tackled

Questionnaire-based variability modeling for system configuration

Abstract: Variability management is a recurrent issue in systems engineering. It arises for example in enterprise systems, where modules are configured and composed to meet the requirements of individual customers based on modifications to a reference model. It also manifests itself in the context of software product families, where variants of a system are built from a common code base. This paper proposes an approach to capture system variability based on questionnaire models that include order dependencies and domain constraints. The paper presents analysis techniques to detect circular dependencies and contradictory constraints in questionnaire models, as well as techniques to incrementally prevent invalid configurations by restricting the space of allowed answers to a question based on previous answers. The approach has been implemented as a toolset and has been used in practice to capture configurable process models for film post-production.

Towards the efficient development of model transformations using model weaving and matching transformations

Abstract: Model transformations can be used in many different application scenarios, for instance, to provide interoperability between models of different size and complexity. As a consequence, they are becoming more and more complex. However, model transformations are typically developed manually. Several code patterns are implemented repetitively, thus increasing the probability of programming errors and reducing code reusability. There is not yet a complete solution that automates the development of model transformations. In this paper, we present a novel approach that uses matching transformations and weaving models to semi-automate the development of transformations. Weaving models are models that contain different kinds of relationships between model elements. These relationships capture different transformation patterns. Matching transformations are a special kind of transformations that implement methods that create weaving models. We present a practical solution that enables the creation and the customization of different creation methods in an efficient way. We combine different methods, and present a metamodel-based method that exploits metamodel data to automatically produce weaving models. The weaving models are derived into model integration transformations. To validate our approach, we present an experiment using metamodels with distinct size and complexity, which show the feasibility and scalability of our solution.

Qualifying input test data for model transformations

Abstract: Model transformation is a core mechanism for model-driven engineering (MDE). Writing complex model transformations is error-prone, and efficient testing techniques are required as for any complex program development. Testing a model transformation is typically performed by checking the results of the transformation applied to a set of input models. While it is fairly easy to provide some input models, it is difficult to qualify the relevance of these models for testing. In this paper, we propose a set of rules and a framework to assess the quality of given input models for testing a given transformation. Furthermore, the framework identifies missing model elements in input models and assists the user in improving these models.

XTraQue: traceability for product line systems

Abstract: Product line engineering has been increasingly used to support the development and deployment of software systems that share a common set of features and are developed based on the reuse of core assets. The large number and heterogeneity of documents generated during the development of product line systems may cause difficulties to identify common and variable aspects among applications, and to reuse core assets that are available under the product line. In this paper, we present a traceability approach for product line systems. Traceability has been recognised as an important task in software system development. Traceability relations can improve the quality of the product being developed and reduce development time and cost. We present a rule-based approach to support automatic generation of traceability relations between feature-based object-oriented documents. We define a traceability reference model with nine different types of traceability relations for eight types of documents. The traceability rules used in our work are classified into two groups namely (a) direct rules, which support the creation of traceability relations that do not depend on the existence of other relations, and (b) indirect rules, which require the existence of previously generated relations. The documents are represented in XML and the rules are represented in an extension of XQuery. A prototype tool called XTraQue has been implemented. This tool, together with a mobile phone product line case study, has been used to demonstrate and evaluate our work in various experiments. The results of these experiments are encouraging and comparable with other approaches that support automatic generation of traceability relations.

Generating instance models from meta models

Abstract: Meta modeling is a wide-spread technique to define visual languages, with the UML being the most prominent one. Despite several advantages of meta modeling such as ease of use, the meta modeling approach has one disadvantage: it is not constructive, i.e., it does not offer a direct means of generating instances of the language. This disadvantage poses a severe limitation for certain applications. For example, when developing model transformations, it is desirable to have enough valid instance models available for large-scale testing. Producing such a large set by hand is tedious. In the related problem of compiler testing, a string grammar together with a simple generation algorithm is typically used to produce words of the language automatically. In this paper, we introduce instance-generating graph grammars for creating instances of meta models, thereby overcoming the main deficit of the meta modeling approach for defining languages.

Model transformation by example using inductive logic programming

Abstract: Model transformation by example is a novel approach in model-driven software engineering to derive model transformation rules from an initial prototypical set of interrelated source and target models, which describe critical cases of the model transformation problem in a purely declarative way. In the current paper, we automate this approach using inductive logic programming (Muggleton and Raedt in J Logic Program 19-20:629–679, 1994) which aims at the inductive construction of first-order clausal theories from examples and background knowledge.

Formalizing the structural semantics of domain-specific modeling languages

Abstract: Model-based approaches to system design are now widespread and successful. These approaches make extensive use of model structure to describe systems using domain-specific abstractions, to specify and implement model transformations, and to analyze structural properties of models. In spite of its general importance the structural semantics of modeling languages are not well-understood. In this paper we develop the formal foundations for the structural semantics of domain-specific modeling languages (DSML), including the mechanisms by which metamodels specify the structural semantics of DSMLs. Additionally, we show how our formalization can complement existing tools, and how it yields algorithms for the analysis of DSMLs and model transformations.

Nivel: a metamodelling language with a formal semantics

Abstract: Much work has been done to clarify the notion of metamodelling and new ideas, such as strict metamodelling, distinction between ontological and linguistic instantiation, unified modelling elements and deep instantiation, have been introduced. However, many of these ideas have not yet been fully developed and integrated into modelling languages with (concrete) syntax, rigorous semantics and tool support. Consequently, applying these ideas in practice and reasoning about their meaning is difficult, if not impossible. In this paper, we strive to add semantic rigour and conceptual clarity to metamodelling through the introduction of Nivel, a novel metamodelling language capable of expressing models spanning an arbitrary number of levels. Nivel is based on a core set of conceptual modelling concepts: class, generalisation, instantiation, attribute, value and association. Nivel adheres to a form of strict metamodelling and supports deep instantiation of classes, associations and attributes. A formal semantics is given for Nivel by translation to weight constraint rule language (WCRL), which enables decidable, automated reasoning about Nivel. The modelling facilities of Nivel and the utility of the formalisation are demonstrated in a case study on feature modelling.

Meta-environment and executable meta-language using smalltalk: an experience report

Abstract: Object-oriented modelling languages such as EMOF are often used to specify domain specific meta-models. However, these modelling languages lack the ability to describe behavior or operational semantics. Several approaches have used a subset of Java mixed with OCL as executable meta-languages. In this experience report we show how we use Smalltalk as an executable meta-language in the context of the Moose reengineering environment. We present how we implemented EMOF and its behavioral aspects. Over the last decade we validated this approach through incrementally building a meta-described reengineering environment. Such an approach bridges the gap between a code-oriented view and a meta-model driven one. It avoids the creation of yet another language and reuses the infrastructure and run-time of the underlying implementation language. It offers an uniform way of letting developers focus on their tasks while at the same time allowing them to meta-describe their domain model. The advantage of our approach is that developers use the same tools and environment they use for their regular tasks. Still the approach is not Smalltalk specific but can be applied to language offering an introspective API such as Ruby, Python, CLOS, Java and C#.

Modularization of model transformations through a phasing mechanism

Abstract: In recent years a great effort has been devoted to understanding the nature of model transformations. As a result, several mechanisms to improve model transformation languages have been proposed. Phasing has been mentioned in some works as a rule scheduling or organization mechanism, but without any detail. In this paper, we present a phasing mechanism in the context of rule-based transformation languages. We explain the structure and the behavior of the mechanism, and how it can be integrated in a language. We also analyze how the mechanism promotes modularity, internal transformation composition and helps to solve usual transformation problems. Besides, we show several examples of application to illustrate the usefulness of the mechanism.

A UML and OWL description of Bunge’s upper-level ontology model

Abstract: A prominent high-level ontology is that proposed by Mario Bunge. While it has been extensively used for research in IS analysis and conceptual modelling, it has not been employed in the more formal settings of semantic web research. We claim that its specification in natural language is the key inhibitor to its wider use. Consequently, this paper offers a description of this ontology in open, standardized knowledge representation formats. The ontology is described both in UML and OWL in order to address needs of both semantic web and conceptual modelling communities.

Information science and the logic of models

Abstract: ion is a fundamental human capacity that permits us to deal with complexity . . . We build models of complex systems because we cannot comprehend such systems in their entirety. There are limits to human capacity to understand complexity . . .Models help us organize, visualize, understand 34 The view of entity as ,something of interest’ is not consistent with established ontology, according to which entities are something which does not necessarily depend on the presence of a conceiving subject. However, in the model of conception on which the model of modelbeing presented here is based, this dependence of entities on a conceiving subject is absolutely necessary (cf. also footnote 33).

Supporting domain-specific model patterns with metamodeling

Abstract: Metamodeling is a widely applied technique in the field of graphical languages to create highly configurable modeling environments. These environments support the rapid development of domain-specific modeling languages (DSMLs). Design patterns are efficient solutions for recurring problems. With the proliferation of DSMLs, there is a need for domain-specific design patterns to offer solutions to problems recurring in different domains. The aim of this paper is to provide theoretical and practical foundations to support domain-specific model patterns in metamodeling environments. In order to support the treatment of premature model parts, we weaken the instantiation relationship. We provide constructs relaxing the instantiation rules, and we show that these constructs are appropriate and sufficient to express patterns. We provide the necessary modifications in metamodeling tools for supporting patterns. With the contributed results, a well-founded domain-specific model pattern support can be realized in metamodeling tools.

Towards an integrated graph-based semantics for UML

Abstract: This paper shows how a central part of the Unified Modeling Language (UML) can be integrated into a single visual semantic model. It discusses UML models composed of class, object, state, sequence and collaboration diagrams and presents an integrated semantics of these models. As formal basis the theoretically well-founded area of graph transformation is employed which supports a visual and rule-based transformation of UML model states. For the translation of a UML model into a graph transformation system the operations in class diagrams and the transitions in state diagrams are associated with graph transformation rules that are then combined into one system in order to obtain a single coherent semantic description. Operation calls in sequence and collaboration diagrams can be associated with applications of graph transformation rules in the constructed graph transformation system so that valid sequence and collaboration diagrams correspond to derivations, i.e., to sequences of graph transformation rule applications. The main aim of this paper is to provide a formal framework that supports visual simulation of integrated UML specifications in which system states and state changes are modeled in a straightforward way.

Object-oriented design: A goal-driven and pattern-based approach

Abstract: In recent years, the influences of design patterns on software quality have attracted increasing attention in the area of software engineering, as design patterns encapsulate valuable knowledge to resolve design problems, and more importantly to improve the design quality. One of the key challenges in object-oriented design is how to apply appropriate design patterns during the system development. In this paper, design pattern is analyzed from different perspectives to see how it can facilitate design activities, handle non-functional requirement, solve design problems and resolve design conflicts. Based on the analysis, various kinds of applicability of design patterns are explored and integrated with a goal-driven approach to guiding developers to construct the object-oriented design model in a systematic manner. There are three benefits to the proposed approach: making it easy to meet requirements, helping resolve design conflicts, and facilitating improvement of the design quality.

Model-based design: a report from the trenches of the DARPA Urban Challenge

Abstract: The impact of model-based design on the software engineering community is impressive, and recent research in model transformations, and elegant behavioral specifications of systems has the potential to revolutionize the way in which systems are designed. Such techniques aim to raise the level of abstraction at which systems are specified, to remove the burden of producing application-specific programs with general-purpose programming. For complex real-time systems, however, the impact of model-driven approaches is not nearly so widespread. In this paper, we present a perspective of model-based design researchers who joined with software experts in robotics to enter the DARPA Urban Challenge, and to what extent model-based design techniques were used. Further, we speculate on why, according to our experience and the testimonies of many teams, the full promises of model-based design were not widely realized for the competition. Finally, we present some thoughts for the future of model-based design in complex systems such as these, and what advancements in modeling are needed to motivate small-scale projects to use model-based design in these domains.

A compositional semantics of UML-RSDS

Abstract: This paper provides a semantics for the UML-RSDS (Reactive System Development Support) subset of UML, using the real-time action logic (RAL) formalism. We show how this semantics can be used to resolve some ambiguities and omissions in UML semantics, and to support reasoning about specifications using the B formal method and tools. We use ‘semantic profiles’ to provide precise semantics for different semantic variation points of UML. We also show how RAL can be used to give a semantics to notations for real-time specification in UML. Unlike other approaches to UML semantics, which concentrate on the class diagram notation, our semantic representation has behaviour as a central element, and can be used to define semantics for use cases, state machines and interactions, in addition to class diagrams.

Redesign of UML class diagrams: a formal approach

Abstract: Contracts provide a precise way of specifying object-oriented systems. When a class structure is modified, the corresponding contracts must be modified accordingly. This paper presents a method of transforming contracts, which allows the extension of a mapping defined on a few model elements, to—what we call—an interpretation function, and to use this function to automatically translate OCL-constraints. Interestingly, such functions preserve reasoning using propositional calculi, resolution, equations, and induction. Interpretation functions can be used to trace model elements throughout multiple redesigns of UML class diagrams in both the forward, and the backward direction. The applicability of our approach is demonstrated in several examples, including some of Fowler’s refactoring patterns.

A UML-based quantitative framework for early prediction of resource usage and load in distributed real-time systems

Abstract: This paper presents a quantitative framework for early prediction of resource usage and load in distributed real-time systems (DRTS). The prediction is based on an analysis of UML 2.0 sequence diagrams, augmented with timing information, to extract timed-control flow information. It is aimed at improving the early predictability of a DRTS by offering a systematic approach to predict, at the design phase, system behavior in each time instant during its execution. Since behavioral models such as sequence diagrams are available in early design phases of the software life cycle, the framework enables resource analysis at a stage when design decisions are still easy to change. Though we provide a general framework, we use network traffic as an example resource type to illustrate how the approach is applied. We also indicate how usage and load analysis of other types of resources (e.g., CPU and memory) can be performed in a similar fashion. A case study illustrates the feasibility of the approach.

Use Case Maps as a property specification language

Abstract: Although a significant body of research in the area of formal verification and model checking tools of software and hardware systems exists, the acceptance of these tools by industry and end-users is rather limited. Beside the technical problem of state space explosion, one of the main reasons for this limited acceptance is the unfamiliarity of users with the required specification notation. Requirements have to be typically expressed as temporal logic formalisms and notations. Property specification patterns were successfully introduced to bridge this gap between users and model checking tools. They also enable non-experts to write formal specifications that can be used for automatic model checking. In this paper, we propose an abstract high level pattern-based approach to the description of property specifications based on Use Case Maps (UCM). We present a set of commonly used properties with their specifications that are described in terms of occurrence, ordering and temporal scopes of actions. Furthermore, our approach also supports the description of properties with respect to their architectural scope. We provide a mapping of our UCM property specification patterns in terms of CTL, TCTL and Architectural TCTL (ArTCTL), an extension to TCTL, introduced in this research that provides temporal logics with architectural scopes. We illustrate the use of our pattern system for requirement specifications of an IP Header compression feature.

A reconfiguration pattern for distributed embedded systems

Abstract: A reconfiguration pattern for UML-based projects of embedded (real-time) systems is defined It enables to set up hardware/software configurations, and to specify conditions and methods for dynamic reconfiguration The reconfiguration pattern was inspired by the reconfiguration management solution of the Specification PEARL methodology, which is based on the standard for Multiprocessor PEARL whose original idea it was to extend the language to enable the programming of distributed real-time applications in PEARL In Specification PEARL, the possibility for abstract descriptions of hardware and software architectures and for defining mappings from software to hardware components has been enhanced in correspondence with the standard Here, a UML pattern for reconfiguration management in distributed embedded applications based on concepts from Specification PEARL is presented Its behavioural, structural and functional aspects are outlined It addresses stereotype entities from the Specification PEARL language, which were joined in a UML profile, and outlines the related reconfiguration management mechanisms, which were carried over to the mentioned UML pattern The proposed reconfiguration pattern is to facilitate the development of distributed embedded application in UML with consistent and temporally predictable reconfiguration support It should also support and enhance the applications’ flexibility and portability

A systematic approach to generate B preconditions: application to the database domain

Abstract: Maintaining integrity constraints in information systems is a real issue. In our previous work, we have defined a formal approach that derives B formal specifications from a UML description of the system. Basically, the generated B specification is composed of a set of variables modeling data and a set of operations representing transactions. The integrity constraints are directly specified as B invariant properties. So far, the operations we generate establish only a reduced class of constraints. In this paper, we describe a systematic approach to identify preconditions that take a larger class of invariants into account. The key idea is the definition of rewriting and simplification rules that we apply to the B invariants.

Adherence preserving refinement of trace-set properties in STAIRS: exemplified for information flow properties and policies

Abstract: STAIRS is a formal approach to system development with UML 2.1 sequence diagrams that supports an incremental and modular development process. STAIRS is underpinned by denotational and operational semantics that have been proved to be equivalent. STAIRS is more expressive than most approaches with a formal notion of refinement. STAIRS supports a stepwise refinement process under which trace properties as well as trace-set properties are preserved. This paper demonstrates the potential of STAIRS in this respect, in particular that refinement in STAIRS preserves adherence to information flow properties as well as policies.

Editorial to the theme issue on metamodelling

Abstract: Linguistics, Mathematics, and Computer Science are inherently reflective disciplines. Linguists use language to talk about language. Mathematicians use mathematical methods to study mathematics itself, and Computer Scientists describe descriptions in order to facilitate automation. For instance, one of the most important concepts in computer science, the universal Turing machine, can be regarded as a program that executes other programs. All the above examples of self-application are variations of a common “meta” theme. All of them require care in avoiding paradoxes which may be caused by uncontrolled selfreference. Linguists are faced with associating semantics to sentences like “This statement is false.” This self-referencing sentence is commonly referred to as “The Liar” and its semantics refuses assignment into “true” and “false” categories. Linguists, therefore, strictly distinguish between “metalanguage” and “object-language” to avoid the paradoxical nature of such antinomies. Mathematicians had to abandon naïve set theory because of Russell’s set paradox, which is nothing else but a mathematical version of the aforementioned “Liar”. Computer scientists have to deal with both the blessing and curse of self-referencing programs and descriptions. On the one hand, we can use this power to build interpreters which may even be parametrised with a language definition, on the other hand we have to deal with nonterminating programs and potentially inconsistent circular definitions.

Metamodeling live sequence charts for code generation

Abstract: This article presents a metamodeling study for Live Sequence Charts (LSCs) and Message Sequence Charts (MSCs) with an emphasis on code generation. The article discusses specifically the following points: the approach to building a metamodel for MSCs and LSCs, a metamodel extension from MSC to LSC, support for model-based code generation, and finally action model and domain-specific data model integration. The metamodel is formulated in metaGME, the metamodel language for the Generic Modeling Environment.

Generating relational database transactions from eb3 attribute definitions

Abstract: eb3 is a trace-based formal language created for the specification of information systems. In eb3, each entity and association attribute is independently defined by a recursive function on the valid traces of external events. This paper describes an algorithm that generates, for each external event, a transaction that updates the value of affected attributes in their relational database representation. The benefits are twofold: eb3 attribute specifications are automatically translated into executable programs, eliminating system design and implementation steps; the construction of information systems is streamlined, because eb3 specifications are simpler and shorter to write than corresponding traditional specifications, design and implementations. In particular, the paper shows that simple eb3 constructs can replace complex SQL queries which are typically difficult to write.

Reusing semi-specified behavior models in systems analysis and design

Abstract: As the structural and behavioral complexity of systems has increased, so has interest in reusing modules in early development phases. Developing reusable modules and then weaving them into specific systems has been addressed by many approaches, including plug-and-play software component technologies, aspect-oriented techniques, design patterns, superimposition, and product line techniques. Most of these ideas are expressed in an object-oriented framework, so they reuse behaviors after dividing them into methods that are owned by classes. In this paper, we present a crosscutting reuse approach that applies object-process methodology (OPM). OPM, which unifies system structure and behavior in a single view, supports the notion of a process class that does not belong to and is not encapsulated in an object class, but rather stands alone, capable of getting input objects and producing output objects. The approach features the ability to specify modules generically and concretize them in the target application. This is done in a three-step process: designing generic and target modules, weaving them into the system under development, and refining the combined specification in a way that enables the individual modules to be modified after their reuse. Rules for specifying and combining modules are defined and exemplified, showing the flexibility and benefits of this approach.

Guest editorial to the special section on model transformation

Abstract: Models have become essential for dealing with the numerous aspects involved in developing and maintaining complex IT systems. Models assist in capturing the relevant aspects of a system from a given perspective and at a precise level of abstraction. Model transformation represents a key activity in model-driven engineering by supporting the definition and implementation of the operations on models, which can provide a chain that enables the automated development of a system from its correspondingmodels. Furthermore, amodel transformation may also be considered a model in its own right, which presents opportunities for higher-order transformations, i.e., transformations that manipulate models representing other model transformations. There exist several approaches that support model transformation specification, implementation, and execution, which are beginning to be used by model engineers, endusers, and practitioners. However, model transformations need specialized support in several areas in order to realize their full potential. The challenges go beyond the need to have specific languages to represent model transformations; it is also necessary to understand foundational principles, such as the key concepts and operators supporting model transformation languages, their semantics, and their structuring

SoSyM at 7 years

Abstract: Over its 7 years in circulation, SoSyM, the International Journal on Software and Systems Modeling, has received a reputation for publishing quality research and experience papers on building and using models in the development of software-based systems. During that time, we have witnessed a growing body of experience related to the use of modeling techniques in practice. The insights gained have led to the development of better solutions, but, more importantly, they have led to (1) a deeper understanding of some of the more critical problems that practitioners face when applying current modeling technologies, and (2) a broader vision of model-driven engineering (MDE) that encompasses not only development, but also software operation. Papers published in SoSyM, and in a number of related conferences and workshops that have contributed to special SoSyM issues, have made significant contributions to this growing body of experience and research on modeling software-based systems. Given the growing maturity of SoSyM, we decided to seek inclusion in the Thomson ISI Science Citation Index. We are happy to tell you that SoSyMhas been part of this index since 2007.Our inclusion in the ScienceCitation Index allows us to better track the impact that SoSyM has on themodeling community and will further increase the number of high quality papers that we will see in the future. As we have done on previous anniversaries, we take this opportunity to give a “state of the journal” report and to acknowledge the reviewers, editors, and publication staff that