Publikationsserver der Universitätsbibliothek Marburg

Titel:Extensible Languages for Flexible and Principled Domain Abstraction
Autor:Sebastian Erdweg
Weitere Beteiligte: Ostermann, Klaus (Prof. Dr.)
Veröffentlicht:2013
URI:https://archiv.ub.uni-marburg.de/diss/z2013/0280
DOI: https://doi.org/10.17192/z2013.0280
URN: urn:nbn:de:hebis:04-z2013-02808
DDC: Informatik
Publikationsdatum:2013-05-23
Lizenz:https://rightsstatements.org/vocab/InC-NC/1.0/

Dokument

Schlagwörter:
Parsing, Domain-specific language, Program transformation, Extensible programming language, Programmiersprache, Software ,, Domänenspezifische Programmiersprache, Erweiterbare Programmiersprache, Programmtransformation, Syntaktische Analyse

Zusammenfassung:
Die meisten Programmiersprachen werden als Universalsprachen entworfen. Unabhängig von der zu entwickelnden Anwendung, stellen sie die gleichen Sprachfeatures und Sprachkonstrukte zur Verfügung. Solch universelle Sprachfeatures ignorieren jedoch die spezifischen Anforderungen, die viele Softwareprojekte mit sich bringen. Als Gegenkraft zu Universalsprachen fördern domänenspezifische Programmiersprachen, modellgetriebene Softwareentwicklung und sprachorientierte Programmierung die Verwendung von Domänenabstraktion, welche den Einsatz von domänenspezifischen Sprachfeatures und Sprachkonstrukten ermöglicht. Insbesondere erlaubt Domänenabstraktion Programmieren auf dem selben Abstraktionsniveau zu programmieren wie zu denken und vermeidet dadurch die Notwendigkeit Domänenkonzepte mit universalsprachlichen Features zu kodieren. Leider ermöglichen aktuelle Ansätze zur Domänenabstraktion nicht die Entfaltung ihres ganzen Potentials. Einerseits mangelt es den Ansätzen für interne domänenspezifische Sprachen an Flexibilität bezüglich der Syntax, statischer Analysen, und Werkzeugunterstützung, was das tatsächlich erreichte Abstraktionsniveau beschränkt. Andererseits mangelt es den Ansätzen für externe domänenspezifische Sprachen an wichtigen Prinzipien, wie beispielsweise modularem Schließen oder Komposition von Domänenabstraktionen, was die Anwendbarkeit dieser Ansätze in der Entwicklung größerer Softwaresysteme einschränkt. Wir verfolgen in der vorliegenden Doktorarbeit einen neuartigen Ansatz, welcher die Vorteile von internen und externen domänenspezifischen Sprachen vereint um flexible und prinzipientreue Domänenabstraktion zu unterstützen. Wir schlagen bibliotheksbasierte erweiterbare Programmiersprachen als Grundlage für Domänenabstraktion vor. In einer erweiterbaren Sprache kann Domänenabstraktion durch die Erweiterung der Sprache mit domänenspezifischer Syntax, statischer Analyse, und Werkzeugunterstützung erreicht werden . Dies ermöglicht Domänenabstraktionen die selbe Flexibilität wie externe domänenspezifische Sprachen. Um die Einhaltung üblicher Prinzipien zu gewährleisten, organisieren wir Spracherweiterungen als Bibliotheken und verwenden einfache Import-Anweisungen zur Aktivierung von Erweiterungen. Dies erlaubt modulares Schließen (durch die Inspektion der Import-Anweisungen), unterstützt die Komposition von Domänenabstraktionen (durch das Importieren mehrerer Erweiterungen), und ermöglicht die uniforme Selbstanwendbarkeit von Spracherweiterungen in der Entwicklung zukünftiger Erweiterungen (durch das Importieren von Erweiterungen in einer Erweiterungsdefinition). Die Organisation von Erweiterungen in Form von Bibliotheken ermöglicht Domänenabstraktionen die selbe Prinzipientreue wie interne domänenspezifische Sprachen. Wir haben die bibliotheksbasierte erweiterbare Programmiersprache SugarJ entworfen und implementiert. SugarJ Bibliotheken können Erweiterungen der Syntax, der statischen Analyse, und der Werkzeugunterstützung von SugarJ deklarieren. Eine syntaktische Erweiterung besteht dabei aus einer erweiterten Syntax und einer Transformation der erweiterten Syntax in die Basissyntax von SugarJ. Eine Erweiterung der Analyse testet Teile des abstrakten Syntaxbaums der aktuellen Datei und produziert eine Liste von Fehlern. Eine Erweiterung der Werkzeugunterstützung deklariert Dienste wie Syntaxfärbung oder Codevervollständigung für bestimmte Sprachkonstrukte. SugarJ Erweiterungen sind vollkommen selbstanwendbar: Eine erweiterte Syntax kann in eine Erweiterungsdefinition transformiert werden, eine erweiterte Analyse kann Erweiterungsdefinitionen testen, und eine erweiterte Werkzeugunterstützung kann Entwicklern beim Definieren von Erweiterungen assistieren. Um eine Quelldatei mit Erweiterungen zu verarbeiten, inspizieren der SugarJ Compiler und die SugarJ IDE die importierten Bibliotheken um die aktiven Erweiterungen zu bestimmen. Der Compiler und die IDE adaptieren den Parser, den Codegenerator, die Analyseroutine und die Werkzeugunterstützung der Quelldatei entsprechend der aktiven Erweiterungen. Wir beschreiben in der vorliegenden Doktorarbeit nicht nur das Design und die Implementierung von SugarJ, sondern berichten darüber hinaus über Erweiterungen unseres ursprünglich Designs. Insbesondere haben wir eine Generalisierung des SugarJ Compilers entworfen und implementiert, die neben Java alternative Basissprachen unterstützt. Wir haben diese Generalisierung verwendet um die bibliotheksbasierten erweiterbaren Programmiersprachen SugarHaskell, SugarProlog, und SugarFomega zu entwickeln. Weiterhin haben wir SugarJ ergänzt um polymorphe Domänenabstraktion und Kommunikationsintegrität zu unterstützen. Polymorphe Domänenabstraktion ermöglicht Programmierern mehrere Transformationen für die selbe domänenspezifische Syntax bereitzustellen. Dies erhöht die Flexibilität von SugarJ und unterstützt bekannte Szenarien aus der modellgetriebenen Entwicklung. Kommunikationsintegrität spezifiziert, dass die Komponenten eines Softwaresystems nur über explizite Kanäle kommunizieren dürfen. Im Kontext von Codegenerierung stellt dies eine interessante Eigenschaft dar, welche die Generierung von impliziten Modulabhängigkeiten untersagt. Wir haben Kommunikationsintegrität als weiteres Prinzip zu SugarJ hinzugefügt. Basierend auf SugarJ und zahlreicher Fallstudien argumentieren wir, dass flexible und prinzipientreue Domänenabstraktion ein skalierbares Programmiermodell für die Entwicklung komplexer Softwaresysteme darstellt.

