ChainTracker, a Model-Transformation Trace Analysis Tool for Code-Generation Environments (original) (raw)
Related papers
Reflecting on Model-based Code Generators Using Traceability Information
Model-based code generators use model-to-model and model-to-text transformations to systematize the construction of software systems. They integrate rule-based and template-based transformation languages to translate high-level specifications into executable code and scripts. Given the complexity and heterogeneity of the underlying transformation languages, flexible traceability tools are needed to collect and visualize information about their architecture and operational mechanics. In this paper,we present ChainTracker, a traceability analysis environment for model-based code generators. ChainTracker helps developers to reflect on the composition of model transformations during the different stages of their construction and maintenance. Furthermore, in this paper we describe a family of software-engineering tasks that developers have to complete during the construction of model-based code generators, and how ChainTracker makes the execution of these.
ChainTracker: Towards a Comprehensive Tool for Building Code-generation Environments
Code-generation environments have emerged as a new mechanism for building software systems in a systematic manner. At their core, model-driven engineering technologies such as model-to-model and model-to-text transformations are effectively used to build generation engines. However, due to the complexity of model-to-model and model-to-text transformation scripts, which is exacerbated as they are composed in complex transformation chains, developers face technical and cognitive challenges when architecting, implementing, and maintaining code-generation environments. In this paper we present ChainTracker, a visualization and trace analysis tool for model-to-model and model-to-text transformation compositions. ChainTracker aims to support developers of code-generation environments by making the usage of model-driven engineering technologies more efficient, less error prone, and less cognitively challenging.
Model-based code-generators are complex in nature; they are built using diverse technology platforms such as language workbenches, and model-to-model and model-to-text transformation languages. Due to the highly heterogeneous technology ecosystem in which code generators are built, understanding and maintaining their architecture pose numerous cognitive challenges to both novice and expert developers. Most of these challenges are associated with tasks that require to trace and pinpoint generation artifacts given a life-cycle requirement. We argue that such tasks can be classified in three families, namely, 1. information discovery, 2. information summarization, and 3. information filtering and isolation. Furthermore, we hypothesize that visualizations that allow the interactive exploration of model-to-model and model-to-text transformation compositions can significantly improve developers’ performance when reflecting on a code generation architecture, and its corresponding execution mechanics. In this paper we describe an empirical study which purpose is twofold: first to (a) understand the performance of developers (in terms of time and precision) when asked to discover, filter, and summarize information about a model-based code generator, using classic integrated development environments and editors, and to (b) measure and compare the performance of developers executing the same set of tasks using state-of-theart traceability visualizations for model-transformation compositions
Backward Propagation of Code Refinements on Transformational Code Generation Environments
TEFSE'13 - The 7th International Workshop on Traceability in Emerging Forms of Software Engineering.
Transformational code generation is at the core of generative software development. It advocates the detection of common and variable features in families of software systems that can be generalized and modeled by domain-specific languages. Additionally, it proposes transformation compositions as a means for successively refining the abstraction level of domain models towards eventually enriching them with execution semantics. Thus, using code-generation environments, families of software systems can be generated, based on models specified in high-level domain languages. The major advantage of this software-construction methodology stems from the fact that it enables the reuse of verified execution semantics, derived from domain models. However, like all software, once an implementation is generated, it is bound to evolve and manually refined to introduce features that were not captured by its original generation environment. This paper describes a conceptual framework for identifying features that have to be backwards propagated to generation engines, from refined generated references. Our conceptual framework is based on static and symbolic execution analysis, and aims to contribute to the maintenance and evolution challenges of model-driven development.
Supporting Maintenance Tasks on Transformational Code Generation Environments
Doctoral Symposium 35th International Conference on Software Engineering (ICSE 2013)
At the core of model-driven software development, model-transformation compositions enable automatic generation of executable artifacts from models. Although the advantages of transformational software development have been explored by numerous academics and industry practitioners, adoption of the paradigm continues to be slow, and limited to specific domains.The main challenge to adoption is the fact that maintenance tasks, such as analysis and management of model-transformation compositions and reflecting code changes to model transformations, are still largely unsupported by tools. My dissertation aims at enhancing the field’s understanding around the maintenance issues in transformational software development, and at supporting the tasks involved in the synchronization of evolving system features with their generation environments. This paper discusses the three main aspects of the envisioned thesis: (a) complexity analysis of model-transformation compositions, (b) system feature localization and tracking in model-transformation compositions, and (c) refactoring of transformation compositions to improve their qualities.
On the Specification of Model Transformations through a Platform Independent Approach
Proceedings of the 27th International Conference on Software Engineering and Knowledge Engineering, 2015
Transformations are key artifacts in the MDD (Model Driven Development) approach: a software development project can be defined through a transformation chain converting source models into target models until code, enabling development process automation. Transformations can be complex and demand software processes, languages and techniques to improve their development in order to increase reuse, portability, correctness, and so on. In this context we propose a framework to develop model transformations using MDD. This paper presents a Model Transformation Profile (MTP) defined as the domain specific language of the framework.
Tracing Evolution Changes of Software Artifacts through Model Synchronization
2004
Software evolution encompasses all activities related to engineering software, from its inception to retirement. Propagating change across software models that are altered due to maintenance activities is a first step towards maintaining consistency between architectural, design, and implementation models. Model synchronization techniques initially presented within the context of Model Driven Architecture provide an instrument for achieving change traceability and consistency. In this paper, we present a framework whereby software artifacts at different levels of abstraction such as architecture diagrams, object models, and abstract syntax trees are represented by graph-based MOF compliant models that can be synchronized using model transformations. In such a framework model dependencies are implicitly encoded using transformation rules and an equivalence relation is used to evaluate when two models become synchronized.
Automatic Impact Analysis of Software Architecture Migration on Model Driven Software Development
2013
The use of Model Driven Software Development (MDSD) approach is increasing in industry. MDSD approach raises the level of abstraction using models as main artifacts of software engineering processes. Models are closer to the problem domain than the solution domain and are easier to understand than the code. Models could be used for early validation and verification or for the automatic generation of code. When models are used for code generation, a system based on metamodels and transformations is developed in order to allow automatic code generation from models. Maintainability and evolution of these systems is a real and complex issue. Moreover, when the software architecture of the targeted systems evolves, the system that generates the code should evolve too. This means to adapt the transformation rules, the input metamodel and models. To reduce the adaptation time of MDSD system has become crucial. In this paper we present an approach and a tool for performing automated analysi...
Reuse and configuration for code generating architectural refinement transformations
Proceedings of the 1st Workshop on View-Based, Aspect-Oriented and Orthographic Software Modelling, 2013
The transformation of component-based architectures into object-oriented source code for different platforms is a common task in Model-Driven Software Development. Reusing parts that are common to all supported target-platforms for several model-to-text transformations is challenging. Existing approaches, like parameterized transformations and modularity concepts for transformations, make the reuse of transformations parts easier, but cannot be used to visualize design decisions that are common to all supported target-platforms. In this paper, we propose that platformindependent design decisions and their transformation results should be made explicit in an intermediate view. A single parameterized transformation should yield a common objectoriented model before individual transformations for specific platforms are executed. We argue that the additional view makes it possible to analyze decisions on how a component architecture is implemented and increases the maintainability by decoupling the involved transformations.