More Web Proxy on the site http://driver.im/

survey

A Survey of Metaprogramming Languages

Authors:

Anthony SavidisAuthors Info & Claims

ACM Computing Surveys (CSUR), Volume 52, Issue 6

Article No.: 113, Pages 1 - 39

https://doi.org/10.1145/3354584

Published: 16 October 2019 Publication History

Abstract

Metaprogramming is the process of writing computer programs that treat programs as data, enabling them to analyze or transform existing programs or generate new ones. While the concept of metaprogramming has existed for several decades, activities focusing on metaprogramming have been increasing rapidly over the past few years, with most languages offering some metaprogramming support and the amount of metacode being developed growing exponentially. In this article, we introduce a taxonomy of metaprogramming languages and present a survey of metaprogramming languages and systems based on the taxonomy. Our classification is based on the metaprogramming model adopted by the language, the phase of the metaprogram evaluation, the metaprogram source location, and the relation between the metalanguage and the object language.

References

[1]

Andrei Alexandrescu. 2010. The D Programming Language. Addison-Wesley Professional.

[2]

Nada Amin and Tiark Rompf. 2017. Collapsing towers of interpreters. Proc. ACM Program. Lang. 2, POPL, Article 52 (December 2017), 33 pages.

Digital Library

[3]

Apache Commons. 2006. BCEL - Byte code engineering library. Retrieved January 2019 from https://commons.apache.org/proper/commons-bcel/.

[4]

Sven Apel, Christian Kästner, and Christian Lengauer. 2008. Feature featherweight Java: A calculus for feature-oriented programming and stepwise refinement. In Proceedings of the 7th International Conference on Generative Programming and Component Engineering (GPCE’08). ACM, New York, 101--112.

Digital Library

[5]

Kenichi Asai. 2014. Compiling a reflective language using MetaOCaml. In Proceedings of the 2014 International Conference on Generative Programming: Concepts and Experiences (GPCE’14). ACM, New York, 113--122.

Digital Library

[6]

Kevin Atkinson and Matthew Flatt. 2011. Adapting scheme-like macros to a c-like language. In Workshop on Scheme and Functional Programming (Scheme’11). Retrieved January 2019 from http://scheme2011.ucombinator.org/papers/Atkinson2011.pdf.

[7]

Jonathan Bachrach and Keith Playford. 1999. D-expressions: Lisp power, Dylan style. Technical Report. Retrieved January 2019 from https://people.csail.mit.edu/jrb/Projects/dexprs.pdf.

[8]

Jonthan Bachrach and Keith Playford. 2001. The Java syntactic extender (JSE). In Proceedings of the 16th ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA’01). ACM, New York, 31--42.

Digital Library

[9]

Jason Baker and Wilson Hsieh. 2002a. Runtime aspect weaving through metaprogramming. In Proceedings of the 1st International Conference on Aspect-Oriented Software Development (AOSD’02). ACM, New York, 86--95.

Digital Library

[10]

Jason Baker and Wilson Hsieh. 2002b. Maya: Multiple-dispatch syntax extension in Java. In Proceedings of the ACM SIGPLAN 2002 Conference on Programming Language Design and Implementation (PLDI’02). ACM, New York, 270--281.

Digital Library

[11]

Don Batory, Bernie Lofaso, and Yannis Smaragdakis. 1998. JTS: Tools for implementing domain-specific languages. In Proceedings of the 5th International Conference on Software Reuse (ICSR’98). IEEE Computer Society, Washington, DC, 143--153.

[12]

Alan Bawden. 1999. Quasiquotation in Lisp. In Proceedings of the Workshop on Partial Evaluation and Semantics-Based Program Manipulation, 88--99. University of Aarhus. Invited talk. Retrieved January 2019 from https://3e8.org/pub/scheme/doc/Quasiquotation%20in%20Lisp%20(Bawden).pdf.

[13]

Alan Bawden and Jonathan Rees. 1988. Syntactic closures. In Proceedings of the 1988 ACM Conference on LISP and Functional Programming (LFP’88), 86--95.

Digital Library

[14]

Jonas Bonér. 2004. What are the key issues for commercial AOP use: How does AspectWerkz address them? In Proceedings of the 3rd International Conference on Aspect-Oriented Software Development (AOSD’04). ACM, New York, 5--6.

Digital Library

[15]

Claus Brabrand and Michael I. Schwartzbach. 2002. Growing languages with metamorphic syntax macros. In Proceedings of the 2002 ACM SIGPLAN Workshop on Partial Evaluation and Semantics-Based Program Manipulation (PEPM’02). ACM, 31--40.

[16]

Gilad Bracha and David Ungar. 2004. Mirrors: Design principles for meta-level facilities of object-oriented programming languages. In Proceedings of the 19th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA’04). ACM, New York, 331--344.