Summary:
Most programming languages are designed for general-purpose software development in a one-size-fits-all fashion: They provide the same set of language features and constructs for all possible applications programmers ever may want to develop. As with shoes, the one-size-fits-all solution grants a good fit to few applications only. The trend toward domain-specific languages, model-driven development, and language-oriented programming counters general-purpose languages by promoting the use of domain abstractions that facilitate domain-specific language features and constructs tailored to certain application domains. In particular, domain abstraction avoids the need for encoding domain concepts with general-purpose language features and thus allows programmers to program at the same abstraction level as they think. Unfortunately, current approaches to domain abstraction cannot deliver on the promises of domain abstraction. On the one hand, approaches that target internal domain-specific languages lack flexibility regarding the syntax, static checking, and tool support of domain abstractions, which limits the level of actually achieved domain abstraction. On the other hand, approaches that target external domain-specific languages lack important principles, such as modular reasoning and composition of domain abstractions, which inhibits the applicability of these approaches in the development of larger software systems. In this thesis, we pursue a novel approach that unifies the advantages of internal and external domain-specific languages to support flexible and principled domain abstraction. We propose library-based extensible programming languages as a basis for domain abstraction. In an extensible language, domain abstraction can be realized by extending the language with domain-specific syntax, static analysis, and tool support. This enables domain abstractions as flexible as external domain-specific languages. To ensure the compliance with important software-development principles, we organize language extensions as libraries and use simple import statements to activate extensions. This facilitates modular reasoning (by inspecting import statements), supports the composition of domain abstractions (by importing multiple extensions), and allows uniform self-application of language extensions in the development of further extensions (by importing extensions in an extension definition). A library-based organization of extensions enables domain abstractions as principled as internal domain-specific languages. We designed and implemented SugarJ, a library-based extensible programming language on top of Java. SugarJ libraries can declare and export extensions of SugarJ's syntax, static analysis, and editor support. Thereby, a syntactic extension consists of an extended syntax and a desugaring transformation from the extended syntax into SugarJ base syntax, an analysis extension matches on part of the current file's abstract syntax tree and produces a list of errors, and an editor extension declares editor services such as coloring or code completion for certain language constructs. SugarJ extensions are fully self-applicable: An extended syntax can desugar into the declaration of another extensions, an extended analysis can check the declaration of an extension, and an extended editor can assist developers in writing extensions. To process a source file with extensions, the SugarJ compiler and IDE inspect the imported libraries to determine active extensions. The compiler and IDE adapt the parser, code generator, analyzer, and editor of the source file according to the active extensions. In this thesis, we do not only describe the design and implementation of SugarJ, but also report on extensions of the original design. In particular, we designed and implemented a generalization of the SugarJ compiler that supports alternative base languages besides Java. Using this generalization, we developed the library-based extensible programming languages SugarHaskell, SugarProlog, and SugarFomega. Furthermore, we developed an extension of SugarJ that supports polymorphic domain abstraction and ensures communication integrity. Polymorphic domain abstraction enables programmers to provide multiple desugarings for the same domain-specific syntax. This increases the flexibility of SugarJ and supports scenarios known from model-driven development. Communication integrity specifies that components of a software system may communicate over explicit channels only. This is interesting in the context of code generation where it effectively prohibits the generation of implicit module dependencies. We augmented SugarJ's principles by enforcing communication integrity. On the basis of SugarJ and numerous case studies, we argue that flexible and principled domain abstraction constitutes a scalable programming model for the development of complex software systems.

