Generic Tools, Specific Languages

Adapting tools to a particular domain is expensive, and the adaptation is often not very deep. To address this challenge, Generic Tools, Specific Languages shifts the focus from building and adapting tools (windows, buttons, algorithms) to building and adapting languages to a domain. The thesis applies the approach to embedded software development: mbeddr is an extensible set of integrated languages for embedded software development built with JetBrains MPS language workbench. The evaluation of mbeddr suggests that it is a productive tool for embedded software development. The evaluation of the development of mbeddr itself suggests that MPS is a suitable platform for Generic Tools, Specific Languages, and that the approach in general is worthwhile. 1.1 O V E RV I E W A N D C O N T R I B U T I O N This section provides an overview of the thesis. It starts out by describing the contribution and the research methodology. It then discusses mbeddr, the primary artifact built during the dissertation and explains its context, embedded software engineering. A discussion of the technologies used for building mbeddr – language engineering, projectional editing and JetBrains MPS – follows. The section concludes with an overview of the results. Contribution Today’s software engineering tools are hard to adapt to specific domains. A major reason is that while platforms such as Eclipse support easy extension of the tool (views, editors, buttons, menus) they do not easily support the extension of the data formats or languages that underlie a tool. The contribution of this thesis is the introduction and evaluation of a new approach to developing domain-specific software engineering tools called Generic Tools, Specific Languages. It shifts the focus from adapting the engineering tool to adapting the underlying languages to solve the problem of tool adaptation. It relies on language workbenches (the generic tool) and recent advances in language engineering, particularly, user-friendly projectional editing. The problem of tool extensibility, the Generic Tools, Specific Languages approach and the way it is evaluated is discussed in Chapter 2. The specific research questions that arise from the approach (domain-specific extensibility, language modularity and projectional editing, tool scalability, implementation efforts and the learning curve) are introduced and motivated in Section 2.6. Methodology As part of the dissertation, the Generic Tools, Specific Languages approach has been applied to embedded software engineering, resulting in a

[1]  Greg J. Michaelson,et al.  Hume: A Domain-Specific Language for Real-Time Embedded Systems , 2003, GPCE.

[2]  K. Beetz,et al.  Nationale Roadmap Embedded Systems , 2010 .

[3]  Partha S. Roop,et al.  PRET-C: A new language for programming precision timed architectures , 2009 .

[4]  Ralf Huuck,et al.  Goanna - A Static Model Checker , 2006, FMICS/PDMC.

[5]  James R. Larus,et al.  Singularity: rethinking the software stack , 2007, OPSR.

[6]  Viljem Zumer,et al.  Incremental programming language development , 2005, Comput. Lang. Syst. Struct..

[7]  Michael D. Ernst,et al.  An Empirical Analysis of C Preprocessor Use , 2002, IEEE Trans. Software Eng..

[8]  Karsten Loer,et al.  Towards usable and relevant model checking techniques for the analysis of dependable interactive systems , 2002, Proceedings 17th IEEE International Conference on Automated Software Engineering,.

[9]  Mike Barnett,et al.  Towards imperative modules: reasoning about invariants and sharing of mutable state , 2004, LICS 2004.

[10]  Arie van Deursen,et al.  Little languages: little maintenance , 1998 .

[11]  David Notkin,et al.  A framework for preprocessor-aware C source code analyses , 2000 .

[12]  Douglas C. Schmidt,et al.  Automated diagnosis of feature model configurations , 2010, J. Syst. Softw..

[13]  Peter Liggesmeyer,et al.  Trends in Embedded Software Engineering , 2009, IEEE Software.

[14]  Gabor Karsai,et al.  Embedded Software: Challenges and Opportunities , 2001, EMSOFT.

[15]  Matthias Jarke,et al.  Requirements tracing , 1998, CACM.

[16]  Frédéric Boussinot,et al.  Reactive C: An extension of C to program reactive systems , 1991, Softw. Pract. Exp..

[17]  Bernhard Schätz,et al.  Language engineering as an enabler for incrementally defined formal analyses , 2012, 2012 First International Workshop on Formal Methods in Software Engineering: Rigorous and Agile Approaches (FormSERA).

[18]  Gail C. Murphy,et al.  An exploratory study of forces and frictions affecting large-scale model-driven development , 2012, MODELS'12.

