On model typing

In this position statement, I argue that modeling languages that aspire to be used in a model-driven development context must fulfill more requirements than traditional notations that have been primarily used for solution sketching. I enumerate some of these requirements, evaluate to what extent they are addressed by the UML, and suggest how the UML could be enhanced in order to become a modeling language that adequately supports model-driven development.

Software & Systems Modeling, 2013

Models are the core assets in model-driven engineering, and are therefore subject to all kind of manipulations, such as refactorings, animations, transformations into other languages, comparisons and merging. This set of model-related activities is known as model management. Even though many languages and approaches have been proposed for model management, most of them are type-centric, specific to concrete meta-models, and hence leading to specifications with a low level of abstraction and difficult to be reused in practice. In this paper, we introduce ideas from generic programming into model management to raise the level of abstraction of the specifications of model manipulations and facilitate their reuse. In particular we adopt generic meta-model concepts as an intermediate, abstract meta-model over which model management specifications are defined. Such meta-model concepts are mapped to concrete meta-models, so that specifications can be applied to families of meta-models satisfying the concept requirements. As a proof of concept, we show the implementation of these ideas using the Eclipse Modeling Framework and the Epsilon family of languages for model management.

2017

The various meta-modelling tools in existence today all have differences in their conformance relations, either intentional or accidental. This results in incompatibilities between tools, where a model cannot simply be exchanged as-is: the meta-meta-model and semantics likely differ. Current tools are inflexible in this regard, making their models grafted on the tool implementation. In this paper, we distinguish between syntactical and semantical differences between tools, both resulting in nonexchangable models. We propose to explicitly model the metameta-model (addressing syntactical differences) and its semantics (addressing semantical differences). This allows meta-metamodels and semantics to be added and manipulated at runtime, making our approach flexible for new tools as well. Models and languages from different tools can then be meaningfully stored in a single tool, retaining syntax and semantics. We provide a prototype implementation: the Modelverse.

1996

Object-oriented programming languages oopl's provide important support for today's large-scale software development projects. Unfortunately, the typing issues arising from the object-oriented features that provide this support are substantially di erent from those that arise in typing procedural languages. Attempts to adapt procedural type systems to object-oriented languages have resulted in languages like Simula, C++, and Object Pascal, which h a v e o v erly restrictive t ype systems. Among other things, the rigidity of these systems frequently force programmers to use type casts, which are a notorious source of hard-to-nd bugs. These restrictive type systems also mean that many programming idioms common to untyped oopl's such as Smalltalk are not typeable. One source of this lack of exibility is the con ation of subtyping and inheritance. Brie y, inheritance is an implementation technique in which new object de nitions may be given as incremental modi cations to existing de nitions. Subtyping concerns substitutivity: when can one object safely replace another? By tying subtyping to inheritance, existing oopl's greatly reduce the number of legal substitutions in a system, and hence their degree of polymorphism. Attempts to x this rigidity h a v e resulted in unsound type systems, most notably Ei el's.

Model-driven software development employs models to describe different aspects of a system on different levels of abstraction. These aspects are driven by technology or application domain. Modeling is often done in specific graphical or textual notations, called domain-specific languages (DSL). In recent years such languages became very popular in the modeling community to describe structure and sometimes behavior. In the context of type systems, these structures are called types and the behavior is modeled with expressions. The programming language community has developed many concepts to model and specify type systems and the semantics of expressions. However, in the modeling community this is often neglected when specifying meta models and describing their semantics, what may cause problems in developing checks and generators for DSLs. To address this issue, we present an approach, that provides guidance and support during DSL development based on established knowledge on type systems and generator construction, to ease the integration of type systems in DSL. We evaluate this approach with the Xtext language engineering framework.

2005

Model-driven approaches to software development require precise definitions and tool support for modeling languages, their syntax and semantics, their notions of consistency and refinement, as well as their mappings to the implementation level. In order to support model-driven development in a variety of contexts, we must find efficient ways of designing languages, accepting that definitions are evolving and that tools need to be delivered in a timely fashion. In this respect, language definitions are not unlike software.

2002

Abstract A discontinuity exists between modeling languages and object-oriented programming languages. This discontinuity is a consequence of ambiguous notions in modeling languages and lack of corresponding notions in objectoriented programming languages. It hinders the transition between a software design and its implementation, and vice versa. Thus, it hampers the implementation and the maintenance processes.

Doctoral Symposium at Models 2015

Software reuse is an important key in developing software systems in a short time with low cost and fewer errors. Traits were introduced to provide fine-grained reusable elements so as to avoid the issues of various forms of inheritance. In spite of being powerful, traits are not used much in software development, mostly because of neither being available in general purpose programming languages nor at the modeling level. In addition, traits suffer from not having control over their clients, which result in a lack of reusability and incorrect usage respectively. In this paper, we propose applying traits to model driven software development. Traits are extended with modeling elements such as associations, state machines, and constraints for a higher level of abstraction. In addition, template parameters are integrated with associations in order to increase genericity and level of abstraction. Traits will be extended with required interfaces to enable structural control over their clients. These features will be implemented in Umple which provides textual modeling of software systems.

Lecture Notes in Computer Science, 2009

Many modeling languages share some common concepts and principles. For example, Java, MOF, and UML share some aspects of the concepts of classes, methods, attributes, and inheritance. However, model transformations such as refactorings specified for a given language cannot be readily reused for another language because their related metamodels may be structurally different. Our aim is to enable a flexible reuse of model transformations across various metamodels. Thus, in this paper, we present an approach allowing the specification of generic model transformations, in particular refactorings, so that they can be applied to different metamodels. Our approach relies on two mechanisms: (1) an adaptation based mainly on the weaving of aspects; (2) the notion of model typing, an extension of object typing in the model-oriented context. We validated our approach by performing some experiments that consisted of specifying three well known refactorings (Encapsulate Field, Move Method, and Pull Up Method) and applying each of them onto three different metamodels (Java, MOF, and UML).

2004

Nowadays, companies involved in the development of modern software face several difficulties. One of the most important ones is the continuous evolution of software platforms (C++, Java, DotNet, CORBA, EJB, Web services, XML, etc.). One interesting solution to this problem is the Model-Driven Architecture (MDA) approach from the OMG. It suggests that domain-specific knowledges should be encapsulated in platformindependent business models, apart from the applications. Beyond this answer is the failure of classical development techniques that rely on object-oriented design and programming. According to these remarks, we address another way to develop software: Model-Oriented Programming. It is based on the Domain-Driven Development track and introduces a macro-level on top of the classical programming entities. It intends to be used for the handling, reuse and evolution of the business know-how and its associated applications. This paper attempts to define a set of golden rules for setting up the framework of model-oriented programming and ensuring the success of its use. It gives also an overview of the implementation of those rules that we propose in our approach called SmartModels.