Bibliographie / References

  1. Sean McDirmid and Martin Odersky. The Scala plugin for Eclipse. In Proceedings of Workshop on Eclipse Technology eXchange (ETX), 2006. Published online http://atlanmod.emn.fr/www/ papers/eTX2006/.
  2. Dave Steinberg, Frank Budinsky, Marcelo Paternostro, and Ed Merks. EMF: Eclipse Modeling Framework (2nd Edition).
  3. Paul J. Layzell. The history of macro processors in programming language extensibility. The Computer Journal, 28(1):29–33, 1985. [Lea66] B. M. Leavenworth. Syntax macros and extended translation. Communications of the ACM, 9:790–793, 1966. [LHB01] Roberto Lopez-Herrejon and Don Batory. A standard problem for evaluating product-line methodologies. In Proceedings of Confer- ence on Generative and Component-Based Software Engineering (GCSE), volume 2186 of LNCS, pages 10–24. Springer, 2001. [LKA11]
  4. Torbjörn Ekman and Görel Hedin. The JastAdd extensible Java compiler. In Proceedings of Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 1–18. ACM, 2007. [EH07b]
  5. Laurence Tratt. Domain specific language implementation via compile-time meta-programming. Transactions on Programming Languages and Systems (TOPLAS), 30(6):1–40, 2008. [VBGK10]
  6. Paul Klint. A meta-environment for generating programming environments. Transactions on Software Engineering Methodology (TOSEM), 2(2):176–201, 1993.
  7. August Schwerdfeger and Eric Van Wyk. Verifiable composition of deterministic grammars. In Proceedings of Conference on Pro- gramming Language Design and Implementation (PLDI), pages 199–210. ACM, 2009.
  8. Jörg Liebig, Christian Kästner, and Sven Apel. Analyzing the discipline of preprocessor annotations in 30 million lines of C code. In Proceedings of Conference on Aspect-Oriented Software Development (AOSD), pages 191–202. ACM, 2011. [LM01]
  9. [THSAC + 11] Sam Tobin-Hochstadt, Vincent St-Amour, Ryan Culpepper, Matthew Flatt, and Matthias Felleisen. Languages as libraries. In Proceedings of Conference on Programming Language Design and Implementation (PLDI), pages 132–141. ACM, 2011. [Tom87]
  10. Luis Pedro, Matteo Risoldi, Didier Buchs, and Vasco Amaral. Developing domain-specific modeling languages by metamodel semantic enrichment and composition: A case study. In Proceed- ings of Workshop on Domain-Specific Modeling (DSM), pages 16:1–16:6. ACM, 2010. [Pri05]
  11. Jonathan Bachrach and Keith Playford. The Java syntactic extender (JSE). In Proceedings of Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 31–42. ACM, 2001. [Bra04]
  12. Bryan Ford. Parsing expression grammars: A recognition-based syntactic foundation. In Proceedings of Symposium on Principles of Programming Languages (POPL), pages 111–122. ACM, 2004. BIBLIOGRAPHY [Fow05a]
  13. Daan Leijen and Erik Meijer. Parsec: Direct style monadic parser combinators for the real world. Technical Report UU-CS-2001-27, Universiteit Utrecht, 2001.
  14. Conor McBride. Epigram: Practical programming with dependent types. In Advanced Functional Programming, volume 3622 of LNCS, pages 130–170. Springer, 2004. [McC60]
  15. Martin Bravenboer, Rob Vermaas, Jurgen J. Vinju, and Eelco Visser. Generalized type-based disambiguation of meta programs with concrete object syntax. In Proceedings of Conference on Generative Programming and Component Engineering (GPCE), volume 3676 of LNCS, pages 157–172. Springer, 2005. [Car97]
  16. [vdBvDH + 01] Mark van den Brand, A. van Deursen, J. Heering, HA De Jong, et al. The ASF+SDF Meta-Environment: A component-based language development environment. In Proceedings of Conference on Compiler Construction (CC), volume 2027 of LNCS, pages 365–370. Springer, 2001. [vDK98]
  17. Eelco Visser. Meta-programming with concrete object syntax. In Proceedings of Conference on Generative Programming and Component Engineering (GPCE), volume 2487 of LNCS, pages 299–315. Springer, 2002.
  18. Torbjörn Ekman and Görel Hedin. Rewritable reference at- tributed grammars. In Proceedings of European Conference on Object-Oriented Programming (ECOOP), volume 3086 of LNCS, pages 144–169. Springer, 2004. [EH07a]
  19. Roland Axelsson, Keijo Heljanko, and Martin Lange. Analyzing context-free grammars using an incremental SAT solver. In Proceedings of International Colloquium on Automata, Languages and Programming (ICALP), volume 5125 of LNCS, pages 410–422. Springer, 2008.
  20. Sylvain Schmitz. Conservative ambiguity detection in context- free grammars. In Proceedings of International Colloquium on Automata, Languages and Programming (ICALP), volume 4596 of LNCS, pages 692–703. Springer, 2007.
  21. Eric Van Wyk, Lijesh Krishnan, Derek Bodin, and August Schw- erdfeger. Attribute grammar-based language extensions for Java. In Proceedings of European Conference on Object-Oriented Pro- gramming (ECOOP), volume 4609 of LNCS, pages 575–599. Springer, 2007.
  22. [HJK + 09] Florian Heidenreich, Jendrik Johannes, Sven Karol, Mirko Seifert, and Christian Wende. Derivation and refinement of textual syntax for models. In Proceedings of European Conference on Model BIBLIOGRAPHY Driven Architecture – Foundations and Applications (ECMDA- FA), volume 5562 of LNCS, pages 114–129. Springer, 2009. [HJSW09]
  23. Bruno C. Oliveira. Modular visitor components. In Proceedings of European Conference on Object-Oriented Programming (ECOOP), volume 5653 of LNCS, pages 269–293. Springer, 2009. [Pat01]
  24. Lukas Renggli, Tudor Gîrba, and Oscar Nierstrasz. Embedding languages without breaking tools. In Proceedings of European Conference on Object-Oriented Programming (ECOOP), volume 6183 of LNCS, pages 380–404. Springer, 2010. [Rie12]
  25. Markus Völter. Embedded software development with projec- tional language workbenches. In Proceedings of Conference on Model Driven Engineering Languages and Systems (MoDELS), volume 6395 of LNCS, pages 32–46. Springer, 2010. BIBLIOGRAPHY [Völ11]
  26. Ole Lehrmann Madsen and Birger Møller-Pedersen. A unified approach to modeling and programming. In Proceedings of Con- ference on Model Driven Engineering Languages and Systems (MoDELS), volume 6394 of LNCS, pages 1–15. Springer, 2010. [MO06]
  27. Sebastian Erdweg and Klaus Ostermann. Featherweight TeX and parser correctness. In Proceedings of Conference on Software Language Engineering (SLE), volume 6563 of LNCS, pages 397– 416. Springer, 2010.
  28. Klaus Ostermann, Paolo G. Giarrusso, Christian Kästner, and Tillmann Rendel. Revisiting information hiding: Reflections on classical and nonclassical modularity. In Proceedings of European Conference on Object-Oriented Programming (ECOOP), volume 6813 of LNCS, pages 155–178. Springer, 2011. [Oli09]
  29. [ERKO12] Sebastian Erdweg, Tillmann Rendel, Christian Kästner, and Klaus Ostermann. Layout-sensitive generalized parsing. In Pro- ceedings of Conference on Software Language Engineering (SLE), volume 7745 of LNCS, pages 244–263. Springer, 2012.
  30. Gabriël D. P. Konat, Lennart C. L. Kats, Guido Wachsmuth, and Eelco Visser. Declarative name binding and scope rules. BIBLIOGRAPHY In Proceedings of Conference on Software Language Engineering (SLE), volume 7745 of LNCS, pages 311–331. Springer, 2012. [Kli93]
  31. Ted Kaminski and Eric Van Wyk. Modular well-definedness analysis for attribute grammars. In Proceedings of Conference on Software Language Engineering (SLE), volume 7745 of LNCS, pages 352–371. Springer, 2012.
  32. [KMC12] Tomaz Kosar, Marjan Mernik, and Jeffrey C. Carver. Program comprehension of domain-specific and general-purpose languages: Comparison using a family of experiments. Empirical Software Engineering, 17(3):276–304, 2012.
  33. G. Kiczales, J. Des Rivieres, and D.G. Bobrow. The art of the metaobject protocol. MIT press, 1991. [Ken02]
  34. Torbjörn Ekman and Görel Hedin. The JastAdd system -modular extensible compiler construction. Science of Computer Program- ming, 69(1-3):14–26, 2007.
  35. Martin Bravenboer, Eelco Dolstra, and Eelco Visser. Preventing injection attacks with syntax embeddings. Science of Computer Programming, 75(7):473–495, 2010. [Ben86]
  36. Eric Van Wyk, Derek Bodin, Jimin Gao, and Lijesh Krishnan. Silver: An extensible attribute grammar system. Science of Computer Programming, 75(1-2):39–54, 2010.
  37. Diomidis Spinellis. Notable design patterns for domain-specific languages. Systems and Software, 56(1):91–99, 2001. BIBLIOGRAPHY [Ste99]
  38. [CKMRM03] Muffy Calder, Mario Kolberg, Evan H. Magill, and Stephan Reiff- Marganiec. Feature interaction: A critical review and considered forecast. Computer Networks, 41(1):115–141, 2003. [CKS09]
  39. Robert B. France and Bernhard Rumpe. Model-driven develop- ment of complex software: A research roadmap. In Proceedings of Workshop on Future of Software Engineering (FOSE), pages 37–54. ACM, 2007.
  40. [KTS + 09] Christian Kästner, Thomas Thüm, Gunter Saake, Janet Feigenspan, Thomas Leich, Fabian Wielgorz, and Sven Apel. FeatureIDE: Tool framework for feature-oriented software devel- opment. In Proceedings of International Conference on Software Engineering (ICSE), pages 611–614. IEEE, 2009. [KV10]
  41. Paul Hudak. Modular domain specific languages and tools. In Pro- ceedings of International Conference on Software Reuse (ICSR), pages 134–142. IEEE, 1998. [Hug00]
  42. D. Batory, B. Lofaso, and Y. Smaragdakis. JTS: Tools for im- plementing domain-specific languages. In Proceedings of Inter- national Conference on Software Reuse (ICSR), pages 143–153. IEEE, 1998.
  43. Frederick P. Brooks, Jr. No silver bullet: Essence and accidents of software engineering. Computer, 20(4):10–19, 1987.
  44. Jules White, James H. Hill, Jeff Gray, Sumant Tambe, Anirud- dha S. Gokhale, and Douglas C. Schmidt. Improving domain- specific language reuse with software product line techniques. IEEE Software, 26(4):47–53, 2009.
  45. Martin P. Robillard, Wesley Coelho, and Gail C. Murphy. How effective developers investigate source code: An exploratory study. Transactions on Software Engineering (TSE), 30(12):889–903, 2004.
  46. Ivan Kurtev, Jean Bézivin, Frédéric Jouault, and Patrick Val- duriez. Model-based DSL frameworks. In Companion to Confer- ence on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 602–616. ACM, 2006.
  47. Atze Dijkstra, Jeroen Fokker, and S. Doaitse Swierstra. The architecture of the Utrecht Haskell compiler. In Proceedings of Haskell Symposium, pages 93–104. ACM, 2009. BIBLIOGRAPHY [DHB92] R. Kent Dybvig, Robert Hieb, and Carl Bruggeman. Syntactic abstraction in scheme. Lisp and Symbolic Computation, 5(4):295– 326, 1992.
  48. Trevor Jim, Yitzhak Mandelbaum, and David Walker. Semantics and algorithms for data-dependent grammars. In Proceedings of Symposium on Principles of Programming Languages (POPL), pages 417–430. ACM, 2010.
  49. Karl Klose and Klaus Ostermann. Modular logic metaprogram- ming. In Proceedings of Conference on Object-Oriented Program- ming, Systems, Languages, and Applications (OOPSLA), pages 484–503. ACM, 2010.
  50. [HO10] Christian Hofer and Klaus Ostermann. Modular domain-specific language components in Scala. In Proceedings of Conference on Generative Programming and Component Engineering (GPCE), pages 83–92. ACM, 2010.
  51. [EKR + 11a] Sebastian Erdweg, Lennart C. L. Kats, Tillmann Rendel, Chris- tian Kästner, Klaus Ostermann, and Eelco Visser. Growing a BIBLIOGRAPHY language environment with editor libraries. In Proceedings of Con- ference on Generative Programming and Component Engineering (GPCE), pages 167–176. ACM, 2011.
  52. [EKR + 11b] Sebastian Erdweg, Lennart C. L. Kats, Tillmann Rendel, Chris- tian Kästner, Klaus Ostermann, and Eelco Visser. Library-based model-driven software development with SugarJ. In Compan- ion to Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 17–18. ACM, 2011.
  53. [KATS12] Christian Kästner, Sven Apel, Thomas Thüm, and Gunter Saake. Type checking annotation-based product lines. Transactions on Software Engineering Methodology (TOSEM), 21(3):14:1–14:39, 2012.
  54. Sebastian Erdweg, Felix Rieger, Tillmann Rendel, and Klaus Ostermann. Layout-sensitive language extensibility with Sugar- Haskell. In Proceedings of Haskell Symposium, pages 149–160. ACM, 2012.
  55. Sebastian Erdweg, Paolo G. Giarrusso, and Tillmann Rendel. Language composition untangled. In Proceedings of Workshop on Language Descriptions, Tools and Applications (LDTA), pages 7:1–7:8. ACM, 2012.
  56. Eugene Kohlbecker, Daniel P. Friedman, Matthias Felleisen, and Bruce Duba. Hygienic macro expansion. In Proceedings of Confer- ence on LISP and Functional Programming (LFP), pages 151–161. ACM, 1986.
  57. Ross Paterson. A new notation for arrows. In Proceedings of International Conference on Functional Programming (ICFP), pages 229–240. ACM, 2001.
  58. J. Katzenelson and E. Milgrom. A short presentation of the main features of AEPL -An extensible programming language. In Proceedings of International Symposium on Extensible Languages, pages 23–25. ACM, 1971.
  59. [HHS03] Bastiaan Heeren, Jurriaan Hage, and S. Doaitse Swierstra. Script- ing the type inference process. In Proceedings of International Conference on Functional Programming (ICFP), pages 3–13. ACM, 2003.
  60. [KOM + 10] Tomaz Kosar, Nuno Oliveira, Marjan Mernik, Maria João Varanda Pereira, Matej Crepinsek, Daniela Carneiro da Cruz, and Pedro Rangel Henriques. Comparing general-purpose and domain-specific languages: An empirical study. Computer Science and Information Systems, 7(2):247–264, 2010. [Kri06]
  61. Peter D. Mosses. Modular structural operational semantics. Logic and Algebraic Programming, 60-61:195–228, 2004. [MP08]
  62. Claus Brabrand and Michael I. Schwartzbach. Growing languages with metamorphic syntax macros. In Proceedings of Workshop on Partial Evaluation and Program Manipulation (PEPM), pages 31–40. ACM, 2002.
  63. [EV06] S. Efftinge and M. Völter. oAW xText: A framework for textual DSLs. In Workshop on Modeling Symposium at Eclipse Summit, 2006.
  64. Felix Rieger. A language-independent framework for syntactic extensibility. Bachelor's Thesis, University of Marburg, June 2012. BIBLIOGRAPHY [RMHP06] Damijan Rebernak, Marjan Mernik, Pedro Rangel Henriques, and Maria João Varanda Pereira. AspectLISA: An aspect-oriented compiler construction system based on attribute grammars. Elec- tronic Notes in Theoretical Computer Science, 164(2):37–53, 2006. [SBPM08]
  65. Daqing Hou and Yuejiao Wang. Analyzing the evolution of user-visible features: A case study with Eclipse. In Proceedings of International Conference on Software Maintenance (ICSM), pages 479–482. IEEE, 2009. BIBLIOGRAPHY [JBK06] Frédéric Jouault, Jean Bézivin, and Ivan Kurtev. TCS: A DSL for the specification of textual concrete syntaxes in model engineering. In Proceedings of Conference on Generative Programming and Component Engineering (GPCE), pages 249–254. ACM, 2006.
  66. Neal Gafter and Peter von der Ahé. Closures for Java. Available at http://javac.info/closures-v06a.html, 2009. [HHPW07]
  67. Steffen Priebe. Preprocessing Eden with Template Haskell. In Proceedings of Conference on Generative Programming and Com- ponent Engineering (GPCE), pages 357–372. Springer, 2005.
  68. Jean Bézivin. On the unification power of models. Software and System Modeling, 4(2):171–188, 2005.
  69. Felienne Hermans, Martin Pinzger, and Arie van Deursen. Domain-specific languages in practice: A user study on the success factors. In Proceedings of Conference on Model Driven Engineer- ing Languages and Systems (MoDELS), volume 5795 of LNCS, pages 423–437. Springer, 2009. [Hud98]
  70. Lukas Renggli, Stéphane Ducasse, Tudor Gîrba, and Oscar Nier- strasz. Domain-specific program checking. In Proceedings of Conference on Technology of Object-oriented Languages and Sys- tems (TOOLS), volume 6141 of LNCS, pages 213–232. Springer, 2010.
  71. Paul Hudak, John Hughes, Simon Peyton Jones, and Philip Wadler. A history of Haskell: Being lazy with class. In Proceedings of Conference on History of Programming Languages (HOPL), pages 1–55. ACM, 2007.
  72. Masaru Tomita. An efficient augmented-context-free parsing algorithm. Computational Linguistics, 13(1-2):31–46, 1987. [Tra08]
  73. David C. Luckham and James Vera. An event-based architecture definition language. Transactions on Software Engineering (TSE), 21(9):717–734, 1995.
  74. Adrian Kuhn, Gail C. Murphy, and C. Albert Thompson. An exploratory study of forces and frictions affecting large-scale model-driven development. In Proceedings of Conference on Model Driven Engineering Languages and Systems (MoDELS), volume 7590 of LNCS, pages 352–367. Springer, 2012. [Knu68]
  75. Anders Møller and Michael I. Schwartzbach. An Introduction to XML and Web Technologies. Addison-Wesley, 2006. BIBLIOGRAPHY [MTR05]
  76. Sven Apel and Christian Kästner. An overview of feature-oriented software development. Object Technology, 8(5):49–84, 2009. [AYT09] Takahito Aoto, Junichi Yoshida, and Yoshihito Toyama. Proving confluence of term rewriting systems automatically. In Proceedings of Conference on Rewriting Techniques and Applications (RTA), volume 5595 of LNCS, pages 93–102. Springer, 2009. [BA99]
  77. Terence Parr and Russell W. Quong. ANTLR: A predicated-LL(k) parser generator. Software Practice and Experience, 25(7):789– 810, 1995. BIBLIOGRAPHY [PRBA10]
  78. Conor McBride and Ross Paterson. Applicative programming with effects. Functional Programming, 18(1):1–13, 2008.
  79. Chris Seaton. A programming language where the syntax and semantics are mutable at runtime. Master's thesis, University of Bristol, 2007.
  80. Jonathan Aldrich, Craig Chambers, and David Notkin. Arch- Java: Connecting software architecture to implementation. In Proceedings of International Conference on Software Engineering (ICSE), pages 187–197. ACM, 2002.
  81. Eelco Visser, Zine-El-Abidine Benaissa, and Andrew P. Tolmach. Building program optimizers with rewriting strategies. In Pro- ceedings of International Conference on Functional Programming (ICFP), pages 13–26. ACM, 1998. BIBLIOGRAPHY [vdBSVV02] Mark van den Brand, Jeroen Scheerder, Jurgen J. Vinju, and Eelco Visser. Disambiguation filters for scannerless generalized LR parsers. In Proceedings of Conference on Compiler Construction (CC), volume 2304 of LNCS, pages 143–158. Springer, 2002.
  82. Emma Söderberg and Görel Hedin. Building semantic editors using JastAdd: Tool demonstration. In Proceedings of Workshop on Language Descriptions, Tools and Applications (LDTA), pages 1–6. ACM, 2011. [Shu93]
  83. David H. Lorenz and Boaz Rosenan. Cedalion: A language for language oriented programming. In Proceedings of Confer- ence on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 733–752. ACM, 2011. [LV95]
  84. Florian Heidenreich, Jendrik Johannes, Mirko Seifert, and Chris- tian Wende. Closing the gap between modelling and Java. In Proceedings of Conference on Software Language Engineering (SLE), volume 5969 of LNCS, pages 374–383. Springer, 2009. [HKGV10] Zef Hemel, Lennart C. L. Kats, Danny M. Groenewegen, and Eelco Visser. Code generation by model transformation: A case study in transformation modularity. Software and System Modeling, 9(3):375–402, 2010.
  85. Matthew Flatt. Composable and compilable macros: You want it when? In Proceedings of International Conference on Functional Programming (ICFP), pages 72–83. ACM, 2002. [Fla12]
  86. Martin Bravenboer and Eelco Visser. Concrete syntax for objects: Domain-specific language embedding and assimilation without restrictions. In Proceedings of Conference on Object-Oriented BIBLIOGRAPHY Programming, Systems, Languages, and Applications (OOPSLA), pages 365–383. ACM, 2004.
  87. [MQR95] Mark Moriconi, Xiaolei Qian, and Robert A. Riemenschneider. Correct architecture refinement. Transactions on Software Engi- neering (TSE), 21(4):356–372, 1995.
  88. Matthew Flatt. Creating languages in racket. Communication of the ACM, 55(1):48–56, 2012. [For02]
  89. Joseph E. Stoy. Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory. MIT Press, 1977. [Sun02] Sun Microsystems. Java Pet Store, 2002. Available at http://www. oracle.com/technetwork/java/index-136650.html, accessed Nov. 14, 2012.
  90. Martin Fowler. Domain-Specific Languages. Addison Wesley, 2010.
  91. [FCF + 02] Robert Bruce Findler, John Clements, Cormac Flanagan, Matthew Flatt, Shriram Krishnamurthi, Paul Steckler, and Matthias Felleisen. DrScheme: A programming environment for scheme. Functional Programming, 12(2):159–182, 2002. [Feh11]
  92. Jacques Carette, Oleg Kiselyov, and Chung-chieh Shan. Finally tagless, partially evaluated: Tagless staged interpreters for simpler typed languages. Functional Programming, 19(5):509–543, 2009. [CMA94] Luca Cardelli, Florian Matthes, and Martín Abadi. Extensible syntax with lexical scoping. Technical Report 121, DEC SRC, 1994.
  93. Robert Allen and David Garlan. Formalizing architectural con- nection. In Proceedings of International Conference on Software Engineering (ICSE), pages 71–80. IEEE, 1994. [AHL08]
  94. John Hughes. Generalising monads to arrows. Science of Com- puter Programming, 37(1–3):67–111, 2000.
  95. Guy L. Steele, Jr. Growing a language. Higher-Order and Sym- bolic Computation, 12(3):221–236, 1999. [Sto77]
  96. Matthias Blume and Andrew W. Appel. Hierarchical modu- larity. Transactions on Programming Languages and Systems (TOPLAS), 21:813–847, 1999. BIBLIOGRAPHY [BBG + 63] J. W. Backus, F. L. Bauer, J. Green, C. Katz, J. McCarthy, A. J. Perlis, H. Rutishauser, K. Samelson, B. Vauquois, J. H. Wegstein, A. van Wijngaarden, and M. Woodger. Revised report on the algorithm language ALGOL 60. Communication of the ACM, 6(1):1–17, 1963.
  97. Jon Rafkind and Matthew Flatt. Honu: Syntactic extension for algebraic notation through enforestation. In Proceedings of Con- ference on Generative Programming and Component Engineering (GPCE), pages 122–131. ACM, 2012.
  98. [FFFK01] Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, and Shriram Krishnamurthi. How to design programs: An introduction to programming and computing. MIT Press, 2001. [FL08] Andrew Forward and Timothy C. Lethbridge. Problems and opportunities for model-centric versus code-centric software de- velopment: A survey of software professionals. In Proceedings of Workshop on Models in Software Engineering (MiSE), pages 27–32. ACM, 2008. [Fla02]
  99. Lukas Renggli, Marcus Denker, and Oscar Nierstrasz. Language boxes: Bending the host language with modular language changes. In Proceedings of Conference on Software Language Engineering (SLE), volume 5969 of LNCS, pages 274–293. Springer, 2009. [RF12]
  100. Jon Louis Bentley. Little languages. Communication of the ACM, 29(8):711–721, 1986.
  101. Arie van Deursen and Paul Klint. Little languages: Little main- tenance? Software Maintenance, 10(2):75–92, 1998. [vdS11] Tijs van der Storm. The Rascal language workbench. Submitted to Language Workbench Competition 2011, available at http: //oai.cwi.nl/oai/asset/18531/18531D.pdf., 2011. [Vis97a]
  102. Terence Parr and Kathleen Fisher. LL(*): The foundation of the ANTLR parser generator. In Proceedings of Conference on Programming Language Design and Implementation (PLDI), pages 425–436. ACM, 2011.
  103. M. Douglas McIlroy. Macro instruction extensions of compiler languages. Communication of the ACM, 3(4):214–220, 1960.
  104. William Clinger and Jonathan Rees. Macros that work. In Pro- ceedings of Symposium on Principles of Programming Languages (POPL), pages 155–162. ACM, 1991.
  105. [FCDF12] Matthew Flatt, Ryan Culpepper, David Darais, and Robert Bruce Findler. Macros that work together -compile-time bindings, par- tial expansion, and definition contexts. Functional Programming, 22(2):181–216, 2012.
  106. Stuart Kent. Model driven engineering. In Proceedings of Confer- ence on Integrated Formal Methods (IFM), volume 2335 of LNCS, pages 286–298. Springer, 2002.
  107. Bryan Ford. Packrat parsing: Simple, powerful, lazy, linear time, functional pearl. In Proceedings of International Conference on Functional Programming (ICFP), pages 36–47. ACM, 2002. [For04]
  108. Gilad Bracha. Pluggable type systems. In OOPSLA Workshop on Revival of Dynamic Languages, 2004. Available at http: //bracha.org/pluggableTypesPosition.pdf.
  109. Luca Cardelli. Program fragments, linking, and modulariza- tion. In Proceedings of Symposium on Principles of Programming Languages (POPL), pages 266–277. ACM, 1997. [CH06] K. Czarnecki and S. Helsen. Feature-based survey of model transformation approaches. IBM Systems Journal, 45(3):621–645, 2006. [Cha06] Matt Chapman. Extending JDT to support Java-like languages. Invited Talk at EclipseCon'06, 2006.
  110. Daniel Weise and Roger F. Crew. Programmable syntax macros. In Proceedings of Conference on Programming Language Design and Implementation (PLDI), pages 156–165. ACM, 1993. [Weg70]
  111. [LZ74] Barbara Liskov and Stephen N. Zilles. Programming with abstract data types. SIGPLAN Notices, 9(4):50–59, 1974. [Mai07] Geoffrey Mainland. Why it's nice to be quoted: Quasiquoting for Haskell. In Proceedings of Haskell Workshop, pages 73–82. ACM, 2007. BIBLIOGRAPHY [Mar10]
  112. [KdJNNV09] Lennart C. L. Kats, Maartje de Jonge, Emma Nilsson-Nyman, and Eelco Visser. Providing rapid feedback in generated modular language environments: Adding error recovery to scannerless generalized-LR parsing. In Proceedings of Conference on Object- Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 445–464. ACM, 2009.
  113. Lennart C. L. Kats, Eelco Visser, and Guido Wachsmuth. Pure and declarative syntax definition: Paradise lost and regained. In Proceedings of Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 918–932. ACM, 2010. BIBLIOGRAPHY [Lan66]
  114. Paul Klint, Tijs van der Storm, and Jurgen Vinju. Rascal: A domain-specific language for source code analysis and manipula- tion. In Proceedings of Conference on Source Code Analysis and Manipulation (SCAM), pages 168–177, 2009.
  115. John N. Shutt. Recursive adaptable grammars. Master's thesis, Worcester Polytechnic Institute, 1993.
  116. John McCarthy. Recursive functions of symbolic expressions and their computation by machine, part I. Communication of the ACM, 3(4):184–195, 1960. [McI60]
  117. Stefan Fehrenbach. Retrofitting language-oriented design with SugarJ. Bachelor's Thesis, University of Marburg, November 2011.
  118. Eelco Visser. Scannerless generalized-LR parsing. Technical Report P9707, Programming Research Group, University of Am- sterdam, 1997.
  119. [FBF09] Matthew Flatt, Eli Barzilay, and Robert Bruce Findler. Scribble: Closing the book on ad hoc documentation tools. In Proceedings of International Conference on Functional Programming (ICFP), pages 109–120. ACM, 2009. BIBLIOGRAPHY [FBLS12] Andrew Forward, Omar Bahy Badreddin, Timothy C. Lethbridge, and Julian Solano. Model-driven rapid prototyping with Umple. Software Practice and Experience, 42(7):781–797, 2012.
  120. Donald E. Knuth. Semantics of context-free languages. Mathe- matical Systems Theory, 2(2):127–145, 1968. [KO10]
  121. [DMN67] O. J. Dahl, B. Myhrhaug, and K. Nygaard. SIMULA 67 common base language. Technical Report S-22, Norwegian Computing Center, 1967. [dR03] Daniel de Rauglaudre. Camlp4 reference manual. http: //caml.inria.fr/pub/docs/manual-camlp4/index.html, ac- cessed Oct. 01 2012., 2003.
  122. David Fisher and Olin Shivers. Static analysis for syntax ob- jects. In Proceedings of International Conference on Functional Programming (ICFP), pages 111–121. ACM, 2006. [GHC12] GHC Team. The glorious Glasgow Haskell Compilation System user's guide, version 7.4.1, 2012.
  123. Ben Wegbreit. Studies in extensible programming languages. Technical Report ESD-TR-70-297, Harvard University, Cam- bridge, Massachusetts, 1970.
  124. [ERKO11] Sebastian Erdweg, Tillmann Rendel, Christian Kästner, and Klaus Ostermann. SugarJ: Library-based syntactic language extensibility. In Proceedings of Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 391–406. ACM, 2011.
  125. Eelco Visser. Syntax Definition for Language Prototyping. PhD thesis, University of Amsterdam, 1997. [Vis02]
  126. Tim Sheard and Simon Peyton Jones. Template meta- programming for Haskell. In Proceedings of Haskell Workshop, pages 1–16. ACM, 2002. [Spi01]
  127. Shriram Krishnamurthi. Educational pearl: Automata via macros. Functional Programming, 16(3):253–267, 2006. BIBLIOGRAPHY [KRPGD12] Dimitrios S. Kolovos, Louis Rose, Richard Paige, and Antonio García-Domínguez. The Epsilon book, 2012. Available at http:// www.eclipse.org/epsilon/doc/book/, accessed Nov. 13, 2012. [KRV08] Holger Krahn, Bernhard Rumpe, and Steven Völkel. Monti- Core: Modular development of textual domain specific languages. In Proceedings of Conference on Technology of Object-oriented Languages and Systems (TOOLS), pages 297–315. Springer, 2008. [KRV10] Holger Krahn, Bernhard Rumpe, and Steven Völkel. MontiCore: A framework for compositional development of domain specific languages. Software Tools for Technology Transfer, 12(5):353–372, 2010.
  128. Peter J. Landin. The next 700 programming languages. Commu- nication of the ACM, 9(3):157–166, 1966. [Lar02] C. Larman. Applying UML and patterns: An introduction to object-oriented analysis and design and the unified process. Pren- tice Hall, second edition, 2002. [Lay85]
  129. Lennart C. L. Kats and Eelco Visser. The Spoofax language workbench: Rules for declarative specification of languages and IDEs. In Proceedings of Conference on Object-Oriented Program- ming, Systems, Languages, and Applications (OOPSLA), pages 444–463. ACM, 2010.
  130. [HORM08] Christian Hofer, Klaus Ostermann, Tillmann Rendel, and Adri- aan Moors. Polymorphic embedding of DSLs. In Proceedings of Conference on Generative Programming and Component Engi- neering (GPCE), pages 137–148. ACM, 2008. [HPvD09]
  131. Ross Paterson and Simon Peyton Jones. Type and translation rules for arrow notation in GHC, 2004.
  132. [MHS05] Marjan Mernik, Jan Heering, and Anthony M. Sloane. When and how to develop domain-specific languages. ACM Computing Surveys, 37:316–344, 2005.
  133. Martin Fowler. Language workbenches: The killer-app for domain specific languages? Available at http://martinfowler.com/ articles/languageWorkbench.html, 2005.
  134. K. Skalski, M. Moskal, , and P. Olszta. Meta-programming in nemerle. http://nemerle.org/metaprogramming.pdf, accessed Oct. 01 2012., 2004.
  135. Eric Allen, Ryan Culpepper, Janus Dam Nielsen, Jon Rafkind, and Sukyoung Ryu. Growing a syntax. In Proceedings of Work- shop on Foundations of Object-Oriented Languages (FOOL), 2009. Available at http://www.cs.cmu.edu/~aldrich/FOOL09/allen. pdf.
  136. Michiaki Tatsubori, Shigeru Chiba, Marc-Olivier Killijian, and Kozo Itano. OpenJava: A class-based macro system for Java. In Proceedings of Workshop on Reflection and Software Engineering, volume 1826 of LNCS, pages 117–133. Springer, 2000. [The12] The Eclipse Foundation. Eclipse. http://www.eclipse.org/, 2012.
  137. Simon Marlow (editor). Haskell 2010 language report. Available at http://www.haskell.org/onlinereport/haskell2010, 2010.
  138. Edsger W. Dijkstra. Letters to the editor: Go to statement considered harmful. Communication of the ACM, 11(3):147–148, 1968. [Dmi04] Sergey Dmitriev. Language oriented programming: The next programming paradigm. Available at http://www.jetbrains. com/mps/docs/Language_Oriented_Programming.pdf, 2004.
  139. Tom Mens, Gabriele Taentzer, and Olga Runge. Detecting struc- tural refactoring conflicts using critical pair analysis. Electronic Notes in Theoretical Computer Science, 127(3):113–128, 2005. [NCM03] Nathaniel Nystrom, Michael R. Clarkson, and Andrew C. Myers. Polyglot: An extensible compiler framework for Java. In Proceed- ings of Conference on Compiler Construction (CC), volume 2622 of LNCS, pages 138–152. Springer, 2003. [Obj04] Object Management Group. Human-usable textual notation (HUTN) specification 1.0. Available at http://www.omg.org/ spec/HUTN, 2004.
  140. Martin Odersky. The Scala language specification, version 2.9. Available at http://www.scala-lang.org/docu/files/ ScalaReference.pdf., 2010.
  141. M. P. Ward. Language-oriented programming. Software – Con- cepts and Tools, 15:147–161, 1995.
  142. [W3C04] W3C XML Schema Working Group. XML Schema part 0: Primer second edition. Available at http://www.w3.org/TR/ xmlschema-0, 2004.
  143. [W3C99] W3C HTML Working Group. HTML 4.01 specification. Available at http://www.w3.org/TR/html4/, 1999.
  144. [W3C08] W3C XML Working Group. Extensible markup language (XML) 1.0 (fifth edition). Available at http://www.w3.org/TR/xml, 2008. [War95]
  145. Markus Völter. Language and IDE modularization, extension and composition with MPS. In Pre-proceedings of Summer School on Generative and Transformational Techniques in Software En- gineering (GTTSE), pages 395–431, 2011.


* Das Dokument ist im Internet frei zugänglich - Hinweise zu den Nutzungsrechten