Digital Library

[17]

Martin Bravenboer, Karl Trygve Kalleberg, Rob Vermaas, and Eelco Visser. 2008. Stratego/XT 0.17. A language and toolset for program transformation. Science of Computer Programming 72, 1--2 (2008), 52--70.

Digital Library

[18]

Avi Bryant and Robert Feldt. 2002. AspectR - Simple aspect-oriented programming in Ruby. Retrieved January 2019 from http://aspectr.sourceforge.net/.

[19]

Eugene Burmako. 2013. Scala macros: Let our powers combine!: On how rich syntax and static types work with metaprogramming. In Proceedings of the 4th Workshop on Scala (SCALA’13). ACM, New York, Article 3, 1--10.

Digital Library

[20]

Cristiano Calcagno, Walid Taha, Liwen Huang, and Xavier Leroy. 2003. Implementing multi-stage languages using ASTs, gensym, and reflection. In Proceedings of the 2nd International Conference on Generative Programming and Component Engineering (GPCE’03). Springer LNCS 2830, 57--76.

Digital Library

[21]

Guido Chari, Diego Garbervetsky, and Stefan Marr. 2016. Building efficient and highly run-time adaptable virtual machines. In Proceedings of the 12th Symposium on Dynamic Languages (DLS’16). ACM, New York, 60--71.

Digital Library

[22]

Shigeru Chiba. 1995. A metaobject protocol for C++. In Proceedings of the 10th Annual Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA’95). ACM, New York, 285--299.

Digital Library

[23]

Shigeru Chiba. 1998. Javassist - A reflection-based programming wizard for java. In Proceedings of the OOPSLA’98 Workshop on Reflective Programming in C++ and Java. Retrieved January 2019 from http://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=2404E80FF2C51CC1892AD4539970A569?doi=10.1.1.39.7059&rep==rep1&type==pdf.

[24]

William Clinger and Jonathan Rees. 1991. Macros that work. In Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of Programming Languages (POPL’91). ACM, New York, 155--162.

Digital Library

[25]

Pascal Costanza. 2004. A short overview of AspectL. In Proceedings of the European Interactive Workshop on Aspects in Software. EIWAS. Retrieved January 2019 from http://www.p-cos.net/documents/aspectl-short-final.pdf.

[26]

Ryan Culpepper and Matthias Felleisen. 2010. Fortifying macros. In Proceedings of the 15th ACM SIGPLAN International Conference on Functional Programming (ICFP’10). ACM, New York, 235--246.

Digital Library

[27]

Krzysztof Czarnecki and Ulrich W. Eisenecker. 2000. Generative Programming: Methods, Tools, and Applications. ACM Press/Addison-Wesley Publishing, New York.

Digital Library

[28]

Robertas Damaševičius and Vytautas Štuikys. 2008. Taxonomy of the fundamental concepts of metaprogramming. Information Technology and Control, 37, 2 (2008), 124--132. Retrieved January 2019 from http://www.itc.ktu.lt/index.php/ITC/article/view/11931/6598.

[29]

Joe Darcy. 2006. Java Specification Request 269: Pluggable annotation processing API. Retrieved January 2019 from http://jcp.org/en/jsr/detail?id=269.

[30]

Zachary DeVito, James Hegarty, Alex Aiken, Pat Hanrahan, and Jan Vitek. 2013. Terra: A multi-stage language for high-performance computing. In Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’13). ACM, New York, 105--116.

Digital Library

[31]

Tim Disney, Nathan Faubion, David Herman, and Cormac Flanagan. 2014. Sweeten your JavaScript: Hygienic macros for ES5. In Proceedings of the 10th ACM Symposium on Dynamic Languages (DLS’14). ACM, New York, 35--44.

Digital Library

[32]

Rémi Douence and Mario Südholt. 2001. A generic reification technique for object-oriented reflective languages. Higher-Order and Symbolic Computation 14, 1 (2001), 7--34.

Digital Library

[33]

