computation. An Obliq computation may involve multiple threads of control within an address space, multiple address spaces on a machine, heterogeneous machines over a local network, and multiple networks over the Internet. Obliq objects have state and are local to a site. Obliq computations can roam over the network, while maintaining network connections.

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 appealing to definitions of abstractions. In a similar way, the graphical interface puts the user into a uniform world of tangible objects that can be directly manipulated and changed without switching modes. The implementation strives to support the world-of-objects illusion by minimizing perceptible pauses and by providing true source-level semantics without sacrificing performance. As a side benefit, it encourages factoring. Although we see areas that fall short of the vision, on the whole, the language, interface, and implementation conspire so that the Self programmer lives and acts in a consistent and malleable world of objects.

This paper's primary aim is to improve the understanding of the delegation mechanism as defined in [18]. We propose a new characterization of delegation based on the notions of name sharing, property sharing and value sharing. It allows us (1) to clearly differentiate delegation from classinheritance in particular and more generally from other inheritance mechanisms and (2) to explain how a founded use of delegation relies on a correct semantics of variable property sharing between objects connected by a delegation link. We then describe a model of split objects which is proposed as an example of a disciplined and semantically founded use of delegation, where property sharing expresses viewpoints within objects. 1 Introduction All kinds of inheritance mechanisms in objectoriented programming or representation languages, despite their diversities [5, 26], have at least the following common points [11]: ffl They are based on a relation I between objects or between concepts (for exampl...

In this paper we take a rather unusual, non-technical approach and investigate object-oriented programming and the prototype-based programming field from a purely philosophical viewpoint. Some historical facts and observations pertaining to objects and prototypes are presented, and conclusions based on those observations are derived.

This paper explores an alternative called compact dispatch tables suited to environments with high requirements in time and space efficiency. Compact dispatch tables are one solution to achieve fast, and constant-time, message passing in dynamically typed languages and to bring them one step closer to the efficiency of statically typed languages

Interobject references in object-oriented programs allow arbitrary aliases between objects. By breaching objects' encapsulation boundaries, these aliases can make programs hard to understand and especially hard to debug. We propose using an explicit, run-time notion of object ownership to control aliases between objects in dynamically typed languages. Dynamically checking object ownership as a program runs ensures the program maintains the encapsulation topology intended by the programmer. 1:

Although spreadsheets can be argued to be the most widely-used visual programming languages (VPLs) today, most are very limited compared to other VPLs, supporting only a few built-in types and offering only primitive support for code reuse. The inheritance mechanisms of object-oriented programming might seem to offer help for the latter problem, but incorporating these mechanisms in a traditional way would introduce concepts foreign to spreadsheets, such as message passing. In this paper, we present similarity inheritance, a new approach to inheritance that is suitable for seamless integration into the spreadsheet paradigm. We first explain the model independently of any implementation, and then present a prototype implementation in the research spreadsheet VPL Forms/3. We show that bringing inheritance functionality to the spreadsheet paradigm can be done using the widely-understood idea of copy/paste. Further, we show why the approach requires the presence of a live, visual environme...

Several architectures are defined for distributed systems management, most of which stem from the network management domain. They all share the idea of multiple models, at least comprising an information model, a communication model, and a functional model. Configuration management is part of the functional model but is very dependent on the information model. Due to its history in network management, the information model itself is mostly restricted to describe a priori known properties of hardware entities or software entities closely bound to the hardware point of view. Modeling the dynamic relationships of distributed systems and applications with such a model is hard if not impossible. Therefore we propose a new information model that focuses on the dynamic description of distributed systems. By using object-oriented technologies such as a prototype-instance model, it is well suited for the actual demands of system administration. Since we do not explicitly combine it with a particular distribution mechanism, it is orthogonal to any given or future communication model. We present an exemplary case study in the analysis to our approach, and we describe the design and implementation of our model.

The object-oriented programming language design space consists of class-based and prototype-based languages. Both language families have been shown to posses many advantages but also several disadvantages with respect to software construction. Hybrid languages featuring both prototype-based and class-based mechanisms have been proposed as a solution. Unfortunately these languages not only unify the advantages but also the disadvantages of both families. In this paper we propose a more intersectional point of view and propose a language that inherits the advantages but shuns the disadvantages of both families.

Prototype-based languages are often described as being more flexible and expressive than class-based languages. This greater flexibility makes prototype-based languages well-suited for rapid prototyping and exploratory programming, but comes with a serious loss of safety. Examples of this are the encapsulation problem and the prototype corruption problem most prototype-based languages suffer from. These problems preclude prototypebased languages from being widely used. We propose a prototype-based language that eliminates these problems and thus reintroduces safety in prototype-based languages.