Metaprogramming - Wikipedia
Jump to content
From Wikipedia, the free encyclopedia
Programming paradigm
This article is about the computer programming technique. For the management technique, see
Charles Simonyi
This article has multiple issues.
Please help
improve it
or discuss these issues on the
talk page
Learn how and when to remove these 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 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 message
Learn how and when to remove this message
Metaprogramming
is a
computer 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.
In some cases, this allows programmers to minimize the number of lines of code to express a solution, in turn reducing development time.
It also allows programs more flexibility to efficiently handle new situations with no recompiling.
Metaprogramming can be used to move computations from
runtime
to
compile time
, to generate code using
compile time computations
, and to enable
self-modifying code
. The ability of a
programming language
to be its own
metalanguage
allows
reflective programming
, and is termed
reflection
Reflection is a valuable language feature to facilitate metaprogramming.
Metaprogramming was popular in the 1970s and 1980s using list processing languages such as
Lisp
Lisp machine
hardware gained some notice in the 1980s, and enabled applications that could process code. They were often used for
artificial intelligence
applications.
Approaches
edit
Metaprogramming enables developers to write programs and develop code that falls under the
generic programming
paradigm
. Having the programming language itself as a
first-class data type
(as in
Lisp
Prolog
SNOBOL
, or
Rebol
) is also very useful; this is known as
homoiconicity
Generic programming
invokes a metaprogramming facility within a language by allowing one to write code without the concern of specifying data types since they can be supplied as
parameters
when used.
Metaprogramming usually works in one of three ways.
The first approach is to expose the internals of the
runtime system
(engine) to the programming code through
application programming interfaces
(APIs) like that for the
.NET
Common Intermediate Language
(CIL) emitter.
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
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.
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 limits faced in
by using constructs that are part of the Scheme language to extend C.
Lisp
is probably the quintessential language with metaprogramming facilities, both because of its historical precedence and because of the simplicity and power of its metaprogramming. In Lisp metaprogramming, the unquote operator (typically a comma) introduces code that is
evaluated at program definition time
rather than at run time. The metaprogramming language is thus identical to the host programming language, and existing Lisp routines can be directly reused for metaprogramming if desired. This approach has been implemented in other languages by incorporating an interpreter in the program, which works directly with the program's data. There are implementations of this kind for some common high-level languages, such as
RemObjects
Pascal Script
for
Object Pascal
Usages
edit
Code generation
edit
A simple example of a metaprogram is this
POSIX Shell
script
, which is an example of
generative programming
#!/bin/sh
# metaprogram
echo
'#!/bin/sh'
program
for
in
$(
seq
992
do
echo
"echo
$i
>>
program
done
chmod
+x
program
This script (or program) generates a new 993-line program that prints out the numbers 1–992. This is only an illustration of how to use code to write more code; it is not the most efficient way to print out a list of numbers. Nonetheless, a programmer can write and execute this metaprogram in less than a minute, and will have generated over 1000 lines of code in that amount of time.
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 compiling is available (such as in
C#
Forth
Frink
Groovy
JavaScript
Lisp
Elixir
Lua
Nim
Perl
PHP
Python
Rebol
Ruby
Rust
SAS
Smalltalk
, and
Tcl
), then techniques can be used to perform metaprogramming without generating source code.
One style of generative approach is to employ
domain-specific languages
(DSLs). A fairly common example of using DSLs involves generative metaprogramming:
lex
and
yacc
, two tools used to generate
lexical analysers
and
parsers
, let the user describe the language using
regular expressions
and
context-free grammars
, and embed the complex algorithms required to efficiently parse the language.
Code instrumentation
edit
One usage of metaprogramming is to instrument programs in order to do
dynamic program analysis
Challenges
edit
Some argue that there is a sharp learning curve to make complete use of metaprogramming features.
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.
Due to this, some believe
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
edit
Macro systems
edit
Main article:
Macro (computer science)
Lisp
, most dialects
Clojure
Common Lisp
Racket
Scheme
hygienic macros
MacroML
Template Haskell
Scala
Nim
Rust
Haxe
Julia
Elixir
Macro assemblers
edit
Main article:
Macro assembler
The
IBM/360
and derivatives had powerful
macro assembler
facilities that were often used to generate complete
assembly language
programs
citation needed
or sections of programs (for different operating systems for instance). Macros provided with
CICS
transaction processing
system had assembler macros that generated
COBOL
statements as a pre-processing step.
Other assemblers, such as
MASM
, also support macros.
Metaclasses
edit
Main article:
Metaclass
Metaclasses
are provided by the following programming languages:
Common Lisp
10
Python
NIL
Groovy
Ruby
Smalltalk
Lua
Template metaprogramming
edit
Main article:
Template metaprogramming
, using
X Macros
C++
, using
templates
11
Common Lisp
Scheme
and most Lisp dialects by using the quasiquote ("backquote") operator.
12
Nim
Staged metaprogramming
edit
Main article:
Multi-stage programming
MetaML
MetaOCaml
Scala
natively
or using the Lightweight Modular Staging Framework
13
14
Terra
Dependent types
edit
Main article:
Dependent type
Use of
dependent types
allows proving that generated code is never invalid.
15
However, this approach is leading-edge and rarely found outside of research programming languages.
Implementations
edit
The list of notable metaprogramming systems is maintained at
List of program transformation systems
See also
edit
Aspect weaver
Comparison of code generation tools
Compile-time function execution
Genetic programming
Homoiconicity
Instruction set simulator
Interpreted language
Machine learning
Metacompiler
Metaobject
Partial evaluation
Reflective programming
, also compile time reflection
Self-interpreter
Self-modifying code
Source code generation
Transcompiler
(also known as transpilation)
Very-large-scale integration
Halting problem
References
edit
Sondergaard, Harald (2013).
"Course on Program Analysis and Transformation"
. Retrieved
18 September
2014
Czarnecki, Krzysztof
; Eisenecker, Ulrich W. (2000).
Generative Programming
. Addison Wesley.
ISBN
0-201-30977-7
Walker, Max.
"The Art of Metaprogrmming in Java"
New Circle
. Retrieved
28 January
2014
Krauss, Aaron.
"Programming Concepts: Type Introspection and Reflection"
. Archived from
the original
on 10 March 2016
. Retrieved
10 March
2016
Joshi, Prateek (5 April 2014).
"What Is Metaprogramming? – Part 2/2"
Perpetual Enigma
. Retrieved
14 August
2014
for example, instance_eval in
Ruby
takes a string or an anonymous function.
"Class BasicObject Ruby 3.5"
"Art of Metaprogramming"
IBM
Bicking, Ian.
"The challenge of metaprogramming"
IanBicking.org
. Retrieved
21 September
2016
Terry, Matt (21 August 2013).
"Beware of Metaprogramming"
Medium.com
. Medium Corporation
. Retrieved
21 August
2014
Through
Common Lisp Object System
's "Meta Object Protocol"
"C++ Template Metaprogramming"
aszt.inf.elte.hu
. Retrieved
2022-07-23
Lisp (programming language)
"Self-evaluating forms and quoting", quasi-quote operator.
"LMS: Program Generation and Embedded Compilers in Scala"
scala-lms.github.io
. Retrieved
2017-12-06
Rompf, Tiark; Odersky, Martin (June 2012).
"Lightweight Modular Staging: A Pragmatic Approach to Runtime Code Generation and Compiled DSLs"
Communications of the ACM
55
(6):
121–
130.
doi
10.1145/2184319.2184345
ISSN
0001-0782
S2CID
52898203
Chlipala, Adam (June 2010).
"Ur: statically-typed metaprogramming with type-level record computation"
(PDF)
ACM SIGPLAN Notices
. PLDI '10.
45
(6):
122–
133.
doi
10.1145/1809028.1806612
. Retrieved
29 August
2012
External links
edit
c2.com Wiki: Metaprogramming article
Meta Programming
on the Program Transformation Wiki
Code generation Vs Metaprogramming
"Solenoid"
: The first metaprogramming framework for
eXist-db
This article may
require
cleanup
to meet Wikipedia's
quality standards
. The specific problem is:
archive-org link links to unrelated maybe-spam site, unclear if legitimate bit rot or malice.
Please help
improve this article
if you can.
April 2025
Learn how and when to remove this message
Programming paradigms
Imperative
Structured
Jackson structures
Block-structured
Modular
Non-structured
Procedural
Programming in the large and in the small
Invariant-based
Nested function
Object-oriented
Class-based
Prototype-based
Object-based
Agent
Immutable object
Persistent
Uniform function call syntax
Declarative
Functional
Recursive
Anonymous function
Partial application
Higher-order
Purely functional
Total
Strict
GADTs
Dependent types
Functional logic
Point-free style
Expression-oriented
Applicative
Concatenative
Function-level
Value-level
Monad
Dataflow
Flow-based
Reactive
Functional reactive
Signals
Streams
Synchronous
Logic
Abductive logic
Answer set
Constraint
Constraint logic
Inductive logic
Nondeterministic
Ontology
Probabilistic logic
Query
Domain-
specific
language
(DSL)
Algebraic modeling
Array
Automata-based
Action
Command
Spacecraft
Differentiable
End-user
Grammar-oriented
Interface description
Language-oriented
List comprehension
Low-code
Modeling
Natural language
Non-English-based
Page description
Pipes
and
filters
Probabilistic
Quantum
Scientific
Scripting
Set-theoretic
Simulation
Stack-based
System
Tactile
Templating
Transformation
Graph rewriting
Production
Pattern
Visual
Concurrent
parallel
Actor-based
Automatic mutual exclusion
Choreographic programming
Concurrent logic
Concurrent constraint logic
Concurrent OO
Macroprogramming
Multitier programming
Organic computing
Parallel programming models
Partitioned global address space
Process-oriented
Relativistic programming
Service-oriented
Structured concurrency
Metaprogramming
Attribute-oriented
Automatic
Inductive
Dynamic
Extensible
Generic
Homoiconicity
Interactive
Macro
Hygienic
Metalinguistic abstraction
Multi-stage
Program synthesis
Bayesian
by demonstration
by example
vibe coding
Reflective
Self-modifying code
Symbolic
Template
Separation
of concerns
Aspects
Components
Data-driven
Data-oriented
Event-driven
Features
Literate
Roles
Subjects
Comparisons/Lists
Comparison
multi-paradigm
object-oriented
functional
),
List
OO
by type
Types of programming languages
Level
Machine
Assembly
Compiled
Interpreted
Low-level
High-level
Very high-level
Esoteric
Generation
First
Second
Third
Fourth
Fifth
Retrieved from "
Categories
Metaprogramming
Programming paradigms
Hidden categories:
Articles with short description
Short description matches Wikidata
Articles needing additional references from August 2011
All articles needing additional references
Wikipedia articles with style issues from February 2017
All articles with style issues
Articles with multiple maintenance issues
All articles with unsourced statements
Articles with unsourced statements from August 2011
Articles needing cleanup from April 2025
All pages needing cleanup
Cleanup tagged articles with a reason field from April 2025
Wikipedia pages needing cleanup from April 2025
Metaprogramming
Add topic