Abstract. In Software Engineering many text-based languages and supporting tools are used, forming the grammarware technical space. Currently model driven engineering is the new emerging paradigm for software engineering, which uses modelling languages and tools, forming the modelware technical space. Transition to the new technical space and interoperability between these two technical spaces is needed in many development scenarios. Building a bridge between these two technical spaces is a tedious task, that has to be repeated for each language to be transformed. Therefore, we propose a generic bridge between grammarware and modelware technical spaces, that can generate a specific bridge based on the EBNF of a given language semi-automatically. The generation comprises of two steps, (1) automatic generation of metamodel corresponding to the EBNF and (2) annotations to provide the additional semantics not captured by the EBNF. The generated bridge is capable of bi-directional transformations between sentences (programs)

Model Driven Engineering is a promizing approach that could lead to the emergence of a new paradigm for software evolution, namely Model Driven Software Evolution. Models, Metamodels and Transformations are the cornerstones of this approach. Combining these concepts leads to very complex structures which revealed to be very di#cult to understand especially when di#erent technological spaces are considered such as XMLWare (the technology based on XML), Grammarware and BNF, Modelware and UML, Dataware and SQL, etc. The concepts of model, metamodel and transformation are usually ill-defined in industrial standards like the MDA or XML. This paper provides a conceptual framework, called a megamodel, that aims at modelling large-scale software evolution processes. Such processes are modeled as graphs of systems linked with well-defined set of relations such as RepresentationOf (), ConformsTo (#) and IsTransformedIn (# ).

Abstract. Model Driven Engineering (MDE) received a lot of attention in the last years, both from academia and industry. However, there is still a debate on which basic concepts form the foundation of MDE. The Model Driven Architecture (MDA) from the OMG does not provided clear answers to this question. This standard instead provides a complex set of interdependent technologies. This paper is the first of a series aiming at defining the foundations of MDE independently from a particular technology. A megamodel is introduced in this paper and incrementally refined in further papers from the series. This paper is devoted to a single concept, the concept of model, and to a single relation, the RepresentationOf relation. The lack of strong foundations for the MDA ’ 4-layers meta-pyramid leads to a common mockery: "So, MDA is just about Egyptology?!". This paper is the pilot of the series called "From Ancient Egypt to Model Driven Engineering". The various episodes of this series show that Egyptology is actually a good model to study MDE. 1

We discuss the nuts and bolts of industrial large-scale software modification projects. These projects become necessary when system owners of deployed systems hit architectural barriers. The mastery of such projects is key to the extension of the best-before date of businesscritical software assets. Our discussion comprises the process for problem analysis, pricing and contracting for such projects, design and implementation of tools for code exploration and code modification, as well as details of service delivery. We illustrate these concerns by way of a real-world example where a deployed management information system required an invasive modification to make the system fit for future use. The chosen project is particularly suited for a complete treatise because of its size (just 90,000 LOC), and the nature of the relevant architectural modification (namely, a form of data expansion). We share the lessons that we learned in this and other architectural modification projects.

these concepts related? It is striking to see that, though MDE is supposed to be about precise modelling, MDE core concepts are usually described in natural language or at best, using sketchy "à-la " UML diagrams. These diagrams are very often inconsistent and too vague to reason about. Most of the time, they are neither validated, not even used by their authors. When precise descriptions are provided, it is only to describe a

A common trend in programming language specification is to generate various tools (e.g., compiler, editor, profiler, and debugger) from a grammar. In such a generative approach, it is desirable to have the definition of a programming language be modularized according to specific concerns specified in the grammar. However, it is often the case that the corresponding properties of the generated tools are scattered and tangled across the language specification. In this paper, separation of concerns within a programming language specification is demonstrated by considering debugging support within a domain-specific language (DSL). The paper first describes the use of AspectJ to weave the debugging semantics into the code created by a parser generator. The paper outlines several situations when the use of AspectJ is infeasible at separating language specification properties. To accommodate such situations, a second approach is presented that weaves the debugging support directly into a grammar specification using a program transformation engine. A case study for a simple DSL is presented to highlight the benefits of weaving across language specifications defined by grammars.

The trend towards domain-specific languages leads to an ever-growing plethora of highly specialized languages. Developers of such languages focus on their specific domains rather than on technical challenges of language design. Generic features of languages are rarely included in special-purpose languages. One very important feature is modularization, the ability to formulate partial programs in separate entities, composable into a complete program in a defined manner. This paper presents a generic approach for adding modularity to arbitrary languages, discussing the underlying concepts and presenting the Reuseware Composition Framework. We walk through an example based on Xcerpt, a Semantic Web query language. 1

Recovering the architecture of large evolving software is challenging. The first problem to be solved is to define what "software architecture" means in the company, and which architectural viewpoints are required by each stakeholder. In order to solve this problem, this paper provides a metamodel-driven implementation of the View Set Scenario. This paper shows how metamodels help in defining architectural viewpoints and how metamodels can be use to drive architecture recovery processes. The concepts presented in this paper were identified over the last decade in the context of a tight collaboration with Dassault Systmes, one of the largest software companies in Europe. The process pattern identified is however general and can be applied in other contexts. This process fits in the MDA and ADM approaches from the OMG. It also complies with the IEEE Standard 1471 for software architecture.

Domain specific languages (DSLs) are increasingly used today. Coping with complex language definitions, evolving them in a structured way, and ensuring their error freeness are the main challenges of DSL design and implementation. The use of modular language definitions and composition operators are therefore inevitable in the independent development of language components. In this article, we discuss these arising issues by describing a framework for the compositional development of textual DSLs and their supporting tools. We use a redundance-free definition of a readable concrete syntax and a comprehensible abstract syntax as both representations significantly overlap in their structure. For enhancing the usability of the abstract syntax, we added concepts like associations and inheritance to a grammarbased definition in order to build up arbitrary graphs (as known from metamodeling). Two modularity concepts, grammar inheritance and embedding, are discussed. They permit compositional language definition and thus simplify the extension of languages based on already existing ones. We demonstrate that compositional engineering of new languages is a useful concept when project-individual DSLs with appropriate tool support are defined.

Model-based software development promises to increase productivity by offering modeling languages tailored to a problem domain. Such modeling languages are often defined by a metamodel. In consequence of changing requirements and technological progress, these modeling languages and thus their metamodels are subject to change. Manually migrating models to a new version of their metamodel is tedious, error-prone and heavily hampers cost-efficient model-based development practice. Automating model migration in response to metamodel adaptation promises to substantially reduce effort. Unfortunately, little is known about the types of changes occurring during metamodel adaptation in practice and, consequently, to which degree reconciling model migration can be automated. We analyzed the changes that occurred during the evolution history of two industrial metamodels and classified them according to their level of potential automation. Based on the results, we present a list of requirements for effective tool support for coupled evolution of metamodels and models in practice.