DOCSLIB.ORG

Evolving Legacy Software with a Generic Program

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Evolving Legacy Software with a Generic Program EVOLVING LEGACY SOFTWARE WITH A GENERIC PROGRAM TRANSFORMATION FRAMEWORK USING META-PROGRAMMING AND DOMAIN-SPECIFIC LANGUAGES by SONGQING YUE JEFF GRAY, COMMITTEE CHAIR JEFFREY CARVER XIAOYAN HONG PETER PIRKELBAUER SUSAN VRBSKY A DISSERTATION Submitted in partial fulfillment of the requirements for the degree of Doctor of Philosophy in the Department of Computer Science in the Graduate School of The University of Alabama TUSCALOOSA, ALABAMA 2015 Copyright Songqing Yue 2015 ALL RIGHTS RESERVED ABSTRACT Advances in the software industry over the past half-century have resulted in a large amount of legacy code implemented across hundreds of different programming languages and paradigms running throughout various application areas. Legacy software requires continuous and rigorous adaptation or modernization in order to avoid progressive decay in quality over time. Modern approaches addressing the needs of modularity and reusability in software engineering have been investigated as effective techniques to assist in software development and maintenance by automating the process of code evolution. The research in this dissertation is focused on applying techniques in software engineering and programming language design to address challenges in software maintenance and evolution. A specific focus area of application is software in the area of High Performance Computing (HPC) with Fortran and C. The research makes a contribution by bringing the power of meta-programming, through Meta-Object Protocols (MOPs), to languages that are widely utilized for solving various problems in HPC. With MOP facilities provided by OpenFortran and OpenC (the two MOPs we built for Fortran and C), developers can build tools to perform arbitrary source-to-source program transformations for legacy software. To simplify the use of MOPs and to reduce the accidental complexities typically associated with the intensive meta-programming paradigm, a textual Domain-Specific Language (DSL) is introduced in our approach, which provides a higher-level abstraction for specifying program transformations, and thus enables direct expression of manipulating program entities. ii There is a general lack of infrastructure support for language extension in terms of building a MOP for an arbitrary language. In order for our approach to accommodate additional programming languages, an extensible framework has been developed in this dissertation work. The framework is composed of a language-independent MOP prototype, called OpenFoo, and a generic front-end DSL (i.e., SPOT). With the assistance of a set of models that describe the aspects and concerns associated with MOP implementation and code modification, the MOP prototype can be extended to create a MOP instance for a specific general-purpose programming language (GPL); and, similarly, the DSL can be extended to accommodate a newly created backend MOP. iii DEDICATION This work is dedicated to Jesus Christ for your grace and unconditional love, to my father and my mother for your support and blessings, to my younger brother for your company in the last two years at UA, and to all my brothers and sisters in Jesus Christ and my dear friends for standing by me throughout the time taken to complete this dissertation. iv LIST OF ABBREVIATIONS AND SYMBOLS ANTLR Another tool for Language Recognition AOP Aspect-Oriented Programming API Application Programming Interface AST Abstract Syntax Tree CASE Computer-Aided Software Engineering CG Conjugate Gradient CLOS Common Lisp Object System CUDA Compute Unified Device Architecture DSL Domain-Specific Languages DMS Design Maintenance System EBNF Extended Backus-Naur Form EDG Edison Design Group EP Embarrassingly Parallel FFT Fast Fourier Transform GPL General-purpose Programming Language HPC High Performance Computing HPF High-Performance Fortran IDE Integrated Development Environment IR Intermediate Representation LOC Lines of Code v MDE Model-Driven Engineering MOP Meta-Object Protocol MPI Message Passing Interface NAS NASA Advanced Supercomputing NPB NAS Parallel Benchmark OFP Open Fortran Parser OOP Object-Oriented Programming OpenMP Open Multiprocessing PTE Program Transformation Engine RSL Rule Specification Language SMP Symmetric Multiprocessing System SPOT Specifying Programming Transformation TXL Turing eXtender Language UML Unified Modeling Language XML Extensible Markup Language vi ACKNOWLEDGMENTS I am pleased to have this opportunity to thank the many colleagues, friends, and faculty members who have helped me during the whole period of my graduate study. First and foremost, I would like to show my gratitude and appreciation to my advisor, Dr. Jeff Gray, for providing me the opportunity to complete my Ph.D. study at the University of Alabama. Without Dr. Gray’s continuous support and encouragement, this work is impossible. When I went through a difficult time in 2010, it was Dr. Gray who lent his helping hand by agreeing to work with me. In the past five years, Dr. Gray has offered me great help and advice toward my research directions, revising the publications, and refining the quality of my research results. I have learned a lot from his outstanding example on how to become a responsible professor and a professional computer researcher. I would also like to extend my gratitude to the other members of my committee. To Dr. Jeffrey Carver, Dr. Xiaoyan Hong, Dr. Peter Pirkelbauer, and Dr. Susan Vrbsky, I feel grateful for your efforts to help me develop the necessary knowledge and skills throughout the stages of my graduate study. I really appreciate your precious time and effort in serving on my committee. To my fellow coworkers at UA, Ke Meng, Bo Fu, Xiannuan Liang, Jing Liu, Jingcheng Gao, Miao Peng, Yan Liang, Yanping Zhang, Zhifeng Xiao, Yu Sun, Hyun Cho, Lei Zeng, Amber Wagner, Ferosh, Jacob, Jonathan Corley, and Songhui Yue, I really appreciate your friendship and all the wonderful and fun times we shared. To all my colleagues in the graduate school at UA, Ashirul Mubin, Dr. John Schmitt, Eric Harris, John Chambers, Kathleen Nodine, Debbie Eads, Sheryl Tubbs, Rebekah Hughes-Brown, vii Mary Williams, and Beth Yarbrough, I really enjoyed working with you as a team to provide professional service to graduate students. I will always be grateful to the financial support from the graduate school. This dissertation would not have been possible without the support of my friends and my family who never stopped encouraging me to persist. Finally, I thank all who have ever helped me on my road towards the completion of my Ph.D. study. viii CONTENTS ABSTRACT ................................................................................................ ii DEDICATION ........................................................................................... iv LIST OF ABBREVIATIONS AND SYMBOLS ........................................v ACKNOWLEDGMENTS ........................................................................ vii LIST OF TABLES ................................................................................... xiii LIST OF FIGURES ................................................................................. xiv 1. INTRODUCTION ...................................................................................1 1.1 Software Maintenance Challenges in High Performance Computing .....................................................2 1.2 Program Transformation Techniques ........................................5 1.2.1 Meta-Programming and Meta-Object Protocol ..........7 1.3 Domain-Specific Languages ......................................................9 1.4 Research Objectives and Contributions ...................................10 1.4.1 Research Questions ...................................................11 1.5 Dissertation Overview .............................................................17 2. BACKGROUND ...................................................................................19 2.1 High Performance Computing .................................................19 2.2 Meta-Programming ..................................................................22 2.2.1 Open Implementation ................................................23 2.2.2 Computational Reflection .........................................24 ix 2.2.3 Meta-Object Protocol ................................................29 2.3 Program Transformation Approaches ......................................31 2.4 Related Work ...........................................................................35 2.4.1 Existing MOPs ..........................................................35 2.4.2 Aspect-Oriented Programming .................................45 2.4.3 Domain-Specific Languages .....................................47 3. EXTENDING PROGRAMS WITH META-PROGRAMMING ..........49 3.1 OpenFortran: A MOP for Extending Fortran Programs ..........50 3.1.1 OpenFortran Design Architecture .............................51 3.1.2 OpenFortran Implementation Details .......................54 3.2 OpenC: A MOP for Extending C Programs ............................59 3.2.1 Benefits of OpenC MOP ...........................................60 3.2.2 OpenC Design and Implementation ..........................62 3.2.3 Implementing a Library in OpenC ............................64 3.3 Case Study: Timer Implementation in NAS ............................68 3.4 Summary ..................................................................................71 3.4.1 Lessons Learned ........................................................72
Load more

