The Converge programming language.

This paper details the Converge programming language, a new dynamically typed imperative programming language capable of compile-time meta-programming, and with an extendable syntax. Although Converge has been designed with the aim of implementing different model transformation approaches as embedded DSL’s in mind, it is also a General Purpose Language (GPL), albeit one with unusually powerful features. The motivation for a new approach to implementing model transformation approaches is simple: existing languages, and their associated tool-chains, lead to long and costly implementation cycles for model transformation approaches. The justification for creating a new language, rather than altering an existing one, is far less obvious— it is reasonable to suggest that, given the vast number of programming languages already in existence, one of them should present itself as a likely candidate for modification. There are two reasons why a new language is necessary to meet the aims of this paper. Firstly, in order to meet its aims, Converge contains a blend of features unique amongst programming languages; some fundamental design choices have been necessary to make these features coalesce, and imposing such choices retrospectively on an existing language would almost certainly lead to untidy results and backwards compatibility issues. Secondly, my personal experience strongly suggests that the complexity of modern languages implementations (when such implementations are available) can make adding new features a significant challenge. In short, I assert that it is easier in the context of model transformations to start with a fresh canvass than to alter an existing language. This paper comes in three main parts. The first part documents the basics of the Converge language itself;. The second part details Converge’s compile-time metaprogramming and syntax extension facilities, including a section detailing suggestions for how some of Converge’s novel features could be added to similar languages. The third part of this paper explains Converge’s syntax extension facility, and documents a user extension which allows simple UML-esque modelling languages to be embedded within Converge. As well as being a practical demonstration of Converge’s features, this facility is used extensively throughout the remainder of the paper.

[1]  Todd A. Proebsting Simple translation of goal-directed evaluation , 1997, PLDI '97.

[2]  Pierre Cointe Metaclasses are First Class: the ObjVlisp Model , 1987, OOPSLA.

[3]  R. Nigel Horspool,et al.  Practical Earley Parsing , 2002, Comput. J..

[4]  Emir Pasalic,et al.  DSL implementation using staging and monads , 1999, DSL '99.

[5]  Alan Bawden,et al.  Quasiquotation in Lisp , 1999, PEPM.

[6]  David A. Gudeman,et al.  Denotational semantics of a goal-directed language , 1992, TOPL.

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

[8]  Manuel M. T. Chakravarty,et al.  Optimising Embedded DSLs Using Template Haskell , 2004, GPCE.

[9]  Emden R. Gansner,et al.  An open graph visualization system and its applications to software engineering , 2000 .

[10]  Matthias Felleisen,et al.  Hygienic macro expansion , 1986, LFP '86.

[11]  Pawel Olszta,et al.  Meta-programming in Nemerle , .

[12]  Adele Goldberg,et al.  SmallTalk 80: The Language , 1989 .

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

[14]  Daniel Weise,et al.  Programmable syntax macros , 1993, PLDI '93.

[15]  Martín Abadi,et al.  A Theory of Objects , 1996, Monographs in Computer Science.

[16]  Ralph E. Griswold,et al.  The Icon programming language , 1983 .

[17]  Jay Earley,et al.  An efficient context-free parsing algorithm , 1970, Commun. ACM.

[18]  Daniel G. Bobrow,et al.  Book review: The Art of the MetaObject Protocol By Gregor Kiczales, Jim des Rivieres, Daniel G. and Bobrow(MIT Press, 1991) , 1991, SGAR.

[19]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

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

[21]  Ralph E. Griswold,et al.  The implementation of the Icon programming language , 1986 .

[22]  Ralph E. Griswold,et al.  History of the Icon programming language , 1993, HOPL-II.

[23]  Robert Hieb,et al.  Syntactic abstraction in scheme , 1992, LISP Symb. Comput..

[24]  Simon L. Peyton Jones,et al.  Template meta-programming for Haskell , 2002, Haskell '02.

[25]  Walid Taha,et al.  Multi-Stage Programming: Its Theory and Applications , 1999 .

[26]  Bryan Ford,et al.  Packrat Parsing: Simple, Powerful, Lazy, Linear Time , 2006, ICFP 2002.

[27]  Krzysztof Czarnecki,et al.  DSL Implementation in MetaOCaml, Template Haskell, and C++ , 2003, Domain-Specific Program Generation.

[28]  Stuart Kent,et al.  Unambiguous UML (2U) submission to UML 2 infrastructure RFP. , 2002 .

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

[30]  Todd L. Veldhuizen,et al.  Using C++ template metaprograms , 1996 .

[31]  Alan Bawden,et al.  First-class macros have types , 2000, POPL '00.

[32]  Emden R. Gansner,et al.  An open graph visualization system and its applications to software engineering , 2000, Softw. Pract. Exp..

[33]  Jonathan Rees,et al.  Revised3 report on the algorithmic language scheme , 1986, SIGP.

[34]  Jacques Malenfant,et al.  Reflection in logic, functional and object-oriented programming: a Short Comparative Study , 1995 .

[35]  Claus Brabrand,et al.  Growing languages with metamorphic syntax macros , 2000, PEPM '02.

[36]  Jonathan Bachrach,et al.  D-Expressions : Lisp Power , Dylan Style , 1999 .

[37]  David Thomas,et al.  Programming Ruby: the pragmatic programmer's guide , 2000 .

[38]  Amr Sabry,et al.  Macros as multi-stage computations: type-safe, generative, binding macros in MacroML , 2001, ICFP '01.

[39]  B. J. Mailloux,et al.  Report on the Algorithmic Language , 1971 .

[40]  Jean-Pierre Briot,et al.  Programming with explicit metaclasses in Smalltalk-80 , 1989, OOPSLA 1989.

[41]  Martín Abadi,et al.  Extensible Grammars for Language Specialization , 1993, DBPL.

[42]  BravenboerMartin,et al.  Concrete syntax for objects , 2004 .