
	Where results make sense

Topic: Metaobject protocol

Related Topics

Kyoto Protocol

Transmission Control Protocol

User Datagram Protocol

communications protocol

The Protocols of the Elders of Zion

network protocol

Internet protocol suite

Point to Point Protocol

File transfer protocol

Simple Mail Transfer Protocol

Simple Object Access Protocol

In the News (Fri 25 Dec 09)

Northern Trust

Marvin Harrison

Peter Chernin

Gary Locke

Match Play

Penelope Cruz

Mickey Rourke

AR Rahman

Danny Boyle

Hugh Jackman

	[No title] (Site not responding. Last check: 2007-10-22)
		Metaobject protocols were originally defined as supplemental interfaces to programming languages that give users the ability to incrementally modify the language's behavior and implementation.
		The metaobject protocol approach, in contrast, is based on the idea that one can and should open languages up, allowing users to adjust the design and implementation to suit their particular needs.
		In a language based upon metaobject protocols, the language implementation itself is structured as an object-oriented program.
	www2.parc.com /csl/groups/sda/projects/mops/default.html (295 words)

	[No title]
		As the Metaobject Protocol is applied, CLOS itself is promoted to be the mechanism for dynamic extension [p 138].
		This is a key piece of the Metaobject Protocol, because object instantiation, introspection, and many of the operations on the object all depend on the class object.
		However, at times when the language itself needs to be extended, the metaobjects must be conditionally and methodically exposed, and the users will be allowed to participate in modifying the behavior of the language through their knowledge of the metaobjects from introspection.
	www.midy.com /~twong/meta (9260 words)

	The Art of the Metabobject Protocol - The MIT Press
		The authors, who developed the metaobject protocol and who were among the group that developed CLOS, introduce this new approach to programming language design, describe its evolution and design principles, and present a formal specification of a metaobject protocol for CLOS.
		One of the major benefits of including the metaobject protocol in programming languages is that it allows users to adjust the language to better suit their needs.
		In presenting the principles of metaobject protocols, the authors work with actual code for a simplified implementation of CLOS and its metaobject protocol, providing an opportunity for the reader to gain hands-on experience with the design process.
	mitpress.mit.edu /catalog/item/default.asp?ttype=2&tid=6091 (257 words)

	COOTS 2001 Paper
		Metaobject protocols and reflection are a good model for expressing such changes.
		Metaobject protocols provide abstractions of the runtime environment, and expose the protocols governing the execution in the runtime environment.
		The metaobject that specifies the code to be invoked when a method is executed can also be compiled and verified therefore reducing the possibility of coding errors.
	www.usenix.org /publications/library/proceedings/coots01/full_papers/welch/welch_html/index.html (5416 words)

	Metaobject Protocols Notes (Site not responding. Last check: 2007-10-22)
		A Metaobject protocol is a generalized and limited subset of the underlying implementation of the language.
		A layered protocol design is good for both meta and normal object protocols, and allows for a combinatorial explosion of customizations to be made to the protocol.
		The top level methods of a layered metaobject protocol are required to call certain methods to perform some tasks.
	unknownlamer.org /files/temp/metaobject_essay[d3].html (2013 words)

	ALU Wiki: Metaobject Protocol
		Lisp's "Metaobject Protocol" is not in the official standard; however it is a common feature in Lisp implementations.
		While the term "metaobject" may sound forbidding, it is only because objects are in general poorly explained in mainstream programming; it is no harder than many other concepts.
		In the above quote, metaobjects would correspond to "second intentions." Dogs and buildings are the concrete things which comprise "first intentions." If this seems confusing and recursive, keep in mind that the recursion is dealt with in the normal way &mdash through base cases.
	wiki.alu.org /Metaobject_Protocol (1122 words)

	[No title] (Site not responding. Last check: 2007-10-22)
		This is similar in concept to the metaobjects found in RbCl but in CodA the concepts are more clearly specified, and are generalized and applied to other meta-level objects such as the scheduler.
		Conceptually, an object's meta-level is not a single metaobject but rather a meta-definition or group of objects each of which defines a particular facet of the object's behaviour.
		Metaobject protocol object: anObject Get or set the receiver's denotation if the metaobject is capable of a one-to-one relationship with its denotations.
	www.laputan.org /pub/washington/text/mcaffer.txt (3674 words)

	29.1. Meta-Object Protocol
		Associated with each class metaobject is a list of direct slot definition metaobjects representing the slots defined directly in the class.
		Also associated with each class metaobject is a list of effective slot definition metaobjects representing the set of slots accessible in instances of that class.
		The elements of this set are class metaobjects that all mention this class among their direct superclasses.
	clisp.cons.org /impnotes/mop-chap.html (4460 words)

	MOP: Concepts
		The protocol followed by the metaobjects to provide the behavior of CLOS is called the CLOS Metaobject Protocol (MOP).
		The remainder of this chapter is intended to emphasize connections among the parts of the Metaobject Protocol, and to provide some examples of the kinds of specializations and extensions the protocols are designed to support.
		The exact point at which finalize-inheritance is called depends on the class of the class metaobject; for standard-class it is called sometime after all the classes superclasses are defined, but no later than when the first instance of the class is allocated (by allocate-instance).
	www.franz.com /support/documentation/8.0/doc/mop/concepts.html (7562 words)

	Amazon.co.uk: The Art of the Metaobject Protocol: Books (Site not responding. Last check: 2007-10-22)
		The authors, who developed the metaobject protocol and who were among the group that developed CLOS, introduce this approach to programming language design, describe its evolution and design principles, and present a formal specification of a metaobject protocol for CLOS.
		The authors show that the "art of metaobject protocol design" lies in creating a synthetic combination of object-orientated and reflective techniques that can be applied under existing software engineering considerations to yield a new approach to programming language design that meets a broad set of design criteria.
		One of the major benefits of including the metaobject protocol in programming languages is that it allows users to adjust the language to better suit their needs.
	www.amazon.co.uk /exec/obidos/ASIN/0262111586 (442 words)

	Abstract for SM Thesis (Site not responding. Last check: 2007-10-22)
		Under the metaobject protocol approach, a computation is parallelized by marking source code expressions with marks supported by the compiler.
		When the supported marks can not be used to express a desired mechanism for concurrency, the metaobject protocol is used to incrementally augment the compiler's parallelization strategy to support the desired mechanism.
		The metaobject protocol is a model of the compiler's parallelization strategy that provides the knowledge necessary to augment the strategy incrementally, without exposing arbitrary or irrelevant implementation details.
	www-swiss.ai.mit.edu /users/lhr/misc/papers-misc/abstract-SM-thesis.html (253 words)

	The art of the metaobject protocol
		Metaobject protocols are interfaces to the language that give users the ability to incrementally modify the language's behavior and implementation, as well as the ability to write programs within the language.
		In this way, a metaobject protocol allows users to adjust the language to better suit their needs.
		The presentation is based on a running implementation of a metaobject protocol.
	www.parc.com /research/publications/details.php?id=4562 (180 words)

	Goops Manual
		Node:Metaobjects and the Metaobject Protocol, Next:Terminology, Up:Introductory Remarks
		A method is a procedure and a set of specializers that specify the type of arguments to which the procedure is applicable.
		The "metaobject protocol" (aka "MOP") is the specification of the generic functions which determine the behaviour of these metaobjects and the circumstances in which these generic functions are invoked.
	www.gnu.org /software/guile/docs/goops/Metaobjects-and-the-Metaobject-Protocol.html (710 words)

	MetaObject Protocol (Site not responding. Last check: 2007-10-22)
		The benefit of this is that programmers can portably tailor CLOS to meet their specific programming needs, or even create their own Object Oriented language.
		The book The Art of the Metaobject Protocol, sometimes called the AMOP, includes the CLOS Metaobject Protocol specification as chapters 5 and 6.
		This document is not part of the ANSI standard for Common Lisp.
	www.alu.org /mop/index.html (116 words)

	A Metaobject Protocol for C++ - Chiba (ResearchIndex) (Site not responding. Last check: 2007-10-22)
		It avoids penalties on runtime performance by adopting a new meta-architecture in which the metaobjects control the compilation of programs instead of being active during program execution.
		1 Introduction A metaobject protocol (MOP) is an object-oriented...
		423 The Art of the Metaobject Protocol (context) - Kiczales, Rivieres et al.
	citeseer.ist.psu.edu /chiba95metaobject.html (658 words)

	Meta Object Protocol
		The core of the Metaobject Protocol is to replace the most basic constructs of a language (in the case of OO languages, this would consist of things like how polymorphism is defined, how to treat inheritance (multiple and single), etc.) and make them so they can be configured and changed.
		This is why a metaobject protocol is of interest to people working on AspectOrientedProgramming.
		It's a Meta Object Protocol, and garbage collection seems more low level and wider in scope than that (in other words those effects are system wide, not really [replacing] one or more of these objects with specialized ones to affect specific aspects of the implementation of specific parts of their program.
	c2.com /cgi/wiki?MetaObjectProtocol (1081 words)

	Putting Metaclasses to Work: A New Dimension in Object-Oriented Programming - $27.97
		The metaobject protocol is used to program new metaclasses that isolate reusable properties.
		Chapter 7 uses the metaobject protocol to create a new abstraction, the cooperative metaclass, which is used to attain composability of metaclasses.
		The combination of Chapters 6 and 7 is the entire metaobject protocol; the separation is for pedagogical purposes.
	www.awprofessional.com /bookstore/product.asp?isbn=0201433052&rl=1 (1572 words)

	Citations: Coarse-Grained Parallelism Using Metaobject Protocols - Jr (ResearchIndex) (Site not responding. Last check: 2007-10-22)
		....how metaobjects protocols can be used to provide the user control over the semantics, or behavior of a language.
		Thus, the metaobject protocol designer s role in this scenario is to provide logical and clean access points for a wide variety of possible semantic extensions (an interface for the language designer) 4 Derivation of Ploy s Protocol Ploy s basic structure closely resembles that of Anibus
		Especially, we took the basic protocol structure from the CLOS MOP [36] and we took the basic architecture from Lisp macros.
	citeseer.comp.nus.edu.sg /context/307008/430525 (1355 words)

	Blended The Art of the Metaobject Protocol (Site not responding. Last check: 2007-10-22)
		The philosophy behind the meta-object protocol is that different applications may require different kinds of object models, and so the object model itself should be subject to program control.
		The Art of the Meta-Object Protocol is useful for the advanced CLOS user as well as for anyone interested in object-oriented programming and language design.
		As a presentation of how to implement the Metaobject Protocol, this is about as authoritative a presentation of CLOS as can exist, short of being a formal (dry!) standards document.
	savebazar.com /P--MDI2MjYxMDc0NA%3D%3D-The+Art+of+the+Metaobject+Protocol.html (484 words)

	[No title]
		(If you are interested only in OO languages, and not metaobject protocols, you can skip the third, fourth and fifth paragraphs of this message.) One stumbling block for people interested in playing with the metaobject protocol (MOP) ideas has been the relative complexity of working in Common Lisp.
		The implementation is even simpler than the simple CLOS found in `The Art of the Metaobject Protocol,' weighing in at around 850 lines of code, including (some) comments and documentation.
		In fact, the slot access protocol used in this MOP is such that it should be possible to get better performance than is possible with the CLOS MOP.
	www.cs.cmu.edu /afs/cs.cmu.edu/project/gwydion-1/dylan-history/1992/12/00447 (781 words)

	IngentaConnect Adding Support for Persistence to CLOS via Its Metaobject Protoco... (Site not responding. Last check: 2007-10-22)
		By virtue of its metaobject protocol, CLOS is a language whose semantics can be tailored by individual programmers.
		We used the metaobject protocol to extend CLOS with support for object persistence.
		For many aspects of the implementation we found that the metaobject protocol was ideal.
	www.ingentaconnect.com /content/klu/lisp/1997/00000010/00000001/00134678 (257 words)

	[Progresearch] Presentation on the CLOS Metaobject Protocol (Site not responding. Last check: 2007-10-22)
		This gives programmers a way to extend its object model by introducing their own metaclasses and providing methods on specified generic functions that change important aspects of the object system for a well-defined scope.
		In this presentation, I will introduce the basic notions of that CLOS Metaobject Protocol (MOP) and illustrate its extensibility by implementing the Python object model as a metaclass [1] as an example.
		The contents of this presentation can be translated to other object systems that are based on similar metaobject protocols, like STklos, Swindle and Meroon for Scheme.
	prog.vub.ac.be /pipermail/progresearch/2005-March/000234.html (281 words)

	Goops Manual: Introductory Remarks
		GOOPS is an object-oriented programming system based on a "metaobject protocol" derived from the ones used in CLOS (the Common Lisp Object System), tiny-clos (a small Scheme implementation of a subset of CLOS functionality) and STKlos.
		GOOPS can be used by application authors at a basic level without any need to understand what the metaobject protocol (aka "MOP") is and how it works.
		Each of the following sections of the reference manual is arranged such that the most basic usage is introduced first, and then subsequent subsections discuss the related internal functions and metaobject protocols, finishing with a description of how to customize that area of functionality.
	www.seul.org /~grumbel/tmp/guile-1.6.0/goops_3.html (1396 words)

	CDR 1: The CLOS Metaobject Protocol (Site not responding. Last check: 2007-10-22)
		Other parts of the protocol, even though they have been implemented in one form or another in PCL and other implementations, are less well worked out.
		Work remains to improve not only the ease of use of these protocols, but also the balance they provide between user extensibility and implementor freedom.
		In preparing this specification, it is our hope that it will provide a basis for the users and implementors who wish to work with a metaobject protocol for CLOS.
	cdr.eurolisp.org /document/1 (379 words)

	Goops Manual
		For an introduction to metaobjects and the metaobject protocol, see 3.1.1 Metaobjects and the Metaobject Protocol.
		The aim of the MOP specification in this chapter is to specify all the customizable generic function invocations that can be made by the standard GOOPS syntax, procedures and methods, and to explain the protocol for customizing such invocations.
		When using this rule to decide whether a given generic function invocation is customizable, we ignore arguments that are expected to be handled in method definitions as a single "rest" list argument.
	www.delorie.com /gnu/docs/guile/goops_54.html (225 words)

	Amazon.com: The Art of the Metaobject Protocol: Books: Gregor Kiczales (Site not responding. Last check: 2007-10-22)
		The philosophy behind the meta-object protocol is that different applications may require different kinds of object models, and so the object model itself should be subject to program control.
		The Art of the Meta-Object Protocol is useful for the advanced CLOS user as well as for anyone interested in object-oriented programming and language design.
		As a presentation of how to implement the Metaobject Protocol, this is about as authoritative a presentation of CLOS as can exist, short of being a formal (dry!) standards document.
	www.amazon.com /Art-Metaobject-Protocol-Gregor-Kiczales/dp/0262610744 (1245 words)

	BurstProject: burst.MOP class Reference
		The term "MetaObject Protocol" (MOP) originates with Gregor Kiczales's work in implementing CLOS, the object system in Common Lisp.
		This is by no means a full MOP for ECMAScript, for reasons of time, need, and inadequacies in the base language that would make it prohibitively expensive at run time.
		A key requirement for a programming language to have a useful MOP is reflection, which has two important parts: introspection, the ability to query about objects and metaobjects, and intercession, the ability to "hook" or alter their runtime behavior.
	burstproject.org /build/apidoc/html/classburst_1_1MOP.html (1119 words)

	Allegro CL 6.2 Documentation Introduction and Overview
		Documentation for the MetaObject Protocol (MOP) is in mop/contents.html (the link is to the initial page).
		The files in the mop/ subdirectory are an HTML version of the description of the MetaObject Protocol in chapters 5 and 6 of The Art of MetaObject Protocol by G. Koczales, J. des Rivieres, and D. Brobrow.
		This document provides specific information about the implementation of Allegro CL. Many details of the Common Lisp standard are implementation-dependent (such as the number of distinct floating-point types and their mapping to machine floats, the largest fixnum, the implementation of random, etc.) and this document says what Allegro CL does.
	csce.unl.edu /cl/introduction.htm (6127 words)

Try your search on: Qwika (all wikis)