Recommended publications
  • Source-To-Source Translation and Software Engineering
    Journal of Software Engineering and Applications, 2013, 6, 30-40 http://dx.doi.org/10.4236/jsea.2013.64A005 Published Online April 2013 (http://www.scirp.org/journal/jsea) Source-to-Source Translation and Software Engineering David A. Plaisted Department of Computer Science, University of North Carolina at Chapel Hill, Chapel Hill, USA. Email: [email protected] Received February 5th, 2013; revised March 7th, 2013; accepted March 15th, 2013 Copyright © 2013 David A. Plaisted. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited. ABSTRACT Source-to-source translation of programs from one high level language to another has been shown to be an effective aid to programming in many cases. By the use of this approach, it is sometimes possible to produce software more cheaply and reliably. However, the full potential of this technique has not yet been realized. It is proposed to make source- to-source translation more effective by the use of abstract languages, which are imperative languages with a simple syntax and semantics that facilitate their translation into many different languages. By the use of such abstract lan- guages and by translating only often-used fragments of programs rather than whole programs, the need to avoid writing the same program or algorithm over and over again in different languages can be reduced. It is further proposed that programmers be encouraged to write often-used algorithms and program fragments in such abstract languages. Libraries of such abstract programs and program fragments can then be constructed, and programmers can be encouraged to make use of such libraries by translating their abstract programs into application languages and adding code to join things together when coding in various application languages.
    [Show full text]
  • The Model Transformation Language of the VIATRA2 Framework
    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by Elsevier - Publisher Connector Science of Computer Programming 68 (2007) 214–234 www.elsevier.com/locate/scico The model transformation language of the VIATRA2 framework Daniel´ Varro´ ∗, Andras´ Balogh Budapest University of Technology and Economics, Department of Measurement and Information Systems, H-1117, Magyar tudosok krt. 2., Budapest, Hungary OptXware Research and Development LLC, Budapest, Hungary Received 15 August 2006; received in revised form 17 April 2007; accepted 14 May 2007 Available online 5 July 2007 Abstract We present the model transformation language of the VIATRA2 framework, which provides a rule- and pattern-based transformation language for manipulating graph models by combining graph transformation and abstract state machines into a single specification paradigm. This language offers advanced constructs for querying (e.g. recursive graph patterns) and manipulating models (e.g. generic transformation and meta-transformation rules) in unidirectional model transformations frequently used in formal model analysis to carry out powerful abstractions. c 2007 Elsevier B.V. All rights reserved. Keywords: Model transformation; Graph transformation; Abstract state machines 1. Introduction The crucial role of model transformation (MT) languages and tools for the overall success of model-driven system development has been revealed in many surveys and papers during the recent years. To provide a standardized support for capturing queries, views and transformations between modeling languages defined by their standard MOF metamodels, the Object Management Group (OMG) has recently issued the QVT standard. QVT provides an intuitive, pattern-based, bidirectional model transformation language, which is especially useful for synchronization kind of transformations between semantically equivalent modeling languages.
    [Show full text]
  • Model Transformation Languages Under a Magnifying Glass:A Controlled Experiment with Xtend, ATL, And
    CORE Metadata, citation and similar papers at core.ac.uk Provided by The IT University of Copenhagen's Repository Model Transformation Languages under a Magnifying Glass: A Controlled Experiment with Xtend, ATL, and QVT Regina Hebig Christoph Seidl Thorsten Berger Chalmers | University of Gothenburg Technische Universität Braunschweig Chalmers | University of Gothenburg Sweden Germany Sweden John Kook Pedersen Andrzej Wąsowski IT University of Copenhagen IT University of Copenhagen Denmark Denmark ABSTRACT NamedElement name : EString In Model-Driven Software Development, models are automatically processed to support the creation, build, and execution of systems. A large variety of dedicated model-transformation languages exists, Project Package Class StructuralElement modifiers : Modifier promising to efficiently realize the automated processing of models. [0..*] packages To investigate the actual benefit of using such specialized languages, [0..*] subpackages [0..*] elements Modifier [0..*] classes we performed a large-scale controlled experiment in which over 78 PUBLIC STATIC subjects solve 231 individual tasks using three languages. The exper- FINAL Attribute Method iment sheds light on commonalities and differences between model PRIVATE transformation languages (ATL, QVT-O) and on benefits of using them in common development tasks (comprehension, change, and Figure 1: Syntax model for source code creation) against a modern general-purpose language (Xtend). Our results show no statistically significant benefit of using a dedicated 1 INTRODUCTION transformation language over a modern general-purpose language. In Model-Driven Software Development (MDSD) [9, 35, 38] models However, we were able to identify several aspects of transformation are automatically processed to support creation, build and execution programming where domain-specific transformation languages do of systems.
    [Show full text]
  • Extending Fortran with Meta-Programming
    OpenFortran: Extending Fortran with Meta-programming Songqing Yue and Jeff Gray Department of Computer Science University of Alabama Tuscaloosa, AL, USA {syue, gray}@cs.ua.edu Abstract—Meta-programming has shown much promise for manipulated [1]. MOPs add the ability of meta-programming improving the quality of software by offering programming to programming languages by providing users with standard language techniques to address issues of modularity, reusability, interfaces to modify the internal implementation of the maintainability, and extensibility. A system that supports meta- program. Through the interface, programmers can programming is able to generate or manipulate other programs incrementally change the implementation and the behavior of a to extend their behavior. This paper describes OpenFortran, a program to better suit their needs. Furthermore, a metaprogram Meta-Object Protocol (MOP) that is able to bring the power of can capture the needs of a commonly needed feature and be meta-programming to Fortran, one of the most widely used applied to several different base programs. languages in the area of High Performance Computing (HPC). OpenFortran provides a framework that allows library A MOP may perform the underling adaptation of the base developers to build arbitrary source-to-source program program at either run-time or compile-time. Run-time MOPs transformation libraries for Fortran programs. To relieve the function while a program is executing and can be used to burden of learning the details about how the underlying perform real-time adaptation, for example the Common Lisp transformations are performed, a domain-specific language Object System (CLOS) [13] that allows the mechanisms of named SPOT has been created that allows developers to specify inheritance, method dispatching, and class instantiation to be direct manipulation of programs.
    [Show full text]
  • ROSE Tutorial: a Tool for Building Source-To-Source Translators Draft Tutorial (Version 0.9.11.115)
    ROSE Tutorial: A Tool for Building Source-to-Source Translators Draft Tutorial (version 0.9.11.115) Daniel Quinlan, Markus Schordan, Richard Vuduc, Qing Yi Thomas Panas, Chunhua Liao, and Jeremiah J. Willcock Lawrence Livermore National Laboratory Livermore, CA 94550 925-423-2668 (office) 925-422-6278 (fax) fdquinlan,panas2,[email protected] [email protected] [email protected] [email protected] [email protected] Project Web Page: www.rosecompiler.org UCRL Number for ROSE User Manual: UCRL-SM-210137-DRAFT UCRL Number for ROSE Tutorial: UCRL-SM-210032-DRAFT UCRL Number for ROSE Source Code: UCRL-CODE-155962 ROSE User Manual (pdf) ROSE Tutorial (pdf) ROSE HTML Reference (html only) September 12, 2019 ii September 12, 2019 Contents 1 Introduction 1 1.1 What is ROSE.....................................1 1.2 Why you should be interested in ROSE.......................2 1.3 Problems that ROSE can address...........................2 1.4 Examples in this ROSE Tutorial...........................3 1.5 ROSE Documentation and Where To Find It.................... 10 1.6 Using the Tutorial................................... 11 1.7 Required Makefile for Tutorial Examples....................... 11 I Working with the ROSE AST 13 2 Identity Translator 15 3 Simple AST Graph Generator 19 4 AST Whole Graph Generator 23 5 Advanced AST Graph Generation 29 6 AST PDF Generator 31 7 Introduction to AST Traversals 35 7.1 Input For Example Traversals............................. 35 7.2 Traversals of the AST Structure............................ 36 7.2.1 Classic Object-Oriented Visitor Pattern for the AST............ 37 7.2.2 Simple Traversal (no attributes)....................... 37 7.2.3 Simple Pre- and Postorder Traversal....................
    [Show full text]
  • Towards Large-Scale Refactoring for Ocaml
    Towards Large-scale Refactoring for OCaml REUBEN N. S. ROWE, University of Kent, UK SIMON J. THOMPSON, University of Kent, UK Refactoring is the process of changing the way a program works without changing its overall behaviour. The functional programming paradigm presents its own unique challenges to refactoring. For the OCaml language in particular, the expressiveness of its module system makes this a highly non-trivial task. The use of PPX preprocessors, other language extensions, and idiosyncratic build systems complicates matters further. We begin to address the question of how to refactor large OCaml programs by looking at a particular refactoring—value binding renaming—and implementing a prototype tool to carry it out. Our tool, Rotor, is developed in OCaml itself and combines several features to manage the complexities of refactoring OCaml code. Firstly it defines a rich, hierarchical way of identifying bindings which distinguishes between structures and functors and their associated module types, and is able to refer directly to functor parameters. Secondly it makes use of the recently developed visitors library to perform generic traversals of abstract syntax trees. Lastly it implements a notion of ‘dependency’ between renamings, allowing refactorings to be computed in a modular fashion. We evaluate Rotor using a snapshot of Jane Street’s core library and its dependencies, comprising some 900 source files across 80 libraries, and a test suite of around 3000 renamings. We propose that the notion of dependency is a general one for refactoring, distinct from a refactoring ‘precondition’. Dependencies may actually be mutual, in that all must be applied together for each one individually to be correct, and serve as declarative specifications of refactorings.
    [Show full text]
  • Combining Source and Target Level Cost Analyses for Ocaml Programs
    Combining Source and Target Level Cost Analyses for OCaml Programs Stefan K. Muller Jan Hoffmann Carnegie Mellon University Carnegie Mellon University Abstract bounding gas usage in smart contracts [24]. More generally, Deriving resource bounds for programs is a well-studied it is an appealing idea to provide programmers with imme- problem in the programming languages community. For com- diate feedback about the efficiency of their code at design piled languages, there is a tradeoff in deciding when during time. compilation to perform such a resource analysis. Analyses at When designing a resource analysis for a compiled higher- the level of machine code can precisely bound the wall-clock level language, there is a tension between working on the execution time of programs, but often require manual anno- source code, the target code, or an intermediate represen- tations describing loop bounds and memory access patterns. tation. Advantages of analyzing the source code include Analyses that run on source code can more effectively derive more effective interaction with the programmer and more such information from types and other source-level features, opportunities for automation since the control flow and type but produce abstract bounds that do not directly reflect the information are readily available. The advantage of analyz- execution time of the compiled machine code. ing the target code is that analysis results apply to the code This paper proposes and compares different techniques for that is eventually executed. Many of the tools developed combining source-level and target-level resource analyses in in the programming languages community operate on the the context of the functional programming language OCaml.
    [Show full text]
  • A Bundle of Program Transformation Tools System Description
    ¡ ¢ £ ¤ ¦ ¨ ¨ ! $ % & ! % $ ' ( * * ( + - . / 0 XT: a bundle of program transformation tools system description Merijn de Jonge 1 CWI, Department SEN, PO Box 94079, 1090 GB Amsterdam, The Netherlands Eelco Visser 2 Universiteit Utrecht, Institute of Information and Computing Sciences PO Box 80089, 3508 TB Utrecht, The Netherlands Joost Visser 3 CWI, Department SEN, PO Box 94079, 1090 GB Amsterdam, The Netherlands Abstract XT bundles existing and newly developed program transformation libraries and tools into an open framework that supports component-based development of program transforma- tions. We discuss the roles of XT’s constituents in the development process of program transformation tools, as well as some experiences with building program transformation systems with XT. 1 Introduction Program transformation encompasses a variety of different, but related, language processing scenarios, such as optimization, compilation, normalization, and reno- vation. Across these scenarios, many common, or similar subtasks can be distin- guished, which opens possibilities for software reuse. To support and demonstrate such reuse across program transformation project boundaries, we have developed XT. XT is a bundle of existing and newly developed libraries and tools useful in the 4 Email:[email protected] 5 Email:[email protected] 6 Email:[email protected] 8 : : ; < > @ BC E G H J @ L N BE H P CH R T V CH Y V H [ ] _ ] 7 c 79 a b d f g i b j g a m oq q b s j g a m oq q b s context of program transformation. It bundles its constituents into an open frame- work for component-based transformation tool development, which is flexible and extendible.
    [Show full text]
  • Data Transformation Language (DTL)
    DTL Data Transformation Language Phillip H. Sherrod Copyright © 2005-2006 All rights reserved www.dtreg.com DTL is a full programming language built into the DTREG program. DTL makes it easy to generate new variables, transform and combine input variables and select records to be used in the analysis. Contents Contents...................................................................................................................................................3 Introduction .............................................................................................................................................6 Introduction to the DTL Language......................................................................................................6 Using DTL For Data Transformations ....................................................................................................7 The main() function.............................................................................................................................7 Global Variables..................................................................................................................................8 Implicit Global Variables ................................................................................................................8 Explicit Global Variables ................................................................................................................9 Static Global Variables..................................................................................................................11
    [Show full text]
  • Model-Based Hardware Generation and Programming - the MADES Approach
    1 Model-based hardware generation and programming - the MADES approach Ian Gray∗, Nikos Matragkas∗, Neil C. Audsley, Leandro Soares Indrusiak, Dimitris Kolovos, Richard Paige University of York, York, U.K. F Abstract—This paper gives an overview of the model-based hardware the proposed hardware development flow and the way generation and programming approach proposed within the MADES that embedded software can be targeted at the resulting project. MADES aims to develop a model-driven development process complex architectures. for safety-critical, real-time embedded systems. MADES defines a sys- tems modelling language based on subsets of MARTE and SysML that allows iterative refinement from high-level specification down to 1.1 MADES Project Goals final implementation. The MADES project specifically focusses on three The MADES project (Model-based methods and tools unique features which differentiate it from existing model-driven develop- ment frameworks. First, model transformations in the Epsilon modelling for Avionics and surveillance embeddeD systEmS) aims framework are used to move between system models and provide to develop the elements of a fully model-driven ap- traceability. Second, the Zot verification tool is employed to allow early proach for the design, validation, simulation, and code and frequent verification of the system being developed. Third, Compile- generation of complex embedded systems to improve Time Virtualisation is used to automatically retarget architecturally- the current practice in the field. MADES differentiates neutral software for execution on complex embedded architectures. itself from similar projects in that way that it covers This paper concentrates on MADES’s approach to the specification of hardware and the way in which software is refactored by Compile-Time all the phases of the development process: from system Virtualisation.
    [Show full text]
  • When Polyhedral Transformations Meet SIMD Code Generation
    When Polyhedral Transformations Meet SIMD Code Generation Martin Kong Richard Veras Kevin Stock Ohio State University Carnegie Mellon University Ohio State University [email protected] [email protected] [email protected] Franz Franchetti Louis-Noel¨ Pouchet P. Sadayappan Carnegie Mellon University University of California Los Angeles Ohio State University [email protected] [email protected] [email protected] Abstract While hand tuned library kernels such as GotoBLAS address all Data locality and parallelism are critical optimization objectives for the above factors to achieve over 95% of machine peak for spe- performance on modern multi-core machines. Both coarse-grain par- cific computations, no vectorizing compiler today comes anywhere allelism (e.g., multi-core) and fine-grain parallelism (e.g., vector SIMD) close. Recent advances in polyhedral compiler optimization [5, 11] must be effectively exploited, but despite decades of progress at both have resulted in effective approaches to tiling for cache locality, ends, current compiler optimization schemes that attempt to address even for imperfectly nested loops. However, while significant per- data locality and both kinds of parallelism often fail at one of the three formance improvement over untiled code has been demonstrated, objectives. the absolute achieved performance is still very far from machine We address this problem by proposing a 3-step framework, which peak. A significant challenge arises from the fact that polyhedral aims for integrated data locality, multi-core parallelism and SIMD exe- cution of programs. We define the concept of vectorizable codelets, with compiler transformations to produce tiled code generally require properties tailored to achieve effective SIMD code generation for the auxiliary transformations like loop skewing, causing much more codelets.
    [Show full text]
  • Feather: a Feature Model Transformation Language
    1 Feather: A Feature Model Transformation Language Ahmet Serkan Karataş * area of usage to include dynamic systems that can face Abstract: Feature modeling has been a very popular approach fluctuating context conditions, changing user requirements, for variability management in software product lines. Building need to include and facilitate novel resources rapidly, and so on. a feature model requires substantial domain expertise, however, The constant need for adaptation required to enhance the even experts cannot foresee all future possibilities. Changing variability management capabilities of SPLs to cover runtime, requirements can force a feature model to evolve in order to which gave birth to the dynamic software product lines adapt to the new conditions. Feather is a language to describe (DSPLs). In addition to the properties they inherit from SPLs, model transformations that will evolve a feature model. This DSPLs have several other properties such as dynamic article presents the structure and foundations of Feather. First, variability management, flexible variation points and binding the language elements, which consist of declarations to times, context awareness, and self-adaptability [21]. characterize the model to evolve and commands to manipulate A major factor affecting the success of a software product its structure, are introduced. Then, semantics grounding in line, classic or dynamic, is the variability management activity feature model properties are given for the commands in order it incorporates [12]. In the literature there are reports of various to provide precise command definitions. Next, an interpreter variability modeling and management approaches such as that can realize the transformations described by the commands in a Feather script is presented.
    [Show full text]