Dirk Draheim, Christof Lutteroth, and Gerald Weber. 2005. A type system for reflective program generators. In Proceedings of the 4th International Conference on Generative Programming and Component Engineering (GPCE'05). Springer LNCS 3676, 327--341.

Digital Library

[34]

Stéphane Ducasse, Nathanael Schärli, and Roel Wuyts. 2005. Uniform and safe metaclass composition. Computer Languages Systems and Structures 31, 3--4 (2005), 143--164.

Digital Library

[35]

Christopher Dutchyn, David B. Tucker, and Shriram Krishnamurthi. 2006. Semantics and scoping of aspects in higher-order languages. Science Computer Programming 63, 3 (2006), 207--239.

Digital Library

[36]

R. Kent Dybvig, Robert Hieb, and Carl Bruggeman. 1993. Syntactic abstraction in scheme. Lisp and Symbolic Computation 5, 4 (1993), 295--326.

Digital Library

[37]

R. Kent Dybvig. 2009. The Scheme Programming Language (4th ed.). MIT Press.

[38]

Jason Eckhardt, Roumen Kaiabachev, Emir Pašalić, Kedar Swadi, and Walid Taha. 2005. Implicitly heterogeneous multi-stage programming. In Proceedings of the 4th International Conference on Generative Programming and Component Engineering (GPCE’05), Springer LNCS 3676, 275--292.

Digital Library

[39]

Sebastian Erdweg, Tillmann Rendel, Christian Kästner, and Klaus Ostermann. 2011. SugarJ: Library-based syntactic language extensibility. In Proceedings of the 2011 ACM International Conference on Object Oriented Programming Systems Languages and Applications (OOPSLA’11). ACM, New York, 391--406.

Digital Library

[40]

Manuel Fähndrich, Michael Carbin, and James R. Larus. 2006. Reflective program generation with patterns. In Proceedings of the 5th International Conference on Generative Programming and Component Engineering (GPCE’06). 275--284.

[41]

Matthew Flatt. 2002. Composable and compilable macros: You want it when? In Proceedings of the 7th ACM SIGPLAN International Conference on Functional Programming (ICFP’02). ACM, New York, 72--83.

Digital Library

[42]

Matthew Flatt, Ryan Culpepper, David Darais, and Robert Bruce Findler. 2012. Macros that work together: Compile-time bindings, partial expansion, and definition contexts. Journal of Functional Programming 22, 2 (2012), 181--216.

Digital Library

[43]

Fabien Fleutot. 2007. Metalua Manual. Retrieved January 2019 from http://metalua.luaforge.net/metalua-manual.html.

[44]

Gael Fraiteur. 2008. AOP on .NET -- PostSharp. Retrieved April 1, 2015, from https://www.postsharp.net/aop.net.

[45]

Steven E. Ganz, Amr Sabry, and Walid Taha. 2001. Macros as multi-stage computations: Type-safe, generative, binding macros in MacroML. In Proceedings of the 6th ACM SIGPLAN International Conference on Functional Programming (ICFP'01). ACM, New York, 74--85.

Digital Library

[46]

Robert Glück and Jesper Jørgensen. 1996. Fast binding-time analysis for multi-level specialization. In Proceedings of the 2nd International Andrei Ershov Memorial Conference on Perspectives of System Informatics. Springer LNCS 1181, 261--272.

[47]

Michael Golm and Jürgen Kleinöder. 1999. Jumping to the meta level: Behavioral reflection can be fast and flexible. In Proceedings of the 2nd International Conference on Meta-Level Architectures and Reflection (Reflection'99). Springer LNCS 1616, 22--33.

[48]

Brendan Gowing and Vinny Cahill. 1996. Meta-Object Protocols for C++: The Iguana Approach. Technical Report. University of Bologna. Retrieved January 2019 from https://www.scss.tcd.ie/publications/tech-reports/reports.96/TCD-CS-96-16.pdf.

[49]

José de Oliveira Guimarães. 1998. Reflection for statically typed languages. In Proceedings of the 12th European Conference on Object-Oriented Programming (ECOOP'98). Springer LNCS 1445, 440--461.

[50]

Tero Hasu and Matthew Flatt. 2016. Source-to-source compilation via submodules. In Proceedings of the 9th European Lisp Symposium on European Lisp Symposium (ELS’16), Article 7, 8.

Digital Library

[51]

Robert Hirschfeld. 2002. AspectS - aspect-oriented programming with squeak. In Revised Papers from the International Conference NetObjectDays on Objects, Components, Architectures, Services, and Applications for a Networked World (NODe'02). Springer LNCS 2591, 216--232.

[52]

Markus Hof. 2000. Composable message semantics in Oberon. In Modular Programming Languages (JMLC’00). Springer LNCS 1897, 11--25.

[53]

Zhang Hongbo and Steve Zdancewic. 2013. Fan: Compile-time metaprogramming for OCaml. Retrieved January 2019 from http://zhanghongbo.me/fan/_downloads/metaprogramming_for_ocaml.pdf.

[54]

Shan Shan Huang, David Zook, and Yannis Smaragdakis. 2005. Statically safe program generation with SafeGen. In Proceedings of the 4th International Conference on Generative Programming and Component Engineering (GPCE’05). Springer LNCS 3676, 309--326.

Digital Library

[55]

Shan Shan Huang, David Zook, and Yannis Smaragdakis. 2007. cJ: Enhancing Java with safe type conditions. In Proceedings of the 6th International Conference on Aspect-oriented Software Development (AOSD'07). ACM, New York, 185--198.

Digital Library

[56]

Shan Shan Huang and Yannis Smaragdakis. 2011. Morphing: Structurally shaping a class by reflecting on others. ACM Transactions on Programming Languages and Systems 33, 2, Article 6, 44.

Digital Library

[57]

Rod Johnson. 2011. Aspect oriented programming with spring. Retrieved January 2019 from http://docs.spring.io/spring/docs/current/spring-framework-reference/html/aop.html.

[58]

Chanwit Kaewkasi and John R. Gurd. 2008. Groovy AOP: A dynamic AOP system for a JVM-based language. In Proceedings of the 2008 AOSD Workshop on Software Engineering Properties of Languages and Aspect Technologies (SPLAT'08). ACM, Article 3.

[59]

Yukiyoshi Kameyama, Oleg Kiselyov, and Chung-chieh Shan. 2009. Shifting the stage: Staging with delimited control. In Proceedings of the 2009 ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation (PEPM'09), 111--120.

[60]

Sam Kamin, Lars Clausen, and Ava Jarvis. 2003. Jumbo: Run-time code generation for Java and its applications. In Proceedings of the 1st IEEE / ACM International Symposium on Code Generation and Optimization (CGO'03), 48--56.

[61]

Brian W. Kernighan and Dennis M. Ritchie. 1988. The C Programming Language (2nd ed.). Prentice-Hall, Englewood Cliffs, NJ.

Digital Library

[62]

Gregor Kiczales, Jim Rivieres, and Daniel G. Bobrow. 1991. The Art of the Metaobject Protocol. MIT Press.

Digital Library

[63]

Gregor Kiczales, John Lamping, Anurag Mendhekar, Chris Maeda, Cristina Lopes, Jean-Marc Loingtier, and John Irwin. 1997. Aspect-oriented programming. In Proceedings of the 11th European Conference on Object-Oriented Programming (ECOOP'97). Springer LNCS 1241, 220--242.

[64]

Gregor Kiczales, Erik Hilsdale, Jim Hugunin, Mik Kersten, Jeffrey Palm, and William G. Griswold. 2001. An overview of AspectJ. In Proceedings of the 15th European Conference on Object-Oriented Programming (ECOOP'01). Springer LNCS 2072, 327--354.

Digital Library

[65]

Michael Kimberlin. 2010. Reducing boilerplate code with project Lombok. Retrieved January 2019 from http://jnb.ociweb.com/jnb/jnbJan2010.html.

[66]

Eugene Kohlbecker, Daniel P. Friedman, Matthias Felleisen, and Bruce Duba. 1986. Hygienic macro expansion. In Proceedings of the 1986 ACM Conference on LISP and Functional Programming (LFP'86). ACM, New York, 151--161.

Digital Library

[67]

Thomas Kühne and Daniel Schreiber. 2007. Can programming be liberated from the two-level style: Multi-level programming with deepjava. In Proceedings of the 22nd Annual ACM SIGPLAN Conference on Object-Oriented Programming Systems and Applications (OOPSLA'07). ACM, New York, 229--244.

Digital Library

[68]

Byeongcheol Lee, Robert Grimm, Martin Hirzel, and Kathryn S. McKinley. 2012. Marco: Safe, expressive macros for any language. In Proceedings of the 26th European Conference on Object-Oriented Programming (ECOOP'12). Springer LNCS 7313, 589--613.

[69]

Yannis Lilis and Anthony Savidis. 2014. Aspects for stages: Cross cutting concerns for metaprograms. Journal of Object Technology 13, 1 (2014), 1--36.

[70]

Yannis Lilis and Anthony Savidis. 2015. An integrated implementation framework for compile-time metaprogramming. Software Practice and Experience 45, 6 (2015), 727--763.

Digital Library

[71]

Fengyun Liu and Eugene Burmako. 2017. Two approaches to portable macros. Technical Report, EPFL.

[72]

Pattie Maes. 1987. Concepts and experiments in computational reflection. In Conference Proceedings on Object-Oriented Programming Systems, Languages and Applications (OOPSLA'87). ACM, New York, 147--155.

Digital Library

[73]

Geoffrey Mainland. 2012. Explicitly heterogeneous metaprogramming with metahaskell. In Proceedings of the 17th ACM SIGPLAN International Conference on Functional Programming (ICFP'12). ACM, New York, 311--322.

Digital Library

[74]

Stefan Marr, Chris Seaton, and Stéphane Ducasse. 2015. Zero-overhead metaprogramming: reflection and metaobject protocols fast and without compromises. In Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI'15). ACM, New York, 545--554.

Digital Library

[75]

Weiyu Miao and Jeremy Siek. 2012. Pattern-based traits. In Proceedings of the 27th Annual ACM Symposium on Applied Computing (SAC'12). ACM, New York, 1729--1736.

Digital Library

[76]

Weiyu Miao and Jeremy Siek. 2014. Compile-time reflection and metaprogramming for Java. In Proceedings of the ACM SIGPLAN 2014 Workshop on Partial Evaluation and Program Manipulation (PEPM'14). ACM, New York, 27--37.

Digital Library

[77]

Gregory Neverov and Paul Roe. 2006. Experiences with an object-oriented, multi-stage language. Science of Computer Programming 62, 1 (2006), 85--94.

Digital Library

[78]

Angela Nicoara and Gustavo Alonso. 2005. Dynamic AOP with PROSE. In Proceedings of the International Workshop on Adaptive and Self-Managing Enterprise Applications (ASMEA’05). Retrieved January 2019 from http://www.deutsche-telekom-laboratories.com/∼angela/papers/AngelaNicoara-ASMEA2005.pdf.

[79]

Dmitry Nizhegorodov. 2000. Jasper: Type-Safe MOP-based language extensions and reflective template processing in java. In Proceedings of ECOOP 2000 Workshop on Reflection and Metalevel Architectures: State of the Art, and Future Trends. ACM Press.

[80]

Yutaka Oiwa, Hidehiko Masuhara, and Akinori Yonezawa. 2001. DynJava: Type safe dynamic code generation in java. In Proceedings of the 3rd JSSST Workshop on Programming and Programming Languages (PPL’01). Retrieved January 2019 from http://loome.cs.illinois.edu/CS498F10/readings/dynjava.pdf.

[81]

Alexandre Oliva and Luiz Eduardo Buzato. 1999. The design and implementation of Guaraná. In Proceedings of the 5th Conference on USENIX Conference on Object-Oriented Technologies 8 Systems -- Vol. 5 (COOTS'99). USENIX Association, Berkeley, CA, 1--15. Retrieved January 2019 from https://www.usenix.org/legacy/events/coots99/full_papers/oliva/oliva.pdf.

[82]

Zachary Palmer and Scott F. Smith. 2011. Backstage Java: Making a difference in metaprogramming. In Proceedings of the 2011 ACM International Conference on Object-Oriented Programming Systems Languages and Applications (OOPSLA'11). ACM, New York, 939--958.

[83]

Lionel Parreaux, Antoine Voizard, Amir Shaikhha, and Christoph E. Koch. 2017. Unifying analytic and statically-typed quasiquotes. Proceedings of ACM Programming Languages 2, POPL, Article 13, 33 pages.

[84]

Emir Pasalic. 2004. The Role of Type Equality in Meta-Programming. Ph.D. Dissertation. OGI School of Science 8 Engineering. Advisor(s) Timothy E. Sheard. AAI3151199. Retrieved January 2019 from http://web.cecs.pdx.edu/∼sheard/papers/EmirsThesis.pdf.

[85]

Renaud Pawlak, Lionel Seinturier, Laurence Duchien, and Gerard Florin. 2001. JAC: A flexible solution for aspect-oriented programming in Java. In Proceedings of the 3rd International Conference on Metalevel Architectures and Separation of Crosscutting Concerns (REFLECTION'01). Springer LNCS 2192, 1--24.

[86]

Massimiliano Poletto, Wilson C. Hsieh, Dawson R. Engler, and M. Frans Kaashoek. 1999. C and TCC: A language and compiler for dynamic code generation. ACM Transactions on Programming Languages and Systems (TOPLAS) 21, 2 (1999), 324--369.

Digital Library

[87]

Jon Rafkind and Matthew Flatt. 2012. Honu: Syntactic extension for algebraic notation through enforestation. In Proceedings of the 11th International Conference on Generative Programming and Component Engineering (GPCE'12). ACM, 122--131.

Digital Library

[88]

Daniel de Rauglaudre. 2003. Camlp4 -- Tutorial. Retrieved January 2019 from http://caml.inria.fr/pub/docs/tutorial-camlp4/index.html.

[89]

Barry Redmond and Vinny Cahill. 2002. Supporting unanticipated dynamic adaptation of application behaviour. In Proceedings of the 16th European Conference on Object-Oriented Programming (ECOOP'02). Springer LNCS 2374, 205--230.

[90]

John Reppy and Aaron Turon. 2007. Metaprogramming with traits. In Proceedings of the 21st European Conference on Object-Oriented Programming (ECOOP’07). Springer LNCS 4609, 373--398.

Digital Library

[91]

Morten Rhiger. 2012. Staged computation with staged lexical scope. In Proceedings of the 21st European Conference on Programming Languages and Systems (ESOP'12), Held as Part of the European Joint Conferences on Theory and Practice of Software (ETAPS’12). Springer LNCS 7211, 559--578.

Digital Library

[92]

Jonathan Riehl. 2009. Language embedding and optimization in Mython. In Proceedings of the 5th Symposium on Dynamic Languages (DLS'09). 39--48.

Digital Library

[93]

Tiark Rompf and Martin Odersky. 2010. Lightweight modular staging: A pragmatic approach to runtime code generation and compiled DSLs. In Proceedings of the 9th International Conference on Generative Programming and Component Engineering (GPCE'10). ACM, New York, 127--136.

Digital Library

[94]

Johannes Rudolph and Peter Thiemann. 2010. Mnemonics: Type-safe bytecode generation at run time. In Proceedings of the 2010 ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation (PEPM'10). ACM, New York, 15--24.

Digital Library

[95]

Vladimir O. Safonov and Dmitry A. Grigoriev. 2005. Aspect.NET -- An aspect-oriented programming tool for Microsoft.NET. In Proceedings of IEEE Regional Conference 2005. Retrieved January 2019 from https://sites.google.com/site/aspectdotnet/5.pdf.

[96]

Marco Servetto and Elena Zucca. 2010. MetaFJig: A meta-circular composition language for Java-like classes. In Proceedings of the ACM International Conference on Object-Oriented Programming Systems Languages and Applications (OOPSLA'10). 464--483.

Digital Library

[97]

Marco Servetto and Elena Zucca. 2014. A meta-circular language for active libraries. Science of Computer Programming 95, P2 (2014), 219--253.

Digital Library

[98]

Tim Sheard. 2001. Accomplishments and research challenges in metaprogramming. In Proceedings of the 2nd International Workshop on Semantics, Application and Implementation of Program Generation (SAIG’01). Springer LNCS 2196, 2--44.

[99]

Tim Sheard and Simon Peyton Jones. 2002. Template metaprogramming for Haskell. SIGPLAN Notices 37, 12 (December 2002), 60--75.

Digital Library

[100]

Kamil Skalski, Michal Moskal, and Pawel Olszta. 2004. Metaprogramming in Nemerle. Retrieved January 2019 from http://pdfs.semanticscholar.org/c3b2/e92909de69b162c064a211a2c56947542373.pdf.

[101]

Yannis Smaragdakis, Aggelos Biboudis, and George Fourtounis. 2017. Structured program generation techniques. In Grand Timely Topics in Software Engineering (GTTSE’15). Lecture Notes in Computer Science, 10223. Springer.

[102]

Olaf Spinczyk, Andreas Gal, and Wolfgang Schröder-Preikschat. 2002. AspectC++: An aspect-oriented extension to the C++ programming language. In Proceedings of the 40th International Conference on Tools Pacific: Objects for Internet, Mobile and Embedded Applications (CRPIT'02), 53--60.

[103]

Venkat Subramaniam. 2013. Programming groovy 2: Dynamic productivity for the Java developer. Pragmatic Bookshelf (1st edition).

[104]

Guy L. Steele. 1990. Common Lisp: The Language (2nd ed.). Digital Press.

Digital Library

[105]

Nicolas Stucki, Aggelos Biboudis, and Martin Odersky. 2018. A practical unification of multi-stage programming and macros. In Proceedings of the 17th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences (GPCE’18). ACM, New York, 14--27.

Digital Library

[106]

Walid Taha and Tim Sheard. 1997. Multi-stage programming with explicit annotations. In Proceedings of the Symposium on Partial Evaluation and Semantic-Based Program Manipulation (PEPM'97), ACM, New York, 203--217.

Digital Library

[107]

Walid Taha and Michael Florentin Nielsen. 2003. Environment classifiers. In Proceedings of the 30th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL'03). ACM, New York, 26--37.

Digital Library

[108]

Éric Tanter, Jacques Noyé, Denis Caromel, and Pierre Cointe. 2003. Partial behavioral reflection: Spatial and temporal selection of reification. In Proceedings of the 18th Annual ACM SIGPLAN Conference on Object-Oriented Programing, Systems, Languages, and Applications (OOPSLA'03). ACM, New York, 27--46.

Digital Library

[109]

Éric Tanter. 2004. Reflection and Open Implementations. Technical report, University of Chile.

[110]

Éric Tanter, Rodolfo Toledo, Guillaume Pothier, and Jacques Noyé. 2008. Flexible metaprogramming and AOP in Java. Science of Computer Programming 72, 1--2 (2008), 22--30.

Digital Library

[111]

Michiaki Tatsubori, Shigeru Chiba, Marc-Olivier Killijian, and Kozo Itano. 2000. OpenJava: A class-based macro system for java. In Proceedings of the 1st OOPSLA Workshop on Reflection and Software Engineering: Reflection and Software Engineering. Springer LNCS 1826, 117--133.

[112]

Elisa Tomioka, José de Oliveira Guimarães, and Antonio Francisco do Prado. 1998. R-Java, A Reflective Java Extension. Retrieved January 2019 from http://www.cyan-lang.org/jose/green/rjava/rjava-sbc.pdf.

[113]

Laurence Tratt. 2008. Domain specific language implementation via compile-time metaprogramming. ACM Transactions on Programming Languages and Systems (TOPLAS) 30, 6 (2008), 1--40.

Digital Library

[114]

Kenneth J. Turner. 1994. Exploiting the m4 macro language. Technical Report CSM-126, Department of Computing Science and Mathematics, University of Stirling, Scotland. Retrieved January 2019 from http://www.cs.stir.ac.uk/∼kjt/research/pdf/expl-m4.pdf.

[115]

Todd Veldhuizen. 2003. C++ templates are Turing complete. Technical Report, Indiana University. Retrieved January 2019 from http://port70.net/∼nsz/c/c%2B%2B/turing.pdf.

[116]

Marcos Viera and Alberto Pardo. 2006. A multi-stage language with intensional analysis. In Proceedings of the 5th International Conference on Generative Programming and Component Engineering (GPCE'06). ACM, New York, 11--20.

Digital Library

[117]

Ken Wakita, Kanako Homizu, and Akira Sasaki. 2014. Hygienic macro system for Javascript and its light-weight implementation framework. In Proceedings of ILC 2014 on 8th International Lisp Conference (ILC'14). ACM, New York, 12--21.

Digital Library

[118]

Daniel Weise and Roger Crew. 1993. Programmable syntax macros. In Proceedings of the ACM SIGPLAN 1993 Conference on Programming Language Design and Implementation (PLDI'93). ACM, New York, 156--165, 1993.

Digital Library

[119]

Ian Welch and Robert Stroud. 1999. From Dalang to Kava - the evolution of a reflective java extension. In Proceedings of the 2nd International Conference on Reflection (Reflection’99). Springer LNCS 1616, 2--21.

[120]

Edwin Westbrook, Mathias Ricken, Jun Inoue, Yilong Yao, Tamer Abdelatif, and Walid Taha. 2010. Mint: Java multi-stage programming using weak separability. In Proceedings of the 2010 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI'10). ACM, New York, 400--411.

Digital Library

[121]

Leo White. 2013. Extension points for ocaml. OCaml Users and Developers Workshop.

[122]

Zhixue Wu and Scarlet Schwiderski. 1997. Reflective Java: Making Java even more flexible, 456--458. Retrieved January 2019 from https://pdfs.semanticscholar.org/b7df/83217f05f1d2d8be3ec7ecaeda72781dc7e2.pdf.

[123]

Jeremy Yallop and Leo White. 2015. Modular macros. Retrieved January 2019 from https://www.cl.cam.ac.uk/∼jdy22/papers/modular-macros.pdf.

[124]

Hiroshi Yamaguchi and Shigeru Chiba. 2015. Inverse macro in Scala. In Proceedings of the 2015 ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences (GPCE’15). ACM, New York, 85--94.

Digital Library

[125]

Zhen Yao, Qi-long Zheng, and Guo-liang Chen. 2005. AOP++: A generic aspect-oriented programming framework in C++. In Proceedings of the 4th International Conference on Generative Programming and Component Engineering (GPCE'05). Springer LNCS 3676, 94--108.

Digital Library

[126]

David Zook, Shan Shan Huang, and Yannis Smaragdakis. 2004. Generating Aspectj programs with meta-Aspectj. In Proceedings of the 3rd International Conference on Generative Programming and Component Engineering (GPCE’04), 1--18. 10.1007/978-3-540-30175-2_1

Cited By

Du Bois ACavalheiro G(2025)GPotion: Embedding GPU programming in ElixirJournal of Computer Languages10.1016/j.cola.2025.101323(101323)Online publication date: Feb-2025
https://doi.org/10.1016/j.cola.2025.101323
Eid AMontoya F(2024)Developing GA-FuL: A Generic Wide-Purpose Library for Computing with Geometric AlgebraMathematics10.3390/math1214227212:14(2272)Online publication date: 20-Jul-2024
https://doi.org/10.3390/math12142272
Li YFujita S(2024)A Synergistic Elixir-EDA-MQTT Framework for Advanced Smart Transportation SystemsFuture Internet10.3390/fi1603008116:3(81)Online publication date: 28-Feb-2024
https://doi.org/10.3390/fi16030081
Show More Cited By

Index Terms

A Survey of Metaprogramming Languages
1. Software and its engineering
  1. Software notations and tools
    1. General programming languages
      1. Language features
        Frameworks
        Patterns
      2. Language types
        Multiparadigm languages

Recommendations

General purpose languages should be metalanguages
PEPM '10: Proceedings of the 2010 ACM SIGPLAN workshop on Partial evaluation and program manipulation

In his paper, The Next 700 Programming Languages, the late Landin writes that "most programming languages are partly a way of expressing things in terms of other things and partly a basic set of given things." Landin tries to separate the general ...
Rational Metaprogramming

Metaprogramming takes place when programs manipulate other programs. It is a powerful but tricky technique that can lead to unmaintainable code and bugs. None of the many current approaches to metaprogramming is mature. An ideal solution would use the ...
Versatile language semantics with reflective embedding
OOPSLA '09: Proceedings of the 24th ACM SIGPLAN conference companion on Object oriented programming systems languages and applications

Often, for one programming language, various implementations exist that have subtle but important variations in their syntax and semantics. While current technology provides good support for syntax variability in form of syntax extensions, there is only ...

Comments

Please enable JavaScript to view thecomments powered by Disqus.

Information & Contributors

Information

Published In

cover image ACM Computing Surveys

ACM Computing Surveys Volume 52, Issue 6

November 2020

806 pages

ISSN:0360-0300

EISSN:1557-7341

DOI:10.1145/3368196

Editor:
Sartaj Sahni
Department of Computer and Information Science and Engineering

Issue’s Table of Contents

Copyright © 2019 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 16 October 2019

Accepted: 01 July 2019

Revised: 01 June 2019

Received: 01 November 2017

Published in CSUR Volume 52, Issue 6

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Survey
Research
Refereed

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

20
Total Citations
View Citations
2,748
Total Downloads

Downloads (Last 12 months)166
Downloads (Last 6 weeks)14

Reflects downloads up to 08 Feb 2025

Other Metrics

View Author Metrics

Citations

Cited By

Du Bois ACavalheiro G(2025)GPotion: Embedding GPU programming in ElixirJournal of Computer Languages10.1016/j.cola.2025.101323(101323)Online publication date: Feb-2025
https://doi.org/10.1016/j.cola.2025.101323
Eid AMontoya F(2024)Developing GA-FuL: A Generic Wide-Purpose Library for Computing with Geometric AlgebraMathematics10.3390/math1214227212:14(2272)Online publication date: 20-Jul-2024
https://doi.org/10.3390/math12142272
Li YFujita S(2024)A Synergistic Elixir-EDA-MQTT Framework for Advanced Smart Transportation SystemsFuture Internet10.3390/fi1603008116:3(81)Online publication date: 28-Feb-2024
https://doi.org/10.3390/fi16030081
Steuben JGeltmacher ARodriguez SBirnbaum AGraber BRawlings AIliopoulos AMichopoulos J(2024)Machine-Learning Metacomputing for Materials Science DataJournal of Computing and Information Science in Engineering10.1115/1.406497524:11Online publication date: 22-Jul-2024
https://doi.org/10.1115/1.4064975
Wei QWu HShi FWan YNing H(2024)A Tutorial on Meta-Services and Services Computing in MetaverseIEEE Internet of Things Journal10.1109/JIOT.2023.334690111:10(16981-16995)Online publication date: 15-May-2024
https://doi.org/10.1109/JIOT.2023.3346901
Kessel MAtkinson C(2024)Code search engines for the next generationJournal of Systems and Software10.1016/j.jss.2024.112065215(112065)Online publication date: Sep-2024
https://doi.org/10.1016/j.jss.2024.112065
Bilyk VSachenko A(2023)Propagator-Oriented Programming Model Using JavaAdvances in Cyber-Physical Systems10.23939/acps2023.01.0098:1(9-16)Online publication date: 10-May-2023
https://doi.org/10.23939/acps2023.01.009
Cardoso ERibeiro RReis LEmiliano M(2023)A Haskell Library for Adaptable Parsing Expression GrammarsProceedings of the XXVII Brazilian Symposium on Programming Languages10.1145/3624309.3624313(73-81)Online publication date: 25-Sep-2023
https://dl.acm.org/doi/10.1145/3624309.3624313
Hochrainer CKrall ADe Roover CRumpe BShaikhha A(2023)A pred-LL(*) Parsable Typed Higher-Order Macro System for Architecture Description LanguagesProceedings of the 22nd ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences10.1145/3624007.3624052(29-41)Online publication date: 22-Oct-2023
https://dl.acm.org/doi/10.1145/3624007.3624052
Chacon-Sartori CBlum COchoa G(2023)Search Trajectory Networks Meet the Web: A Web Application for the Visual Comparison of Optimization AlgorithmsProceedings of the 2023 12th International Conference on Software and Computer Applications10.1145/3587828.3587843(89-96)Online publication date: 23-Feb-2023
https://dl.acm.org/doi/10.1145/3587828.3587843
Show More Cited By

View Options

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Article

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

HTML Format

View this article in HTML Format.

Figures

Tables

Media

View Issue’s Table of Contents