Metaobject
From Wikipedia, the free encyclopedia
This article does not cite any references or sources. Please help improve this article by adding citations to reliable sources (ideally, using inline citations). Unsourced material may be challenged and removed. (November 2007) |
This article should be divided into sections by topic, to make it more accessible. Please help by adding section headings in accordance with Wikipedia's style guidelines. |
In computer science, a metaobject or meta-object is any entity that manipulates, creates, describes, or implements other objects. The object that the metaobject is about is called the base object. Some information that a metaobject might store is the base object's type, interface, class, methods, attributes, variables, functions, control structures, etc.
A metaobject protocol (MOP) is an interpreter of the semantics of a program that is open and extensible. Therefore, a MOP determines what a program means and what its behavior is, and it is extensible in that a programmer (or metaprogrammer) can alter program behavior by extending parts of the MOP. The MOP exposes some or all internal structure of the interpreter to the programmer. The MOP may manifest as a set of classes and methods that allow a program to inspect the state of the supporting system and alter its behaviour. MOPs are implemented as object-oriented programs where all objects are metaobjects.
MOPs may be runtime or compile time. The metaobjects of runtime MOPs exist while the program itself is executed. The metaobjects of compile-time MOPs, however, exist only when the program is compiled. They may alter or extend the compiling process, but do not exist when the program is running.
One of the best-known runtime MOPs is the one described in the book The Art of the Metaobject Protocol; it applies to the Common Lisp Object System (CLOS) and allows the mechanisms of inheritance, method dispatch, class instantiation and so on to be manipulated.
A good example of a compile-time MOP is OpenC++.
One example use of a MOP is to alter the implementation of multiple inheritance. A recurring issue is how to resolve conflicting slots and methods of the superclasses. Typically, language designers select one solution, and language users must live with it. Instead, a metaobject protocol makes it possible to change the rules of inheritance and choose a different solution for individual classes.
A metaobject protocol is one way to implement aspect-oriented programming languages. Many of the early founders of MOPs, including Gregor Kiczales have since moved on to be the primary advocates for aspect-oriented programming.
[edit] See also
- CLOS
- Javassist
- Joose JavaScript meta object system
- Moose Perl meta object system
- OpenC++
- OpenJava
- Unified Modeling Language: UML
- Groovy (programming language)
- Ruby (programming language)
- Python (programming language)
- Perl6 (programming language)
[edit] References
- Gregor Kiczales, Jim Des Rivieres, Daniel G. Bobrow: The Art of the Metaobject Protocol, MIT Press, 1991, ISBN 0-262-11158-6 or ISBN 0-262-61074-4
[edit] External links
- The guile MOP specification (tiny clos)
- Metaobjects and the Metaobject Protocol
- The Common Lisp Object System MetaObject Protocol (contains two chapters from The Art of the Metaobject Protocol)