Metaprogramming

This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these template messages) This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "Metaprogramming" – news · newspapers · books · scholar · JSTOR (August 2011) (Learn how and when to remove this template message) This article's tone or style may not reflect the encyclopedic tone used on Wikipedia. See Wikipedia's guide to writing better articles for suggestions. (February 2017) (Learn how and when to remove this template message) (Learn how and when to remove this template message)

Metaprogramming is a programming technique in which computer programs have the ability to treat other programs as their data. It means that a program can be designed to read, generate, analyse or transform other programs, and even modify itself while running.^[1][2] In some cases, this allows programmers to minimize the number of lines of code to express a solution, in turn reducing development time.^[3] It also allows programs a greater flexibility to efficiently handle new situations without recompilation.

Metaprogramming can be used to move computations from

Metaprogramming usually works in one of three ways.[5]

1. The first approach is to expose the internals of the run-time engine to the programming code through
   IL
   emitter.
2. The second approach is dynamic execution of expressions that contain programming commands, often composed from strings, but can also be from other methods using arguments or context, like JavaScript.^[6] Thus, "programs can write programs." Although both approaches can be used in the same language, most languages tend to lean toward one or the other.
3. The third approach is to step outside the language entirely. General purpose program transformation systems such as compilers, which accept language descriptions and carry out arbitrary transformations on those languages, are direct implementations of general metaprogramming. This allows metaprogramming to be applied to virtually any target language without regard to whether that target language has any metaprogramming abilities of its own. One can see this at work with Scheme and how it allows tackling some limitations faced in C by using constructs that were part of the Scheme language itself to extend C.^[7]

#!/bin/sh
# metaprogram
echo '#!/bin/sh' > program
for i in $(seq 992)
do
    echo "echo $i" >> program
done
chmod +x program

A quine is a special kind of metaprogram that produces its own source code as its output. Quines are generally of recreational or theoretical interest only.

Not all metaprogramming involves generative programming. If programs are modifiable at runtime or if incremental compilation is available (such as in

One usage of metaprogramming is to instrument programs in order to do dynamic program analysis.

Challenges

Some argue that there is a sharp learning curve to make complete use of metaprogramming features.^[8] Since metaprogramming gives more flexibility and configurability at runtime, misuse or incorrect use of metaprogramming can result in unwarranted and unexpected errors that can be extremely difficult to debug to an average developer. It can introduce risks in the system and make it more vulnerable if not used with care. Some of the common problems, which can occur due to wrong use of metaprogramming are inability of the compiler to identify missing configuration parameters, invalid or incorrect data can result in unknown exception or different results.^[9] Due to this, some believe^[8] that only high-skilled developers should work on developing features which exercise metaprogramming in a language or platform and average developers must learn how to use these features as part of convention.

Uses in programming languages

Macro systems

• Common Lisp and most Lisp dialects.
• Scheme hygienic macros
• MacroML
• Racket (programming language)
• Template Haskell
• Scala macros
• Clojure
  macros
• Nim
• Rust
• Haxe
• Julia
• Elixir

Macro assemblers

The

Metaclasses are provided by the following programming languages:

• Common Lisp^[10]
• Python
• Nil
• Groovy
• Ruby
• Smalltalk
• Lua

Template metaprogramming

• C "X Macros"
• C++ Templates^[11]
• D
• Common Lisp, Scheme and most Lisp dialects by using the quasiquote ("backquote") operator.^[12]
• Nim

Staged metaprogramming

• MetaML
• MetaOCaml
• Scala natively or using the Lightweight Modular Staging Framework^[13][14]
• Terra

Dependent types

Usage of dependent types allows proving that generated code is never invalid.^[15] However, this approach is bleeding-edge and is rarely found outside of research programming languages.

Implementations

The list of notable metaprogramming systems is maintained at

See also

References