[19]  Maria H. Penedo,et al.  An annotated bibliography on integration in software engineering environments , 1992, SOEN.

[20]  Ian Thomas,et al.  Definitions of Tool Integration for Environments , 1992, IEEE Softw..

[21]  Eelco Visser,et al.  Product Line Engineering Using Domain-Specific Languages , 2011, 2011 15th International Software Product Line Conference.

[22]  Bernhard Schätz,et al.  mbeddr: instantiating a language workbench in the embedded software domain , 2013, Automated Software Engineering.

[23]  Thomas W. Reps,et al.  The synthesizer generator , 1984, SDE 1.

[24]  Bertrand Meyer.  Design By Contract. The Eiffel Method , 1998, Proceedings. Technology of Object-Oriented Languages. TOOLS 26 (Cat. No.98EX176).

[25]  Paul Clements,et al.  From subroutines to subsystems: component-based software development , 2001 .

[26]  John Favaro,et al.  Next Generation Requirements Engineering , 2011 .

[27]  Manfred Broy,et al.  Challenges in automotive software engineering , 2006, ICSE.

[28]  Janos Sztipanovits,et al.  Correct-ed through construction: a model-based approach to embedded systems reality , 2006, 13th Annual IEEE International Symposium and Workshop on Engineering of Computer-Based Systems (ECBS'06).

[29]  Dinakar Dhurjati,et al.  Memory safety without runtime checks or garbage collection , 2003 .

[30]  Alejandra Garrido,et al.  Challenges of refactoring C programs , 2002, IWPSE '02.

[31]  Manfred Broy,et al.  Seamless Model-Based Development: From Isolated Tools to Integrated Model Engineering Environments , 2010, Proceedings of the IEEE.

[32]  Xavier Crégut,et al.  Leveraging Formal Verification Tools for DSML Users: A Process Modeling Case Study , 2012, ISoLA.

[33]  Hans Toetenel,et al.  Embedded Software Engineering: The State of the Practice , 2003, IEEE Softw..

[34]  Luigi Palopoli,et al.  A C language extension for programming real-time applications , 1999, Proceedings Sixth International Conference on Real-Time Computing Systems and Applications. RTCSA'99 (Cat. No.PR00306).

[35]  James Cheney,et al.  Cyclone: A Safe Dialect of C , 2002, USENIX Annual Technical Conference, General Track.

[36]  Don S. Batory,et al.  Achieving Extensibility Through Product-Lines and Domain-Specific Languages: A Case Study , 2000, ICSR.

[37]  Andy Schürr,et al.  Tool Integration with Triple Graph Grammars - A Survey , 2006, FoVMT.

[38]  Ivar Jacobson,et al.  Unified Modeling Language , 2020, Definitions.

[39]  Eelco Visser,et al.  WebDSL: A Case Study in Domain-Specific Language Engineering , 2007, GTTSE.

[40]  Larry Rudolph,et al.  ParC—An Extension of C for Shared Memory Parallel Processing , 1996 .

[41]  S. Karthik,et al.  Static Analysis : C Code Error Checking for Reliable and Secure Programming , 2022 .

[42]  Chao Wang,et al.  Model checking C programs using F-Soft , 2005, 2005 International Conference on Computer Design.

[43]  K. Kavi,et al.  Software Tools Assessment , 1996, IEEE Software.

[44]  Krzysztof Czarnecki,et al.  Verifying feature-based model templates against well-formedness OCL constraints , 2006, GPCE '06.

[45]  Antoine Miné,et al.  Static Analysis of Run-Time Errors in Embedded Critical Parallel C Programs , 2011, ESOP.

[46]  Stephen Clark,et al.  Best Practices for Automated Traceability , 2007, Computer.

[47]  Zoltán Horváth,et al.  Feldspar: A domain specific language for digital signal processing algorithms , 2010, Eighth ACM/IEEE International Conference on Formal Methods and Models for Codesign (MEMOCODE 2010).

[48]  Dirk Muthig,et al.  Model-Based Design of Product Line Components in the Automotive Domain , 2008, 2008 12th International Software Product Line Conference.

[49]  Aniruddha S. Gokhale,et al.  Model driven middleware: A new paradigm for developing distributed real-time and embedded systems , 2008, Sci. Comput. Program..

[50]  Don S. Batory,et al.  Feature Models, Grammars, and Propositional Formulas , 2005, SPLC.

[51]  C. H. Lie,et al.  Fault Tree Analysis, Methods, and Applications ߝ A Review , 1985, IEEE Transactions on Reliability.

[52]  M Mernik,et al.  When and how to develop domain-specific languages , 2005, CSUR.

[53]  George S. Avrunin,et al.  Patterns in property specifications for finite-state verification , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[54]  Eelco Visser,et al.  Designing Syntax Embeddings and Assimilations for Language Libraries , 2007, MoDELS Workshops.

[55]  John C. Grundy,et al.  Supporting Generic Sketching-Based Input of Diagrams in a Domain-Specific Visual Language Meta-Tool , 2007, 29th International Conference on Software Engineering (ICSE'07).

[56]  Douglas C. Schmidt,et al.  Guest Editor's Introduction: Model-Driven Engineering , 2006, Computer.

[57]  P.J. Mosterman,et al.  Challenges for embedded software development , 2007, 2007 50th Midwest Symposium on Circuits and Systems.

[58]  William R. Cook,et al.  Safe composition of product lines , 2007, GPCE '07.

[59]  Elvinia Riccobene,et al.  Modeling the Dynamics of UML State Machines , 2000, Abstract State Machines.

[60]  Görel Hedin,et al.  JastAdd--an aspect-oriented compiler construction system , 2003, Sci. Comput. Program..

[61]  Paul Grünbacher,et al.  DOPLER: An Adaptable Tool Suite for Product Line Engineering , 2007, SPLC.

[62]  Conrad E. Bock.  UML 2 Composition Model. , 2004 .

[63]  Jane Huffman Hayes,et al.  Improving requirements tracing via information retrieval , 2003, Proceedings. 11th IEEE International Requirements Engineering Conference, 2003..

[64]  E. Riccobene,et al.  Automatic Review of Abstract State Machines by Meta Property Verification , 2010, NASA Formal Methods.

[65]  Reinhard von Hanxleden,et al.  SyncCharts in C: a proposal for light-weight, deterministic concurrency , 2009, EMSOFT '09.

[66]  Bernhard Schätz,et al.  Using Language Engineering to Lift Languages and Analyses at the Domain Level , 2013, NASA Formal Methods.

[67]  Paul Klint.  A Meta-Environment for Generating Programming Environments , 1989, Algebraic Methods.

[68]  David E. Simon,et al.  An Embedded Software Primer , 1999 .

[69]  Krzysztof Czarnecki,et al.  Feature Diagrams and Logics: There and Back Again , 2007 .

[70]  A B S T R.  Preventing Injection Attacks with Syntax Embeddings , .

[71]  Bernhard Schätz,et al.  mbeddr: an extensible C-based programming language and IDE for embedded systems , 2012, SPLASH '12.

[72]  Eelco Visser,et al.  Declarative Name Binding and Scope Rules , 2012, SLE.

[73]  David Notkin.  The GANDALF project , 1985, J. Syst. Softw..

[74]  Tijs van der Storm,et al.  RASCAL: A Domain Specific Language for Source Code Analysis and Manipulation , 2009, 2009 Ninth IEEE International Working Conference on Source Code Analysis and Manipulation.

[75]  Håkan Burden,et al.  Industrial Adoption of Model-Driven Engineering: Are the Tools Really the Problem? , 2013, MoDELS.

[76]  Michal Antkiewicz,et al.  Mapping features to models: a template approach based on superimposed variants , 2005, GPCE'05.

[77]  Paul Grünbacher,et al.  Model-Based Customization and Deployment of Eclipse-Based Tools: Industrial Experiences , 2009, 2009 IEEE/ACM International Conference on Automated Software Engineering.

[78]  Eelco Visser,et al.  Concrete syntax for objects: domain-specific language embedding and assimilation without restrictions , 2004, OOPSLA '04.

[79]  Eelco Visser,et al.  Syntax definition for language prototyping , 1997 .

[80]  Christian Kästner.  CIDE: Decomposing Legacy Applications into Features , 2007, SPLC.

[81]  Martin Törngren,et al.  A tool integration platform for multi-disciplinary development , 2005, 31st EUROMICRO Conference on Software Engineering and Advanced Applications.

[82]  Christian Kästner,et al.  Virtual Separation of Concerns: Toward Preprocessors 2.0 , 2010, it Inf. Technol..

[83]  David H. Lorenz,et al.  Cedalion: a language for language oriented programming , 2011, OOPSLA '11.

[84]  Thomas A. Henzinger,et al.  An eclipse plug-in for model checking , 2004, Proceedings. 12th IEEE International Workshop on Program Comprehension, 2004..

[85]  Eelco Visser,et al.  Stratego/XT 0.17. A language and toolset for program transformation , 2008, Sci. Comput. Program..

[86]  Manfred Broy,et al.  What is the Benefit of a Model-Based Design of Embedded Software Systems in the Car Industry? , 2012 .

[87]  Danilo Beuche,et al.  Variability management with feature models , 2004, Sci. Comput. Program..

[88]  Eelco Visser,et al.  Pure and declarative syntax definition: paradise lost and regained , 2010, OOPSLA.

[89]  J. Barrie Thompson,et al.  MetaMOOSEan object-oriented framework for the construction of CASE tools , 2000, Inf. Softw. Technol..

[90]  Matthew B. Dwyer,et al.  Bandera: extracting finite-state models from Java source code , 2000, Proceedings of the 2000 International Conference on Software Engineering. ICSE 2000 the New Millennium.

[91]  Viljem Zumer,et al.  LISA: An Interactive Environment for Programming Language Development , 2002, CC.

[92]  Juha-Pekka Tolvanen,et al.  Defining Domain-Specific Modeling Languages to Automate Product Derivation: Collected Experiences , 2005, SPLC.

[93]  Michael Jiang,et al.  Using Eclipse as a Tool-Integration Platform for Software Development , 2007, IEEE Software.

[94]  Markus Völter,et al.  Language and IDE Modularization and Composition with MPS , 2011, GTTSE.

[95]  Mark Neal,et al.  Why and how of requirements tracing , 1994, IEEE Software.

[96]  P. L. Goddard.  Software FMEA techniques , 2000, Annual Reliability and Maintainability Symposium. 2000 Proceedings. International Symposium on Product Quality and Integrity (Cat. No.00CH37055).

[97]  Kyo Chul Kang,et al.  Feature-Oriented Domain Analysis (FODA) Feasibility Study , 1990 .

[98]  Edward A. Lee.  Cyber Physical Systems: Design Challenges , 2008, 2008 11th IEEE International Symposium on Object and Component-Oriented Real-Time Distributed Computing (ISORC).

[99]  Bernhard Rumpe,et al.  Meaningful modeling: what's the semantics of "semantics"? , 2004, Computer.

[100]  Bernhard Rumpe,et al.  MontiCore: a framework for compositional development of domain specific languages , 2010, International Journal on Software Tools for Technology Transfer.

[101]  Hermann Kopetz,et al.  Real-time systems , 2018, CSC '73.

[102]  Capers Jones,et al.  Embedded Software: Facts, Figures, and Future , 2009, Computer.

[103]  Michael R. Clarkson,et al.  Polyglot: An Extensible Compiler Framework for Java , 2003, CC.

[104]  Shigeru Chiba,et al.  OpenJava: A Class-Based Macro System for Java , 1999, Reflection and Software Engineering.

[105]  Federico Tomassetti,et al.  Extracting variability from C and lifting it to mbeddr , 2013 .

[106]  David Harel,et al.  Statecharts: A Visual Formalism for Complex Systems , 1987, Sci. Comput. Program..

[107]  Jens von Pilgrim,et al.  A survey of traceability in requirements engineering and model-driven development , 2010, Software & Systems Modeling.

[108]  Robert Bruce Findler,et al.  Scribble: closing the book on ad hoc documentation tools , 2009, ICFP.

[109]  Marie-Pierre Gervais,et al.  Model Bus: Towards the Interoperability of Modelling Tools , 2003, MDAFA.

[110]  Russell W. Quong,et al.  ANTLR: A predicated‐LL(k) parser generator , 1995, Softw. Pract. Exp..

[111]  Mario Kolberg,et al.  Feature interaction: a critical review and considered forecast , 2003, Comput. Networks.

[112]  Juha-Pekka Tolvanen,et al.  MetaEdit+: defining and using integrated domain-specific modeling languages , 2009, OOPSLA Companion.

[113]  Holger Giese,et al.  Tool integration at the meta-model level: the Fujaba approach , 2004, International Journal on Software Tools for Technology Transfer.

[114]  Wilhelm Hasselbring,et al.  Xbase: implementing domain-specific languages for Java , 2012, GPCE '12.

[115]  Mihalis Yannakakis,et al.  Hierarchical State Machines , 2000, IFIP TCS.

[116]  Mark van den Brand,et al.  Repleo: a syntax-safe template engine , 2007, GPCE '07.

[117]  Lidia Fuentes,et al.  Language Support for Managing Variability in Architectural Models , 2008, SC@ETAPS.

[118]  Eddie Kohler,et al.  Xoc, an extension-oriented compiler for systems programming , 2008, ASPLOS.

[119]  Markus Völter.  Integrating Prose as First-Class Citizens with Models and Code , 2013, MPM@MoDELS.

[120]  Miro Samek,et al.  Practical statecharts in C/C++: Quantum programming for embedded systems , 2002 .

[121]  Daniel Kroening,et al.  A Tool for Checking ANSI-C Programs , 2004, TACAS.

[122]  Charles Simonyi,et al.  Intentional software , 2006, OOPSLA '06.

[123]  Zaur Molotnikov,et al.  Implementing modular domain specific languages and analyses , 2012, MoDeVVa '12.

[124]  Armand Puccetti,et al.  Static Analysis of the XEN Kernel using Frama-C , 2010, J. Univers. Comput. Sci..

[125]  Sriram K. Rajamani,et al.  SLAM and Static Driver Verifier: Technology Transfer of Formal Methods inside Microsoft , 2004, IFM.

[126]  Andrew J. McCarthy,et al.  A Middleware Framework for Constraint-Based Deployment and Autonomic Management of Distributed Applications , 2010, ArXiv.

[127]  Mark Lawford,et al.  A Tabular Expression Toolbox for Matlab/Simulink , 2011, NASA Formal Methods.

[128]  Eric Van Wyk,et al.  Attribute Grammar-Based Language Extensions for Java , 2007, ECOOP.

[129]  Markus Völter,et al.  Embedded software development with projectional language workbenches , 2010, MODELS'10.

[130]  Scott Wilkin. Porter.  Design of a syntax directed editor for PSDL. , 1988 .

[131]  B. J. Ferro Castro,et al.  Pattern-Oriented Software Architecture: A System of Patterns , 2009 .

[132]  David Lorge Parnas,et al.  Tabular Representations in Relational Documents , 1997, Relational Methods in Computer Science.

[133]  Krzysztof Czarnecki,et al.  SAT-based analysis of feature models is easy , 2009, SPLC.

[134]  T. Reiter,et al.  Towards a semantic infrastructure supporting model-based tool integration , 2006, GaMMa '06.

[135]  Anthony L Wasserman.  Tool Integration in Software Engineering Environments , 1989, SEE.

[136]  Eric Van Wyk,et al.  Building Extensible Specifications and Implementations of Promela with AbleP , 2011, SPIN.

[137]  Sebastian Erdweg,et al.  Language composition untangled , 2012, LDTA.

[138]  Peyman Oreizy,et al.  xADL: enabling architecture-centric tool integration with XML , 2001, Proceedings of the 34th Annual Hawaii International Conference on System Sciences.

[139]  Ira D. Baxter,et al.  Preprocessor conditional removal by simple partial evaluation , 2001, Proceedings Eighth Working Conference on Reverse Engineering.

[140]  Georg Rock,et al.  A Custom Approach for Variability Management in Automotive Applications , 2010, VaMoS.

[141]  Edmund M. Clarke,et al.  Symbolic Model Checking: 10^20 States and Beyond , 1990, Inf. Comput..

[142]  Benoît Combemale,et al.  A Generic Tool for Tracing Executions Back to a DSML's Operational Semantics , 2011, ECMFA.

[143]  Alan W. Brown.  Component-Based Software Engineering: Selected Papers from the Software Engineering Institute , 1996 .

[144]  Dawson R. Engler,et al.  RacerX: effective, static detection of race conditions and deadlocks , 2003, SOSP '03.

[145]  Eelco Visser,et al.  Declaratively programming the mobile web with Mobl , 2011, OOPSLA '11.

[146]  Eric Van Wyk,et al.  Forwarding in Attribute Grammars for Modular Language Design , 2002, CC.

[147]  Laurence Tratt,et al.  Model transformations and tool integration , 2005, Software & Systems Modeling.

[148]  Danilo Beuche,et al.  Managing Flexibility: Modeling Binding-Times in Simulink , 2009, ECMDA-FA.

[149]  Thomas Leich,et al.  TypeChef: toward type checking #ifdef variability in C , 2010, FOSD '10.

[150]  Bertrand Meyer,et al.  Applying 'design by contract' , 1992, Computer.

[151]  Mohd Fadzil Hassan,et al.  Model driven software development: An overview , 2014, 2014 International Conference on Computer and Information Sciences (ICCOINS).

[152]  Partha S. Roop,et al.  Predictable multithreading of embedded applications using PRET-C , 2010, Eighth ACM/IEEE International Conference on Formal Methods and Models for Codesign (MEMOCODE 2010).

[153]  Oscar Nierstrasz,et al.  Embedding Languages without Breaking Tools , 2010, ECOOP.

[154]  Muneeb Ali,et al.  Protothreads: simplifying event-driven programming of memory-constrained embedded systems , 2006, SenSys '06.

[155]  Constance L. Heitmeyer,et al.  Developing safety-critical systems: the role of formal methods and tools , 2006 .

[156]  Markus Völter,et al.  Requirements as First-Class Citizens: Integrating Requirements closely with Implementation Artifacts , 2013, ACESMB@MoDELS.

[157]  Bruce Powel Douglass,et al.  Design Patterns for Embedded Systems in C: An Embedded Software Engineering Toolkit , 2010 .

[158]  Lidia Fuentes-Fernández,et al.  An Introduction to UML Profiles , 2004 .

[159]  Jeannette M. Wing,et al.  A behavioral notion of subtyping , 1994, TOPL.

[160]  Robert V. Binder,et al.  Testing Object-Oriented Software , 1997, TOOLS.

[161]  Eelco Visser,et al.  Growing a language environment with editor libraries , 2011, GPCE '11.

[162]  Edmund M. Clarke,et al.  Modular Translation of Statecharts to SMV , 2000 .

[163]  P. L. Goddard.  Validating the safety of embedded real-time control systems using FMEA , 1993, Annual Reliability and Maintainability Symposium 1993 Proceedings.

[164]  Guy L. Steele,et al.  Growing a Language , 1999, High. Order Symb. Comput..

[165]  Eelco Visser,et al.  DSL Engineering - Designing, Implementing and Using Domain-Specific Languages , 2013 .

[166]  Stephan Merz,et al.  Model Checking , 2000 .

[167]  Eelco Visser,et al.  The State of the Art in Language Workbenches - Conclusions from the Language Workbench Challenge , 2013, SLE.

[168]  Tobias Rötschke,et al.  Metamodel-based tool integration with moflon , 2008, 2008 ACM/IEEE 30th International Conference on Software Engineering.

[169]  Jonathan Bachrach,et al.  The Java syntactic extender (JSE) , 2001, OOPSLA '01.

[170]  Sebastian Erdweg,et al.  SugarJ: library-based syntactic language extensibility , 2011, OOPSLA '11.

[171]  Peter H. Feiler,et al.  An Incremental Programming Environment , 1981, IEEE Transactions on Software Engineering.

[172]  Donald E. Knuth,et al.  Literate Programming , 1984, Comput. J..

[173]  Edward A. Lee,et al.  What's Ahead for Embedded Software? , 2000, Computer.

[174]  Timo Kehrer,et al.  Extensible Debuggers for Extensible Languages , 2013, Softwaretechnik-Trends.

[175]  Eelco Visser,et al.  Generalized type-based disambiguation of meta programs with concrete object syntax , 2005, GPCE'05.

[176]  Alan W. Brown.  Control integration through message-passing in a software development environment , 1993, Softw. Eng. J..

[177]  Eric Van Wyk,et al.  Silver: an Extensible Attribute Grammar System , 2008, Electron. Notes Theor. Comput. Sci..