José Eduardo Rivera

Formal and Tool Support for Model Driven Engineering with Maude

Models and metamodels play a cornerstone role in Model-Driven Software Development. Although several notations have been proposed to specify them, the kind of formal and tool support they provide is quite limited. In this paper we explore the use of Maude as a formal notation for describing models and metamodels. Maude is an executable rewriting logic language specially well suited for the specification of object-oriented open and distributed systems. We show how Maude oers a simple, natural, and accurate way of specifying models and metamodels, and oers good tool support for reasoning about them. In particular, we show how some basic operations on models, such as model subtyping, type inference, and metric evaluation, can be easily specified and implemented in Maude, and made available in development environments such as Eclipse.

Analyzing Rule-Based Behavioral Semantics of Visual Modeling Languages with Maude

There is a growing need to explicitly represent the behavioral semantics of Modeling Languages in a precise way, something especially important in industrial environments in which simulation and verification are critical issues. Graph transformation provides one way to specify the semantics of Domain Specific Visual Languages (DSVLs), with the advantage of being intuitive and easy to use for the system designer. Even though its theory has been extensively developed during the last 30 years, it has some limitations concerning specific analysis capabilities. On the contrary, Maude is a rewriting logic-based language with very good formal analysis support, but which requires specialized knowledge. In this paper we show how a mapping between graph transformation-based specifications of DSVL semantics and Maude is possible. This allows performing simulation, reachability and model-checking analysis on the models, using the tools and techniques that Maude provides.

Representing and Operating with Model Differences

Models and metamodels play a cornerstone role in Model-Driven Software Development (MDSD). Models conform to metamodels, which usually specify domain-specific languages that allow to represent the various facets of a system in terms of models. This paper discusses the problem of calculating differences between models conforming to arbitrary metamodels, something essential in any MDSD environment for dealing with the management of changes and evolution of software models. We present a metamodel for representing the differences as models, too, following the MDSD “everything is a model” principle. The Difference Metamodel, together with the difference and other related operations (do, undo and composition) presented here have been specified in Maude and integrated in an Eclipse-developed environment.

Formal Specification and Analysis of Domain Specific Models Using Maude

Modeling languages play a cornerstone role in model-driven software development for representing models and metamodels. Modeling languages are usually defined in terms of their abstract and concrete syntax. This allows the rapid development of languages and some associated tools (e.g. editors), but does not allow the representation of their behavioral semantics, something especially important in certain industrial environments in which simulation and verification are critical issues. In this paper we explore the use of Maude as a formal notation for describing models, metamodels, and their dynamic behavior, making models amenable to formal analysis, reasoning, and simulation.

Adding Behavior to Models

Domain Specific Languages (DSLs) play a cornerstone role in Model-Driven Software Development for representing models and metamodels. DSLs are usually defined in terms of their abstract and concrete syntax only. This allows the rapid and inexpensive development of DSLs and their associated tools (e.g., editors), but does not allow the representation of their behavioral semantics, something especially important for model operations like simulation and verification. In this paper we explore the use of Maude as a formal notation for describing models and metamodels, including the specification of their dynamic behavior.

Simulating domain specific visual models by observation

Domain Specific Visual Languages (DSVLs) are essential elements in Model-Driven Engineering (MDE) for representing models and metamodels. In-place model transformations provide an intuitive way to complement metamodels with behavioral specifications. Besides, they can be extended with quantitative models of time and with mechanisms that facilitate the design of real-time complex systems. In this paper we present an approach to simulate and analyze the behavior of systems described by DSVLs using observers, which are objects that can monitor both the state of the rest of the objects of the system, and the execution of the system actions. Our proposal is supported by e-Motions, a graphical framework and tool for defining timed behavioral specifications of models. We also show how this approach enables the specification and simulation of other important features of systems, such as the automatic reconfiguration of the system when the value of some of the observed properties change.

On the specification of non-functional properties of systems by observation

Domain specific languages play a cornerstone role in Model-Driven Engineering (MDE) for representing models and metamodels. So far, most of the MDE community efforts have focused on the specification of the functional properties of systems. However, the correct and complete specification of some of their non-functional properties is critical in many important distributed application domains, such as embedded systems, multimedia applications or e-commerce services. In this paper we present an approach to specify QoS requirements, based on the observation of the system actions and of the state of its objects. We show how this approach can be used to extend languages which specify behavior in terms of rules, and how QoS characteristics can be easily expressed and reused across models. We show as well how this approach enables the specification of other important properties of systems, such as automatic reconfiguration of the system when some of the QoS properties change.

Behavior, Time and Viewpoint Consistency: Three Challenges for MDE

Although Model Driven Software Development (MDSD) is achieving significant progress, it is still far from becoming a real Engineering discipline. In fact, many of the difficult problems of the engineering of complex software systems are still unresolved, or simplistically addressed by many of the current MDSD approaches. In this position paper we outline three of the outstanding problems that we think MDSD should tackle in order to be useful in industrial environments.

Formal Visual Modeling of Real-Time Systems in e-Motions: Two Case Studies

Francisco Dur´an and Vlad Rusu (Eds.):Second International Workshop on Algebraic Methodsin Model-Based Software Engineering 2011 (AMMSE’11)EPTCS 56, 2011, pp. 49–63, doi:10.4204/EPTCS.56.4c F. Duran, P. C.´ Olveczky, and J. E. Rivera¨This work is licensed under theCreative Commons Attribution License.