3rd international software language engineering conference (SLE) : pre-proceedings, October 12-13, 2010, Eindhoven, the Netherlands

We are pleased to present the proceedings of the Third International Conference on Software Language Engineering (SLE 2010). The conference will be held in Eindhoven, the Netherlands during October 12-13, 2010 and will be co-located with The Ninth International Conference on Generative Programming and Component Engineering (GPCE'10), and The Workshop on Feature-Oriented Software Development (FOSD). An important goal of SLE is to integrate the different sub-communities of the software-language-engineering community to foster cross-fertilization and strengthen research overall. The Doctoral Symposium at SLE 2010 contributes towards these goals by providing a forum for both early and late-stage PhD students to present their research and get detailed feedback and advice from other researchers. The SLE conference series is devoted to a wide range of topics related to artificial languages in software engineering. SLE is an international research forum that brings together researchers and practitioners from both industry and academia to expand the frontiers of software language engineering. SLE's foremost mission is to encourage and organize communication between communities that have traditionally looked at software languages from different, more specialized, and yet complementary perspectives. SLE emphasizes the fundamental notion of languages as opposed to any realization in specific technical spaces. In this context, the term "software language" comprises all sorts of artificial languages used in software development including general-purpose programming languages, domain-specific languages, modeling and meta-modeling languages, data models, and ontologies. Software language engineering is the application of a systematic, disciplined, quantifiable approach to the development, use, and maintenance of these languages. The SLE conference is concerned with all phases of the lifecycle of software languages; these include the design, implementation, documentation, testing, deployment, evolution, recovery, and retirement of languages. Of special interest are tools, techniques, methods, and formalisms that support these activities. In particular, tools are often based on, or automatically generated from, a formal description of the language. Hence, the treatment of language descriptions as software artifacts, akin to programs, is of particular interest - while noting the special status of language descriptions, and the tailored engineering principles and methods for modularization, refactoring, refinement, composition, versioning, co-evolution, and analysis that can be applied to them. The response to the call for papers for SLE 2010 was very enthusiastic. We received 79 full submissions from 108 initial abstract submissions. From these submissions, the Program Committee (PC) selected 25 papers: 17 full papers, five short papers, and two tool demonstration papers, resulting in an acceptance rate of 32%. To ensure the quality of the accepted papers, each submitted paper was reviewed by at least three PC members. Each paper was discussed in detail during the electronic PC meeting. A summary of this discussion was prepared by members of the PC and provided to the authors along with the reviews

A Comparison of Model Migration Tools

International audienceModelling languages and thus their metamodels are subject to change. When a metamodel evolves, existing models may no longer conform to the evolved metamodel. To avoid rebuilding them from scratch, existing models must be migrated to conform to the evolved metamodel. Manually migrating existing models is tedious and errorprone. To alleviate this, several tools have been proposed to build a migration strategy that automates the migration of existing models. Little is known about the advantages and disadvantages of the tools in different situations. In this paper, we thus compare a representative sample of migration tools - AML, COPE, Ecore2Ecore and Epsilon Flock - using common migration examples. The criteria used in the comparison aim to support users in selecting the most appropriate tool for their situation

Evolving models in Model-Driven Engineering : State-of-the-art and future challenges

The artefacts used in Model-Driven Engineering (MDE) evolve as a matter of course: models are modified and updated as part of the engineering process; metamodels change as a result of domain analysis and standardisation efforts; and the operations applied to models change as engineering requirements change. MDE artefacts are inter-related, and simultaneously constrain each other, making evolution a challenge to manage. We discuss some of the key problems of evolution in MDE, summarise the key state-of-the-art, and look forward to new challenges in research in this area

Evolution of domain-specific languages depending on external libraries

L'ingénierie dirigée par les modèles est une approche qui s'appuie sur l'abstraction pour exprimer davantage les concepts du domaine. Ainsi, les ingénieurs logiciels développent des langages dédiés (LD) qui encapsulent la structure, les contraintes et le comportement du domaine. Comme tout logiciel, les LDs évoluent régulièrement. Cette évolution peut se produire lorsque l'un de ses composants ou le domaine évolue. L'évolution du domaine ainsi que l'évolution des composants du LD et l'impact de cette évolution sur ceux-ci ont été largement étudiés. Cependant, un LD peut également dépendre sur d'éléments externes qui ne sont pas modélisées. Par conséquent, l'évolution de ces dépendances externes affecte le LD et ses composants. Actuellement, les ingénieurs logiciels doivent évoluer le LD manuellement lorsque les dépendances externes évoluent. Dans ce mémoire, nous nous concentrons sur l'évolution des librairies externes. Plus spécifiquement, le but de cette thèse est d'aider les ingénieurs logiciels dans la tâche d'évolution. À cette fin, nous proposons une approche qui intègre automatiquement les changements des librairies externes dans le LD. De plus, nous offrons un LD qui supporte l'évolution des librairies Arduino. Nous évaluons également notre approche en faisant évoluer un éditeur de modélisation interactif qui dépend d'un LD. Cette étude nous permet de montrer la faisabilité et l'utilité de notre approche.Model-driven engineering (MDE) is an approach that relies on abstraction to further express domain concepts. Hence, language engineers develop domain-specific languages (DSLs) that encapsulates the domain structure, constraints, and behavior. Like any software, DSLs evolve regularly. This evolution can occur when one of its components or the domain evolves. The domain evolution as well as the evolution of DSL components and the impact of such evolution on them has been widely investigated. However, a DSL may also rely on external dependencies that are not modeled. As a result, the evolution of these external dependencies affects the DSL and its components. This evolution problem has yet to be addressed. Currently, language engineers must manually evolve the DSL when the external dependencies evolve. In this thesis, we focus on the evolution of external libraries. More specifically, our goal is to assist language engineers in the task of evolution. To this end, we propose an approach that automatically integrates the changes of the external libraries into the DSL. In addition, we offer a DSL that supports the evolution of the Arduino libraries. We also evaluate our approach by evolving an interactive modeling editor that depends on a DSL. This study allows us to demonstrate the feasibility and usefulness of our approach

MODEL DRIVEN SOFTWARE PRODUCT LINE ENGINEERING: SYSTEM VARIABILITY VIEW AND PROCESS IMPLICATIONS

La Ingeniería de Líneas de Productos Software -Software Product Line Engineerings (SPLEs) en inglés- es una técnica de desarrollo de software que busca aplicar los principios de la fabricación industrial para la obtención de aplicaciones informáticas: esto es, una Línea de productos Software -Software Product Line (SPL)- se emplea para producir una familia de productos con características comunes, cuyos miembros, sin embargo, pueden tener características diferenciales. Identificar a priori estas características comunes y diferenciales permite maximizar la reutilización, reduciendo el tiempo y el coste del desarrollo. Describir estas relaciones con la suficiente expresividad se vuelve un aspecto fundamental para conseguir el éxito. La Ingeniería Dirigida por Modelos -Model Driven Engineering (MDE) en inglés- se ha revelado en los últimos años como un paradigma que permite tratar con artefactos software con un alto nivel de abstracción de forma efectiva. Gracias a ello, las SPLs puede aprovecharse en granmedida de los estándares y herramientas que han surgido dentro de la comunidad de MDE. No obstante, aún no se ha conseguido una buena integración entre SPLE y MDE, y como consecuencia, los mecanismos para la gestión de la variabilidad no son suficientemente expresivos. De esta manera, no es posible integrar la variabilidad de forma eficiente en procesos complejos de desarrollo de software donde las diferentes vistas de un sistema, las transformaciones de modelos y la generación de código juegan un papel fundamental. Esta tesis presenta MULTIPLE, un marco de trabajo y una herramienta que persiguen integrar de forma precisa y eficiente los mecanismos de gestión de variabilidad propios de las SPLs dentro de los procesos de MDE. MULTIPLE proporciona lenguajes específicos de dominio para especificar diferentes vistas de los sistemas software. Entre ellas se hace especial hincapié en la vista de variabilidad ya que es determinante para la especificación de SPLs.Gómez Llana, A. (2012). MODEL DRIVEN SOFTWARE PRODUCT LINE ENGINEERING: SYSTEM VARIABILITY VIEW AND PROCESS IMPLICATIONS [Tesis doctoral no publicada]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/15075Palanci

From model-driven software development processes to problem diagnoses at runtime

Following the “convention over configuration” paradigm, model-driven software development (MDSD) generates code to implement the “default” behaviour that has been specified by a template separate from the input model. On the one hand, developers can produce end-products without a full understanding of the templates; on the other hand, the tacit knowledge in the templates is subtle to diagnose when a runtime software failure occurs. Therefore, there is a gap between templates and runtime adapted models. Generalising from the concrete problematic examples in MDSD processes to a model-based problem diagnosis, the chapter presents a procedure to separate the automated fixes from those runtime gaps that require human judgments

Handling High-Level Model Changes Using Search Based Software Engineering

Model-Driven Engineering (MDE) considers models as first-class artifacts during the software lifecycle. The number of available tools, techniques, and approaches for MDE is increasing as its use gains traction in driving quality, and controlling cost in evolution of large software systems. Software models, defined as code abstractions, are iteratively refined, restructured, and evolved. This is due to many reasons such as fixing defects in design, reflecting changes in requirements, and modifying a design to enhance existing features. In this work, we focus on four main problems related to the evolution of software models: 1) the detection of applied model changes, 2) merging parallel evolved models, 3) detection of design defects in merged model, and 4) the recommendation of new changes to fix defects in software models. Regarding the first contribution, a-posteriori multi-objective change detection approach has been proposed for evolved models. The changes are expressed in terms of atomic and composite refactoring operations. The majority of existing approaches detects atomic changes but do not adequately address composite changes which mask atomic operations in intermediate models. For the second contribution, several approaches exist to construct a merged model by incorporating all non-conflicting operations of evolved models. Conflicts arise when the application of one operation disables the applicability of another one. The essence of the problem is to identify and prioritize conflicting operations based on importance and context – a gap in existing approaches. This work proposes a multi-objective formulation of model merging that aims to maximize the number of successfully applied merged operations. For the third and fourth contributions, the majority of existing works focuses on refactoring at source code level, and does not exploit the benefits of software design optimization at model level. However, refactoring at model level is inherently more challenging due to difficulty in assessing the potential impact on structural and behavioral features of the software system. This requires analysis of class and activity diagrams to appraise the overall system quality, feasibility, and inter-diagram consistency. This work focuses on designing, implementing, and evaluating a multi-objective refactoring framework for detection and fixing of design defects in software models.Ph.D.Information Systems Engineering, College of Engineering and Computer ScienceUniversity of Michigan-Dearbornhttp://deepblue.lib.umich.edu/bitstream/2027.42/136077/1/Usman Mansoor Final.pdfDescription of Usman Mansoor Final.pdf : Dissertatio

Realizing Change-Driven Consistency for Component Code, Architectural Models, and Contracts in Vitruvius

During the development of component-based software systems, it is often impractical or even impossible to include all development information into the source code. Instead, specialized languages are used to describe components and systems on different levels of abstraction or from different viewpoints: Component-based architecture models and contracts, for example, can be used to describe the system on a high level of abstraction, and to formally specify component constraints. Since models, contracts, and code contain redundant information, inconsistencies can occur if they are modified independently. Keeping this information consistent manually can require considerable effort, and can lead to costly errors, for example, when security-relevant components are verified against inconsistent contracts. In this technical report, we present details on realizing an approach for keeping component-based architecture models and contracts specified in the Java Modeling Language (JML) consistent with Java source code. We use change-driven incremental transformations and the Vitruvius framework to automate the consistency preservation where this is possible. Using two case studies, we demonstrate how to detect and propagate changes and refactoring operations to keep models and contracts consistent with the source code