Showing papers by "Gregor Kiczales published in 1993"

Metaobject protocols: why we want them and what else they can do

Abstract: All rights reserved. No part of this book may be reproduced in any form by any electronic or mechanical means (including photocopying, recording, or information storage and retrieval) without permission in writing from the publisher. Originally conceived a s a n e at idea that could help solve problems in the design and implementation of CLOS, the metaobject protocol framework now appears to have applicability to a wide range of problems that come up in high-level languages. This chapter sketches this wider potential, by drawing an analogy to ordinary language design, by presenting some early design principles, and by presenting an overview of three new metaobject protcols we have designed that, respectively, control the semantics of Scheme, the compilation of Scheme, and the static parallelization of Scheme programs.

The need for customizable operating systems

Abstract: Although modern operating systems provide powerful abstractions to application programs, they often fail to implement those abstractions in a way that provides applications programs, especially specialized application programs, with the best utilization of the physical resources of the computer system. The operating system community has implicitly recognized this problem by providing mechanisms that give client programmers more access to the physical substrate. The Mach External Pager allows clients to replace the paging mechanism. More recent work allows client replacement of the paging policy as well. Scheduler activations share the job of thread management between clients and the system. Apertos allows these and other aspects of operating system implementation to be client-controlled. Object-oriented operating systems under development also provide these kinds of control. We contend that there is a very general issue here, which operating systems have been among the first kinds of software to have to face head-on: some implementation decisions are crucial strategy decisions whose resolution will invariably bias the performance of the resulting implementation. Explicitly recognizing this issue helps to make sense of current trends and suggests new directions to explore. We consider the implications of this issue for operating systems, providing a framework with which to analyze systems such as those mentioned above, and suggesting connections with similar problems in other domains. >

Operating systems: why object-oriented?

Abstract: The implementor of an operating system service faces inherent dilemmas in choosing implementation strategies. A new approach to operating system design is emerging in which, rather than attempting to hide these dilemmas, they are exposed to clients, using a meta-protocols. Object-oriented programming techniques play an important role in enabling meta-protocols to expose these dilemmas to the client in a principled and modular fashion. >

Traces (A Cut at the Make Isn't Generic Problem)

Abstract: Object-oriented techniques are a powerful tool for making a system end-programmer specializable. But, in cases where the system not only accepts objects as input, but also creates objects internally, specialization has been more difficult. This has been referred to as the “make isn't generic problem.” We present a new object-oriented language concept, called traces, that we have used successfully to support specialization in cases that were previously cumbersome.

Efficient method dispatch in PCL

Abstract: Permission to make digital or hard copies of part or all 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, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from Publications Dept, ACM Inc., fax +1 (212) 869-0481, or permissions@acm.org.

What A Metaobject Protocol Based Compiler Can Do For Lisp

Abstract: A new kind of metaobject protocol, that controls the compilation of programs, allows users toparticipatein the compilation in a principled and modular way. Such a compiler makes it possi-ble to program in a high-level language and still maintain control over crucial implementationissues. This result is that a number of simple and elegant Scheme programs can be compiled asefficiently as if they had been written with special purpose primitives. 1 Introduction Considera worldinwhichyougettohaveyourcake and eatittoo. Youdoyourday-to-dayprogram-mingin a high-levellanguagelikeLisp,thatprovidesyouwithpowerful abstractionsandallowsyouto write your programs in a principled and modular way. But, on those crucial occasions where itis important that an abstraction be implemented in a particular way, you get to help the compilerachieve that end, also in a principled and modular way. In this world, you get to enjoy the benefitsof high-level abstraction without paying traditional performance, interoperability and functionalitycosts.In thispaper, we will showhow a proof-of-conceptmetaobject protocolbased compiler we havedeveloped for Scheme allows programmers to cleanly, concisely and portably code the followingexamples, and have them work as efficiently and as robustly as if they had been implemented prim-itively: