David Ungar

Apple Inc.

We identify three design principles for reflection and metaprogramming facilities in object oriented programming languages. Encapsulation: meta-level facilities must encapsulate their implementation. Stratification: meta-level facilities must be separated from base-level functionality. Ontological correspondence: the ontology of meta-level faciliti...

Korz is a new computational model that provides for context-oriented programming by combining implicit arguments and multiple dispatch in a slot-based model. This synthesis enables the writing of software that supports contextual variation along multiple dimensions, and graceful evolution of that software to support new, unexpected dimensions of va...

Korz is a new computational model that provides for context-oriented programming by combining implicit arguments and multiple dispatch in a slot-based model. This synthesis enables the writing of software that supports contextual variation along multiple dimensions, and graceful evolution of that software to support new, unexpected dimensions of va...

A method (and system) includes providing a memory including a plurality of named locations each holding a value and introducing at least one freshener. The at least one freshener chooses one of the plurality of named locations and re-computes its value.

We introduce the domain of enterprise context, as opposed to personal or execution context, and we present requirements for context-oriented programming technology arising out of this broader notion of context. We illustrate enterprise context with scenarios in which data from across an enterprise, as well as data from outside an enterprise, are al...

Even the simplest hardware, running the simplest programs, can behave in the strangest of ways. Tracking down the cause of a performance anomaly without the complete hardware reference of a processor is a prime example of black-box architectural exploration. When doubling the work of a simple benchmark program, that was run on a single core of Tile...

Let throughput denote the amount of application-level work performed in unit time, normalized to the amount of work that would be accomplished with perfect linear scaling. Let latency denote the mean time required for a thread on one core to observe a change effected by a thread on another core, normalized to the best latency possible for the given...

Massively-parallel systems are coming: core counts keep rising whether conventional cores as in multicore and manycore systems, or specialized cores as in GPUs. Conventional wisdom has been to utilize this parallelism by reducing synchronization to the minimum required to preserve determinism in particular, by eliminating data races. However, Amdah...

Most of the mainstream programming languages in use today originated in the 70s and 80s. Even the scripting languages in growing use today tend to be based on paradigms established twenty years ago. Does the arrival of multicore, manycore, and cloud computing mean that we need to establish a new set of programming languages with new paradigms, or s...

Current compilers are still largely ignorant of the scheduling of parallel tasks at runtime. Without this information, however, they have difficulties optimizing and verifying concurrent programs. In this paper, we present a programming model where the ...

We believe that embracing nondeterminism and harnessing emergence have great potential to simplify the task of programming manycore processors. To that end, we have designed and implemented Ly, pronounced "Lee", a new parallel programming language built around two new concepts: (i) ensembles which provide for parallel execution and replace all coll...

In order to construct a test-bed for investigating new programming paradigms for future "manycore" systems (i.e. those with at least a thousand cores), we are building a Smalltalk virtual machine that attempts to efficiently use a collection of 56-on-chip caches of 64KB each to host a multi-megabyte object heap. In addition to the cost of inter-cor...

Point Argument: "Dynamic Languages (in Reactive Environments) Unleash Creativity," by David Ungar. For the sake of creativity, the profession needs to concentrate more on inventing new and better dynamic languages and environments and less on improving static languages. Counterpoint Argument: "Explicitly Declared Static Types: The Missing Links," b...

Can virtual machine developers benefit from religiously observing the principles more often embraced for exploratory programming? To find out, we are concurrently constructing two artifacts--a Self VM entirely in Self (the Klein VM), and a specialized development environment--with strict adherence to pure object-orientation, metacircularity, heavy...

We identify three design principles for reflection and metaprogramming facilities in object oriented programming languages. Encapsulation: meta-level facilities must encapsulate their implementation. Stratification: meta-level facilities must be separated from base-level functionality. Ontological correspondence: The ontology of meta-level faciliti...

We identify three design principles for reflection and metaprogramming facilities in object oriented programming languages. Encapsulation : meta-level facilities must encapsulate their implementation. Stratification : meta-level facilities must be separated from base-level functionality. Ontological correspondence : the ontology of meta-level facil...

Dynamically-typed object-oriented languages please programmers, but their lack of static type information penalizes performance. Our new implementation techniques extract static type information from declaration-free programs. Our system compiles several copies of a given procedure, each customized for one receiver type, so that the type of the rec...

Self is a minimalist object-oriented language with a sophisticated implementation that utilizes adaptive optimization. We have built implementations of Smalltalk and Java by translation to Self. These implementations were much easier to construct in Self than by conventional means, and perform surprisingly well (competitively with conventional, com...

Previous studies have shown that object-oriented programs have different execution characteristics than procedural programs, and that special object-oriented hardware can improve performance. The results of these studies may no longer hold because compiler optimizations can remove a large fraction of the differences. Our measurements show that Self...

this article appeared at PLDI '94 and OOPSLA '94. This work was performed while the first author was with Stanford University and Sun Microsystems Laboratories. The first author has been generously supported by Sun Microsystems Laboratories. The SELF project has been supported by Sun Microsystems, National Science Foundation PYI grant CCR-8657631,...

Data Types. In Proceedings of the ACM SIGPLAN Conference on Very High Level Languages, pp. 50-59, April, 1974. Published as SIGPLAN Notices 9(4), 1974. [LSAS77] Barbara Liskov, Alan Snyder, Russell Atkinson, and J. Craig Schaffert. Abstraction Mechanisms in CLU. In Communications of the ACM 20(8), pp. 564-576, August, 1977. [LAB+81] Barbara Liskov,...

An abstract is not available.

SELF is an object-oriented language for exploratory programming based on a small number of simple and concrete ideas: prototypes, slots, and behavior. Prototypes combine inheritance and instantiation to provide a framework that is simpler and more flexible than most object-oriented languages. Slots unite variables and procedures into a single const...

: Polymorphic inline caches (PICs) provide a new way to reduce the overhead of polymorphic message sends by extending inline caches to include more than one cached lookup result per call site. For a set of typical object-oriented SELF programs, PICs achieve a median speedup of 11%. As an important side effect, PICs collect type information by recor...

In the past, object-oriented language designers and programmers have been forced to choose between pure message passing and performance. Last year, our SELF system achieved close to half the speed of optimized C but suffered from impractically long compile times. Two new optimization techniques, deferred compilation of uncommon cases and non-backtr...

We have developed and implemented techniques that double the performance of dynamically-typed object-oriented languages. Our SELF implementation runs twice as fast as the fastest Smalltalk implementation, despite SELF's lack of classes and explicit variables. To compensate for the absence of classes, our system uses implementation-level maps to tra...

This paper describes the approach we have taken with the design of the user interface for SELF. Detailed description of the language and implementation can be found in [1, 2, 6, 11]. Our prototype user interface for SELF provides browsing and inspecting of SELF objects by combining an object-based model with an artificial reality. Emphasizing the p...

Integrated, dynamically-typed object-oriented programming environments offer many advantages, but have trouble producing small, self-contained applications. Recent advances in type inference have made it possible to build an application extractor for Self. The extractor was able to extract a mediumsized application in a few minutes. The extracted a...

Object-oriented languages such as Java and Smalltalk provide a uniform object reference model, allowing objects to be conveniently shared. If implemented directly, these uniform reference models can suffer in efficiency due to additional memory dereferences ...

Introduction For the past few years, researchers have been debating the relative merits of object-oriented languages with classes and inheritance as opposed to those with prototypes and delegation. It has become clear that the object-oriented programming language design space is not a dichotomy. Instead, we have identified two fundamental mechanism...

A good user interface brings the end user face-to-face with whatever is being manipulated and experienced. The article discusses about the experience of immediacy in a programming environment which draws the programmer closer to the program. In such cases debugging is easier. The principle of immediacy can serve as a guide, keeping builders of prog...

Computers enables programmers to fashion their own universes, choosing their own sets of "physical laws." Although, may computer-based systems seem to have their physics well debugged. Some collaborative virtual environments allow their users to "program" For example, LambdaMOO at Xerox PARC allows users to make new kinds of objects with new behavi...

. The Self system attempts to integrate intellectual and non-intellectual aspects of programming to create an overall experience. The language semantics, user interface, and implementation each help create this integrated experience. The language semantics embed the programmer in a uniform world of simple objects that can be modified without appeal...

Most object-oriented languages are objective: an object always responds to the same message in the same way. Subjective objects more closely match naturally occurring systems, and they provide consistent solutions to a wide range of problems, problems that otherwise must be solved by varied and specialized mechanisms. Applying a perspective-receive...

Dynamically dispatched calls often limit the performance of object-oriented programs, since object-oriented programming encourages factoring code into small, reusable units, thereby increasing the frequency of these expensive operations. Frequent calls not only slow down execution with the dispatch overhead per se, but more importantly they hinder...

In Self 4.0, people write programs by directly constructing webs of objects in a larger world of objects. But in order to save or share these programs, the objects must be moved to other worlds. However, a concrete, directly constructed program is incomplete, in particular missing five items of information: which module to use, whether to transport...

Manipulating programs is hard, while manipulating objects in the physical world is often easy. Several attributes of the physical world help make it comprehensible and manipulable: concreteness, uniformity, and flexibility. The Self programming system attempts to apply these attributes to the world within the computer. The semantics of the language...

Manipulating programs is hard, while manipulating objects in the physical world is often easy. Several attributes of the physical world help make it comprehensible and manipulable: concreteness, uniformity, and flexibility. The Self programming system attempts to apply these attributes to the world within the computer. The semantics of the language...

The Self system attempts to integrate intellectual and nonintellectual aspects of programming to create an overall experience. The language semantics, user interface, and implementation each help create this integrated experience. The language semantics embed the programmer in a uniform world of simple objects that can be modified without appealing...

Previous studies have shown that object-oriented programs have different execution characteristics than procedural programs, and that special object-oriented hardware can improve performance. The results of these studies may no longer hold because compiler optimizations can remove a large fraction of the differences. Our measurements show that SELF...

Subjectivity in object-oriented systems is a new research area. At this, the first workshop in this area, there was much discussion of fundamental concepts and issues, as well as of perceived needs for subjectivity and models for realizing it. The discussion is summarized here, and a list of issues that were identified during the workshop is presen...

Integrated, dynamically-typed object-oriented programming environments offer many advantages, but have trouble producing small, self-contained applications. Recent advances in type inference have made it possible to build an application extractor for Self. The extractor was able to extract a medium-sized application in a few minutes. The extracted...

Programming systems should be both responsive (to support rapid development) and efficient (to complete computations quickly). Pure object-oriented languages are harder to implement efficiently since they need optimization to achieve good performance. Unfortunately, optimization conflicts with interactive responsiveness because it tends to produce...

Abstrach Object-oriented programs are difficult to optimize because they execute many dynamically-dispatched calls. These calls cannot easily be eliminated because the compiler does not know which callee will be invoked at runtime. We have developed a simple technique that feeds back type information from the runtime system to the compiler. With th...

User interfaces are often based on static presentations, a model ill suited fcr conveying change. Consequently, events on the screen frequently startle and confime users. Cartoon animation, in contrast is exceedingly successful at engaging its audience; even the most bizarre events are easily comprehended. The Self user interface has served as a te...

This tutorial is for those who like to know how object-oriented languages work under the hood, why some things are expensive while other things are cheap, and why language definitions include certain restrictions. This tutorial provides that, and more. It describes features of object-oriented languages that are difficult to implement efficiently, a...

Many editors use the graphics capabilities of personal workstations to provide a visual editing environment. Such editors present graphical representations of familiar objects and allow the user to manipulate the representations directly. This style of interaction is usually more intuitive to the user than typing statements in a command language. H...

The Self programming language, which distills object-oriented computation down to a simple story based on copying prototypes to create objects, inheriting from objects to share their contents, and passing messages to invoke methods, is discussed. It is shown that Self's uniform application of the object-message paradigm gives programmers unusual fl...

SELF's debugging system provides complete source-level debugging (expected behavior) with globally optimized code. It shields the debugger from optimizations performed by the compiler by dynamically deoptimizing code on demand. Deoptimization only affects the procedure activations that are actively being debugged; all other code runs at full speed....

One of the more promising automatic storage reclamation techniques, generation scavenging, suffers poor performance if many objects live for a fairly long time and then die. We have investigated the severity of this problem by simulating a two-generation scavenger using traces taken from actual 4-h sessions. There was a wide variation in the sample...

Many interactive computing environments provide automatic storage reclamation and virtual memory to ease the burden of managing storage. Unfortunately, many storage reclamation algorithms impede interaction with distracting pauses. Generation Scavenging is a reclamation algorithm that has no noticeable pauses, eliminates page faults for transient o...

Efficient Implementation of Object-Oriented Programming Languages Craig Chambers, University of Washington, David Ungar, Sun Labs This tutorial is for those who like to know how object-oriented languages work under the hood, why some things are expensive while other things are cheap, and why language definitions include certain restrictions. This...

series of exorcisms. The very first collector I built was a classical reference-counting collector. It introduced me to two devils: unreclaimed circular structures and high overhead. Inspired by Peter Deutsch and Dave Patterson I sought to banish these devils by investigating Generation Scavenging with a trace-driven simulation. At that time, it ap...

Polymorphic inline caches (PICs) provide a new way to reduce the overhead of polymorphic message sends by extending inline caches to include more than one cached lookup result per call site. For a set of typical object-oriented SELF programs, PICs achieve a median speedup of 11%. As an important side effect, PICs collect type information by recordi...

. All organizational functions carried out by classes can be accomplished in a simple and natural way by object inheritance in classless languages, with no need for special mechanisms. A single model---dividing types into prototypes and traits---supports sharing of behavior and extending or replacing representations. A natural extension, dynamic ob...

. The design of inheritance and encapsulation in SELF, an object-oriented language based on prototypes, results from understanding that inheritance allows parents to be shared parts of their children. The programmer resolves ambiguities arising from multiple inheritance by prioritizing an object's parents. Unifying unordered and ordered multiple in...

. Object-oriented languages have suffered from poor performance caused by frequent and slow dynamically-bound procedure calls. The best way to speed up a procedure call is to compile it out, but dynamic binding of object-oriented procedure calls without static receiver type information precludes inlining. Iterative type analysis and extended messag...

Object-oriented languages have suffered from poor performance caused by frequent and slow dynamically-bound procedure calls. The best way to speed up a procedure call is to compile it out, but dynamic binding of object-oriented procedure calls without static receiver type information precludes inlining. Iterative type analysis and extended message...

Dynamically-typed object-oriented languages please programmers, but their lack of static type information penalizes performance. Our new implementation techniques extract static type information from declaration-free programs. Our system compiles several copies of a given procedure, each customized for one receiver type, so that the type of the rec...

Abstract Object-oriented languages have suffe=d from poor performance caused by frequent and slow dynamically-bound procedure calls. The best way to speed up a procedure call is to compile it out, but dynamic binding of object-oriented procedure calls without static receiver type information preeludes inlining. Iterative type analysis and extended...

One of the most promising automatic storage reclamation techniques, generation-based storage reclamation, suffers poor performance if many objects live for a fairly long time and then die. We have investigated the severity of this problem by simulating Generation Scavenging automatic storage reclamation from traces of actual four-hour sessions. The...

We have adapted an interactive programming system (Smalltalk) to a multiprocessor (the Firefly). The task was not as difficult as might be expected, thanks to the application of three basic strategies: serialization, replication, and reorganization. Serialization of access to resources disallows concurrent access. Replication provides multiple inst...

An introduction is given to SELF, an object-oriented language for exploratory programming that is based on a small number of simple and concrete ideas: prototypes, slots and behavior. Prototypes combine inheritance and instantiation to provide a framework that is simpler and more flexible than most object-oriented languages. Slots unite variables a...

The Smalltalk On A RISC project at U. C. Berkeley proves that a high-level object-oriented language can attain high performance on a modified reduced instruction set architecture. The single most important optimization is the removal of a layer of interpretation, compiling the bytecoded virtual machine instructions into low-level, register-based, h...

The Smalltalk On A RISC project at U. C. Berkeley proves that a high-level object-oriented language can attain high performance on a modified reduced instruction set architecture. The single most important optimization is the removal of a layer of interpretation, compiling the bytecoded virtual machine instructions into low-level, register-based, h...

The Smalltalk On A RISC project at U. C. Berkeley proves that a high-level object-oriented language can attain high performance on a modified reduced instruction set architecture. The single most important optimization is the removal of a layer of interpretation, compiling the bytecoded virtual machine instructions into low-level, register-based, h...

The Smalltalk On A RISC project at U. C. Berkeley proves that a high-level object-oriented language can attain high performance on a modified reduced instruction set architecture. The single most important optimization is the removal of a layer of interpretation, compiling the bytecoded virtual machine instructions into low-level, register-based, h...

In anticipation of the promise of tremendous hardware advances, software researchers have fashioned expansive programming environments to improve programmer productivity. Even with the march of technology, exploratory programming environments such as Smalltalk-80 require such expensive computers that few programmers can afford them. With the hope o...

An abstract is not available.

We have implemented Smalltalk-80 on an instruction-level simulator for a RISC microcomputer called SOAR. Measurements suggest that even a conventional computer can provide high performance for Smalltalk-80 by abandoning the 'Smalltalk Virtual Machine' in favor of compiling Smalltalk directly to SOAR machine code, linearizing the activation records...

SOAR (Smalltalk on a RISC), a 32-bit microprocessor designed for the efficient execution of compiled Smalltalk, is described. The chip, implemented in 4-μm single-level metal NMOS technologies, has a cycle time of 400 ns. Pipelining allows an instruction to start each cycle with the exception of loads and stores. The processor contains 35700 transi...

A 32b microprocessor built specially to execute smalltalk will be presented. A 4μm NMOS implementation operates at 400ns per instruction and consists of 36K transistors in a die size of 320×432 mils.

The Smalltalk-80 sub TM system makes it possible to write programs quickly by providing object-oriented programming, incremental complication, run-time type checking, use-extensible data types and control structures, and an interactive graphical interface. However, the potential savings in programming effort have been curtailed by poor performance...

Smalltalk on a RISC (SOAR) is a simple, Von Neumann computer that is designed to execute the Smalltalk-80 system much faster than existing VLSI microcomputers. The Smalltalk-80 system is a highly productive programming environment but poses tough challenges for implementors: dynamic data typing, a high level instruction set, frequent and expensive...

Smalltalk on a RISC (SOAR) is a simple, Von Neumann computer that is designed to execute the Smalltalk-80 system much faster than existing VLSI microcomputers. The Smalltalk-80 system is a highly productive programming environment but poses tough challenges for implementors: dynamic data typing, a high level instruction set, frequent and expensive...

Many interactive computing environments provide automatic storage reclamation and virtual memory to ease the burden of managing storage. Unfortunately, many storage reclamation algorithms impede interaction with distracting pauses. Generation Scavenging is a reclamation algorithm that has no noticeable pauses, eliminates page faults for transient o...

Many interactive computing environments provide automatic storage reclamation and virtual memory to ease the burden of managing storage. Unfortunately, many storage reclamation algorithms impede interaction with distracting pauses. Generation Scavenging is a reclamation algorithm that has no noticeable pauses, eliminates page faults for transient o...

Smalltalk on a RISC (SOAR) is a simple, Von Neumann computer that is designed to execute the Smalltalk-80 system much faster than existing VLSI microcomputers. The Smalltalk-80 system is a highly productive programming environment but poses tough challenges for implementors: dynamic data typing, a high level instruction set, frequent and expensive...

This paper presents data about three facets of a recently-completed VLSI design containing 45000 transistors. The first set of data describes the mask-level features of the circuit, from which it is seen that almost all features have at least one small dimension. The second set of data analyzes the hierarchical cell structure used by the designers...