Search

CLIX is a parallel object oriented language that embodies communicating process model of object oriented programming. It incorporates the notion of objects with communications in distributed systems. The objects in CLIX are encapsulation of information and communication handlers that operate on the information in response to messages. The underlying communication system is modeled as a mail system. In addition to presenting an overview of CLIX, it is reviewed in terms of relevant issues in parallel object oriented programming. [ABSTRACT FROM AUTHOR]

We have investigated the concepts of inheritance and subtyping in order to integrate them in a parallel object-oriented language. In doing so, we have concluded that inheritance and subtyping are two different concepts, which should not be confused in any object-oriented language (be it parallel or sequential). Inheritance takes place on the implementation level of classes, and it is a convenient mechanism for code sharing. It can be supported, for example, by introducing inheritance packages into a programming language. Subtyping deals with the message interface of objects, and it leads to a conceptual hierarchy based on behavioural specialization. Subtyping should take place on the basis of specifications of the external behaviour of objects, and as much as possible of these specifications should be formal. Some specific problems with introducing these two concepts into a parallel language are also discussed. [ABSTRACT FROM AUTHOR]

We describe progress made within the FORK project, whose goals are the implementation of a primarily object-oriented knowledge representation system and its application to the design and fault diagnosis of technical systems. Whereas the kernel of the FORK representation system is completely object-oriented, the system as a whole is supposed to integrate a variety of different programming styles. In the following, an extension for rule-oriented programming is described, which raises the descriptive power of the FORK system beyond that of LOOPS. As an application of the rule-oriented component, a constraint language has been implemented which plays an important rule in our approach to the design and fault diagnosis of technical systems. The next steps in the FORK project will include the development of a general logical framework, comprising a logical reconstruction of object-centered representations, retrieval of complex descriptions by unification, and deductions on structured objects. The problem of non-monotonicity will be dealt with on the meta level by a module similar to DeKleer's ATMS. Further progress shall be achieved by concentrating on a general treatment of the problem of time in modelling technical systems which is to our opinion one of the most important issues. [ABSTRACT FROM AUTHOR]

We study here some problems yielded by multiple inheritance in object-oriented languages. We give an interpretation and a formalism of heritance mechanisms within the framework of partially ordered sets theory. An inheritance mechanism can be regarded as a traversing algorithm of the inheritance graph, and we prove that those which yields linear extension (total order) play a central role. We discuss some operational semantic aspects of multiple inheritance, with the introduction of a concept named by multiplicity. After a presentation of some well- known inheritance algorithms we propose two new algorithms based upon depth-first search techniques and some particular classes of linear extensions, recently studied. We end by applying these results in the case of inheritance with exceptions and by setting a few problems. All these results are implemented in the frame-based language YAFOOL. [ABSTRACT FROM AUTHOR]

Our Object Modeling Technique is a software engineering technique for collecting and representing information about requirements and designs. It enforces the object-oriented notions of modularity, separation of implementation details from external behavior, and abstract data types. We have successfully applied the Object Modeling Technique to support conceptual design, followed by implementation using both conventional programming languages and an object-oriented language. [ABSTRACT FROM AUTHOR]

A recent paper by Meyer compared the usefulness of Genericity and Inheritance as a basis fur static type checking in object oriented systems. Conformance is also being considered by some researchers, and Meyer's paper is reexamined here using Conformance. Some problems result related to the conformance of formal and actual parameters of operations. Additional rules for conformance are introduced to overcome these problem and these lead naturally to the concept of Enhancement as a union of the techniques of Conformance, Genericity and Inheritance. This work has been partially sponsored under the ESPRIT programme, in project 834 Comandos - Construction and Management of Distributed Office Systems. [ABSTRACT FROM AUTHOR]

The purpose of behavioral simulation is to simulate the behavior of the characters having behavior rules in the surrounding environment. This kind of simulation, which differs from the traditional simulation baaed on a statistical model of the world, provides us with a more precise simulation with regard to individuals. Because of the nature of behavioral simulation, characters, the environment in which the characters exist, and messages which are passed among characters, are the main elements that should be considered. The notion of object-orientation is one of the most attractive computational models for providing the basis of behavioral simulation. Specifically, we employ the notion of knowledge objects which are objects having knowledge contained within themselves. We fist establish a behavioral simulation model based on the notion of knowledge objects, then design and implement a behavioral simulation system PARADISE. To demonstrate the capability and effectiveness of this Simulation model, barracuda and herring school is used as an example of this simulation system. [ABSTRACT FROM AUTHOR]

The Common Lisp Object System is an object-oriented system that is based on the concepts of generic functions, multiple inheritance, and method combination. All objects in the Object System are instances of classes that form an extension to the Common Lisp type system. The Common Lisp Object System is based on a meta-object protocol that renders it possible to alter the fundamental structure of the Object System itself. The Common Lisp Object System has been proposed as a standard for ANSI Common Lisp and has been tentatively endorsed by X3J13. [ABSTRACT FROM AUTHOR]

The research reported in this paper is part of an ongoing effort to explore potential benefits of using new software technologies for various classes of system simulation. Queueing network scenarios have been chosen as the first area, of application. Our experiences in the use of two object-oriented simulators art described, using a simple example. Pose is a Scheme based queueing network simulator. It demonstrates the suitability of symbolic languages and exploratory programming for system simulation. Some characteristics of window-based and graphical programming environments are then briefly discussed, with reference to a Smalltalk-based simulation tool. The final chapter suggests that object-oriented simulation languages embedded in interactive modelling environments hosted on powerful workstations may well offer major breakthroughs in terms of user acceptance. The bandwidth of user/tool interfaces should be as wide as possible, drawing on modern techniques for graphical interaction and multi-process systems supporting the ‘desktop' metaphor. Use of Smalltalk permits quick and easy exploration of design alternatives through rapid prototyping. Embedding such tools in Scheme preserves their functionality while making them more accessible to a wider community. Computational efficiency, while a lesser concern to ‘modelling for insight', remains unsatisfactory in simulation for quantitative predictions. This problem may hopefully be overcome through future advances in software and hardware technologies. [ABSTRACT FROM AUTHOR]

The aim of this paper is to present a set of extensions to the Prolog language in order to insert in it concepts typical of parallel, distributed object-oriented systems. A program is a collection of objects (P-Units) that represent chunks of knowledge expressed as separate Prolog programs. P-units interact by asking for the demonstration of goals conceived as requests for operations. P-units can perform operations in parallel. Policies of interaction between objects, the creation of parallel activities, inheritance and delegation mechanisms are not frozen in the basic interpreter, but can be explicitly expressed in particular P-units that act as meta-objects. This approach enhances both the flexibility and reusability of the resulting object-oriented system. [ABSTRACT FROM AUTHOR]

Trellis/Owl is an object oriented programming language being developed as part of the Trellis programming environment by the Object Based Systems group within Corporate Research and Architecture at Digital Equipment Corporation's Hudson, MA facility. Trellis/Owl incorporates support for concurrency. Here we describe the high level language features designed, the rationale for that design, the implementation techniques used, the principles behind them, and experience with the resulting system to date. We show how the object oriented nature of Trellis/Owl influenced the design, and how it affected the implementation. [ABSTRACT FROM AUTHOR]

This article concerns generic tools for the construction of user interfaces: Application Frameworks and User Interface Management Systems (UIMS's). In this article, we propose a new taxonomy for these tools, identify their limitations and show how the object paradigm can be exploited to overcome the current deficiencies such as support for generality, context and distribution. This taxonomy is the result of our own experience in designing MOUSE, an object-oriented UIMS based on a general model, PAC, that can be applied at any level of abstraction of a user interface. PAC structures any component of an interactive application into three parts: the Presentation which defines the external behaviour, the Abstraction which corresponds to internal concepts and the Control which bridges the gap between the syntax and the semantics. [ABSTRACT FROM AUTHOR]

We describe a new approach to constructing user Interfaces by declaratively specifying the relation- ships between objects via filters. A filter Is a package of constraints dynamically enforced between a source object and a view object. For example, the relationship between an employee object in a database and a bitmap object represented on a display screen can be modelled as a filter. The object in the database can then be modified by manipulating the object on the screen, and changes made to the employee object by other programs are Instantly reflected on the screen. This paper describes a specification language for filters, an Implementation of filters with the aid of a constraint-satisfaction system, and a graphical Interface for designing filters. We illustrate the power and flexibility of the filter paradigm with an Interface example and show that it stimulates and supports the re-use of existing components and gives a design methodology for constructing interfaces. [ABSTRACT FROM AUTHOR]

Transparency and adaptability are important criteria for the usability of computer systems. It is not easy to fulfill these criteria in ill-structured domains by using traditional software concepts. The object-oriented approach, however, allows the construction of metasystems which enable the user to understand and manipulate the underlying conceptual schemata of an application system. ZOO is a metasystem for the application expert. ZOO visualizes the contents of an object-oriented knowledge base in a graphic, spatial representation as a net of icons. ZOO allows its user to inspect, manipulate, create and delete the components of a knowledge base through direct manipulation of graphic objects. [ABSTRACT FROM AUTHOR]

Observing and debugging concurrent actor programs on a distributed architecture such as the Apiary poses new problems not found in sequential systems. Since events are only partially ordered, the chronological order of events no longer corresponds to their causal ordering, so the execution trace of a computation must be more structured than a simple stream. Many events may execute concurrently, so a stepper must give the programmer control over the order in which events are stepped. Because of the arrival order nondeterminism of the actor model, different actors may have different views on the ordering of events. We conquer these problems by recording the activation ordering, the transaction pairing, and the arrival ordering of messages in the Apiary and displaying the resulting structures in Traveler's window oriented interface under user control. [ABSTRACT FROM AUTHOR]

A formal model of the Smalltalk-80 programming language is introduced. The semantics of much of the Smalltalk-80 language are described using the denotational style. A poorly-designed feature of Smalltalk is highlighted, and alternative semantics are presented for the language feature. [ABSTRACT FROM AUTHOR]

The main thing with the sub-class mechanism as found in languages like C++, SIMULA and Smalltalk is its possibility to express specializations. A general class, covering a wide range of objects, may be specialized to cover more specific objects. This is obtained by three properties of sub-classing: An object of a sub-class inherits the attributes of the super-class, virtual procedure/method attributes (of the super-class) may be specialized in the sub-class, and (in SIMULA only) it inherits the actions of the super-class. In the languages mentioned above, virtual procedures/methods of a super-class are specialized in sub-classes in a very primitive manner: they are simply re-defined and need not bear any resemblance of the virtual in the super-class. In BETA, a new object-oriented language, classes and methods are unified into one concept, and by an extension of the virtual concept, virtual procedures/methods in sub-classes are defined as specializations of the virtuals in the super-class. The virtual procedures/methods of the sub-classes thus inherits the attributes (e.g. parameters) and actions from the "super-procedure/method". In the languages mentioned above only procedures/methods may be virtual. As classes and procedures/methods are unified in BETA this gives also virtual classes. The paper demonstrates, how this may be used to parameterize types and enforce constraints on types. [ABSTRACT FROM AUTHOR]

This paper discusses knowledge sharing (inheritance) mechanisms for Object-Oriented Programming (OOP) in the context of concurrent (distributed) languages. We review three different schemes: inheritance, delegation and copy. A fourth model, called recipe-query, is presented and all are compared and criticized. Techniques relying on the shared memory assumption are rejected. We point out the conflict between distributing knowledge among objects and the synchronization of concurrent objects. [ABSTRACT FROM AUTHOR]

Object oriented programming environments frequently suffer serious performance degradation because of a high level of paging activity when implemented using a conventional virtual memory system. Although the fine-grained, persistent nature of objects in such environments is not conducive to efficient paging, the performance degradation can be limited by careful grouping of objects within pages. Such object placement schemes can be classified into four categories — the grouping mechanism may be either static or dynamic and may use information acquired from static or dynamic properties. This paper investigates the effectiveness of a simple dynamic grouping strategy based on dynamic behaviour and compares it with a static grouping scheme based on static properties. These schemes are also compared with near-optimal and random cases. [ABSTRACT FROM AUTHOR]

Languages, such as C++, that combine static type checking with inheritance pose a challenge to the compiler writer: the flexibility of the type and scope system implies that a compiler must be able to cope with data structures of a complexity far exceeding what is needed for traditional languages. Fortunately, they also supply the means for coping with this complexity. This paper describes the strategies devised for representing and manipulating C++ scopes and the storage management techniques employed to make these representations efficient. The techniques have been used to implement a C++ compiler in C++. [ABSTRACT FROM AUTHOR]

The Smalltalk-80 system offers a language with a small and elegant conceptual core, and a highly interactive programming environment. We believe, however, that it could be made more learnable and usable by a relatively small set of changes. In this paper, we present the results of a series of empirical studies on learnability, and also some informal studies of large implementation projects. Based on these studies, we suggest a number of changes to the Smalltalk-80 language and system. [ABSTRACT FROM AUTHOR]

"Object-Oriented Programming" and "Data Abstraction" have become very common terms. Unfortunately, few people agree on what they mean. I will offer informal definitions that appear to make sense in the context of languages like Ada, C++, Modula-2, Simula67, and Smalltalk. The general idea is to equate "support for data abstraction" with the ability to define and use new types and equate "support for object-oriented programming" with the ability to express type hierarchies. Features necessary to support these programming styles in a general purpose programming language will be discussed. The presentation centers around C++ but is not limited to facilities provided by that language. [ABSTRACT FROM AUTHOR]

The "programs are data" philosophy of Lisp uses Lisp's S-expressions to represent programs, and permits a program written in Lisp itself to implement the interpreter for the language. Object-oriented languages can take this one step further: we can use objects to represent programs. and an object-oriented interpreter takes the form of responses to a protocol of messages for evaluating programs. Because objects are a richer data structure than simple S-expressions, the representation of programs can have more built-in intelligence than was feasible using simple list manipulation alone. This paper surveys techniques and applications for object-oriented interpreters. We focus particularly on object-oriented interpreters that are reversible, those that, unlike conventional interpreters, remember their history of evaluation. We illustrate the techniques involved with two applications of reversible object-oriented interpreters: a reversible stepper for Lisp, and a programming environment which constructs Lisp programs from examples. [ABSTRACT FROM AUTHOR]

If the object-oriented style of programming hopes to live up to its potential as an improved methodology for software programming, a clear understanding of how to use types and inheritance is essential. Our experiences with using object-oriented languages and teaching object-oriented techniques to other programmers have shown that effective use of types and inheritance may be problematic. There are no concrete guidelines to assist programmers, and the existing aphorisms often create interpretation problems for novice object-oriented programmers. In this paper we look at how types, subtyping, and inheritance are used in object-oriented languages. We discuss the different ways that types and type hierarchies can be used to structure programs. We illustrate appropriate use of these concepts through examples and develop guidelines to assist programmers in using the object-oriented methodology effectively. [ABSTRACT FROM AUTHOR]

There are two equally important, related, functions involved in the control of assets and resources. One of these is the verification of a potential user's identity and authority to use or have access to those assets. The other is to provide a record (receipt) of each access so that in the event of a later dispute as to whether an illegitimate use was made of the assets, or of the extent of the liability incurred in a legitimate use, etc., the authenticity and specifics of the access can be demonstrated in a logically compelling (and hence eventually legally binding) manner to an impartial third party or arbiter. Elaborate, and legally accepted, document based protocols to accomplish these functions are central to all commercial and private transactions. When the resources are remotely accessible, however, as in the case of computer data files, electronic funds transfers (EFT), automated bank tellers, and even in many manned point-of-sale systems, no satisfactory counterpart to the established document based protocols for verifying individual identity and/or authority to use a resource have been found, nor has a fully satisfactory means been devised to provide unforgeable transaction receipts. In this paper, we show how a public authentication channel can be used to certify private (user unique) authentication channels in a protocol that both "proves" a potential user's identity and authority and also provides certified receipts for transactions whose legitimacy can later be verified by impartial arbiters who did not have to be parties to the original transaction. We also introduce an authentication scheme to be used in this application based on the legitimate originator of information being able to extract square roots modulo n — pq, where p and q are primes of a special form. We show that these protocols provide a zero-knowledge proof of identity and of veracity transaction receipts, and that they are therefore very secure. We also show how the legitimate owner of the authentication channel can give a zero-knowledge proof that the modulus n has the correct form, thereby eliminating the possibility of the existence of several known subliminal channels. [ABSTRACT FROM AUTHOR]

Smalltalk-80 is presented as a useful testbed for prototyping applications involving shared, persistent objects, and a detailed design of a shared persistent object store is discussed. The store is a set of named containers for object state, and it provides low-cost atomic transactions using an optimistic synchronisation technique. The standard Smalltalk-80 virtual machine is modified to support a new object class, the Transaction, and an example of a Smalltalk program using nested sub-transactions is given. Immutability of object state is identified both as an important property of objects. and a basis for producing an efficient implementation within a distributed system environment. [ABSTRACT FROM AUTHOR]

We describe the design of a prototype which makes objects persistent. Our target language is the CommonLisp Object System (CLOS), although we pay attention to the eventual sharing of data with other languages. Our design is very flexible, in that it allows the simultaneous use of multiple, different databases. This is accomplished by defining a virtual database layer which consists of a core protocol that is expected to be implemented on all databases, and of protocol adapters which accommodate features offered by some databases, but not by others. This virtual database has been implemented for a simple, single-user, in-core data store, and for Iris, a multi-user, object-oriented database management system. We outline the advantages of the CLOS Metaclass Protocol for implementing object persistence or other low-level modifications to the CLOS implementation. [ABSTRACT FROM AUTHOR]

This paper provides a brief introduction to the OOPS+ knowledge-representation language. While basically object-oriented, OOPS+ integrates database concepts as well as classical knowledge-representation techniques such as rule-based inference and demons. In addition, the language supports types as first-class objects, inheritance, imperative function definition, and query facilities based on logic programming. [ABSTRACT FROM AUTHOR]

We present an object-oriented semantic database model which, similar to other object-oriented systems, combines the virtues of four concepts: the functional data model, a property inheritance hierarchy, abstract data types and message-driven computation. The main emphasis is on the last of these four concepts. We describe generic procedures that permit queries to be processed in a purely message-driven manner. A database is represented as a network of nodes and directed arcs, in which each node is a logical processing element, capable of communicating with other nodes by exchanging messages. This eliminates the need for shared memory and for centralized control during query processing. Hence, the model is suitable for implementation on a multiprocessor computer architecture, consisting of large numbers of loosely coupled processing elements. [ABSTRACT FROM AUTHOR]

Computer supported cooperative work currently receives much attention. There are many aspects of cooperative work. One of these is the use of shared material. Much cooperation is based on silent coordination mediated by the shared material used in the work process. The properties of the shared material are, however, often ignored when work is computerised. Instead the emphasis has been on automating frequent work procedures. This has resulted in very inflexible systems. A fundamental idea in object oriented programming is to model the phenomena in the part of reality the system addresses. These modelling techniques can be used to implement shared material on computers. The result is a raw system providing the material and the essential primitive operations on this material. Such a system can be seen as a specialised programming environment which can be tailored to the needs of individual users or be modified for future needs. This use of object oriented programming requires persistent and shared objects. Some objects may be active and execute as parallel processes. Incremental change of a running system will be needed to allow evolution. It is non-trivial to decide which properties of the material to model. An example demonstrates that this decision may depend on the kind of technology being considered. [ABSTRACT FROM AUTHOR]

The terminology in the area of databases and data models is inconsistent and inaccurate and thus often confusing. Some fundamental database concepts are described in this paper. The description of these concepts are based on general concepts related to the development of the object oriented languages SIMULA, DELTA and BETA. A database is defined as an information system providing information about a referent system (the modelled part of the world), and a data model is defined as "having an inherent structure and a set of tools and techniques used in the process of designing, constructing and manipulating model systems (in particular, databases)". The connection between databases, DBMS and data models and other concepts related to the development and use of databases are described in a process/structure hierarchy. [ABSTRACT FROM AUTHOR]

Object-oriented systems could use much of the functionality of database systems to manage their objects. Persistence, object identity, storage management, distribution and concurrency control are some of the things that database systems traditionally handle well. Unfortunately there is a fundamental difference in philosophy between the object-oriented and database approaches, namely that of object independence versus data independence. We discuss the ways in which this difference in outlook manifests itself, and we consider the possibilities for resolving the two views, including the current work on object-oriented databases. We conclude by proposing an approach to co-existence that blurs the boundary between the object-oriented execution environment and the database. [ABSTRACT FROM AUTHOR]

This paper presents a debugging method for Concurrent Object-Oriented Systems. Our method is based upon a new notion called Object Groups. An Object Group is a collection of objects which forms a natural unit for performing collective tasks. An Object Group's Task differs from C. Manning's nested transaction which is based on the nested request-reply bilateral message passing structures. Each Object Group's Task permits more general message passing structures. The language constructs which specify and use Object Groups have been introduced into an object-oriented concurrent language ABCL/l. The paper also describes ABCL/l's debugging tools based on Object Groups. [ABSTRACT FROM AUTHOR]

The ABCL/c+ is a C-based concurrent object-oriented language, designed as an extension of ABCL/l, a language developed by A. Yonezawa and others. In order to create the world of processes, a routine object is introduced which unifies procedures, functions, and objects. ABCL/c+ is then used to write an operating system kernel. The XINU operating system, developed by D. Comer and others of Bell Laboratories, is rewritten entirely in ABCL/c+. The result shows that concurrent object-oriented languages can produce a highly readable and understandable operating system kernel. [ABSTRACT FROM AUTHOR]

One of the key concepts available in many object-oriented programming languages is that of type-inheritance, which permits new types to be derived from, and inherit the capabilities of, old types. This paper describes how to exploit this property in a very simple fashion to implement object-oriented concurrency control. We show how by using type-inheritance, objects may control their own level of concurrency in a type-specific manner. Simple examples demonstrate the applicability of the approach. The implementation technique described here is being used to develop Arjuna, a fault-tolerant distributed programming system supporting atomic actions. [ABSTRACT FROM AUTHOR]

This paper describes DistributedSmalltalk, which consists of a number of cooperating Smalltalk virtual machines distributed over a network, that provide complete distribution transparency to the image level, including transparent message passing across machine boundaries. As a result no modifications are necessary at the image level and e.g. the standard Smalltalk debugger can be used for system wide debugging. Transparent I/O is provided by means of a concept called "home objects". The performance degradation is acceptable, due to replication and the home object concept. Replication is transparent and replication consistency is guaranteed, so e.g. for replicated class objects no compatibility checking is needed. Distributed garbage, whether containing cycles or not, is collected incrementally without any synchronization being necessary. [ABSTRACT FROM AUTHOR]

SCOOP is an experimental language implemented in Prolog that tries to combine the best of logic, object-oriented and concurrent programming in a structured, natural and efficient manner. SCOOP provides hierarchies of object classes. These objects behave as independent Prolog programs with private databases which can execute goals within other objects. SCOOP also supports parallel processes, synchronised by the exchange of messages. For simulation, a sequencing set and primitives concerned with simulated time are provided. Thus, SCOOP has the ability to describe structured dynamic systems and to encode knowledge. The important features of SCOOP are 1) its lexical block structure designed to promote and enforce modularity and to allow verification and optimisation via a compiler, 2) its combination of familiar programming cliches: the concepts of Simula67 for macrostructuring of entities and those of standard Prolog (unification & backtracking) for local behaviour, 3) its provision for parallel activity with a clear distinction between static objects and dynamic processes and 4) its discrete simulation capability. [ABSTRACT FROM AUTHOR]

An Integrated Electronic Book (IEB) represents a complex network of integrated information and "know how" on a given subject. In the design phase of WEBS (Woven Electronic Book System), we soon realized that, because we were describing the IEB in terms of "objects" and "methods," and because we wanted WEBS to be easily expandable and to offer a consistent user interface, we should use an object-oriented development system. This paper does not fully discuss the concept of electronic book systems, but rather describes our own experiences developing a complex software system with an object-oriented language. The first part explains our choice of an object-oriented language and software framework. The rest describes the software architecture of WEBS, which is a class hierarchy of three layers: a software framework (MacApp) layer, a system-specific layer; and an application-specific layer. [ABSTRACT FROM AUTHOR]

We discuss several negative features and properties of the C++ language, some common with C, others pertaining to C++ classes. Remedies are proposed for most of the latter ones, most of the former ones being feared to be already incurable. The worst class-related defects claimed in present C++ have to do with free store management. Some hints are given to programmers on how to avoid pitfalls. [ABSTRACT FROM AUTHOR]

We present an original exception handling system especially designed for object-oriented languages. making actual information hiding possible and taking into account specific issues of object-oriented languages. It allows association of handlers with expressions as well as with object classes, using a well defined semantics. It offers an object-oriented and extensible representation of exceptions, handlers and knowledge about exceptions. Handlers can specify both resumption and termination. There are no distinctions between system and user defined exceptions. With this system. fault tolerant programs and well specified encapsulations can be written, simple and powerful integration of new user-defined exceptions and secure as well as readable non local moves can be implemented. In this paper, we examine object oriented specific issues related to exception handling. We discuss the exception handling mechanisms available in current object-oriented languages and explain why they do not provide he ability to define fault tolerant encapsulations. Our system description shows how the utilization of the object-oriented formalism solves, in an efficient and simple way, some well known problems related to exception handling such as: how to create exception hierarchies, how to signal fatal or continuable exceptions with the same primitive, how to pass arguments to handlers. and so on. [ABSTRACT FROM AUTHOR]

The notion of nested blocks has come into disfavour or has been ignored in recent program language design. Many of the current object oriented programming languages use subclassing as the sole mechanism to establish relationships between classes and have no general notion of nesting. We argue that nesting (and, more generally, hierarchical organization) is a powerful mechanism that provides facilities that are not otherwise possible in a class based programming language. We agree that traditional block structure and its associated nesting have severe problems, and we suggest several extensions to the notion of blocks and block structure that indirectly make nesting a useful and powerful mechanism, particularly in an object oriented programming system. The main extension is to allow references to definitions from outside of the containing block, thereby making the contained definitions available in a larger scope. References are made using either the name of the containing entity or an instance of the containing entity. The extensions suggest a way to organize the programming environment for a large, multi-user system. These facilities are not available with subclassing, and subclassing provides facilities not available by nesting; hence, an object oriented language can benefit by providing nesting as well. [ABSTRACT FROM AUTHOR]

This paper presents the design of a minimal set of instruction for a class system embedded in Lisp: ObjVLisp. We re-use the set of postulates describing the operational behaviour of ObjVLisp to discuss and derive a new implementation based on a reduced set of functions and a more self-contained description. Then we develop the ObjVLisp experience in building metaclass architecture to propose a layered and incremental metaobject protocol for CLOS. [ABSTRACT FROM AUTHOR]

Supporting multiple classification in object-oriented programming languages is the topic of discussion in this paper. Supporting multiple classification gives rise to one important question — namely the question of inheritance of attributes with identical names from multiple paths in the classification hierarchy. The problem is to decide how these multiple classification paths are reflected in the class being defined. One of the conclusions in this paper is, that by choosing strict and simple inheritance rules, one is excluding some particular usages of multiple classification. This leads to the notion of attribute-resolution at class definition, which means that the programmer in some cases is forced or allowed to resolve the potential ambiguity of the inherited names. The concept of attribute-resolution is managed through the identification of two conceptually different utilizations of specialization (unification and intersection), and two different attribute properties (plural and singleton) to guide the attribute-resolution. [ABSTRACT FROM AUTHOR]

At the specification level, inheritance can be defined as subtyping by means of order sorted specifications [GM85]. Subtyping is, obviously, a very important notion, allowing not only to work with a non rigid type structure, but also providing an adequate basis for error handling in algebraic specifications. However, in our opinion, subtyping and order sorted specifications do not play the same rûle as inheritance in program design. In this paper, we will present a hierarchical organization for specifications, based on a different concept of inheritance which, we think, corresponds, methodologically, to the usual inheritance relation defined at the programming level. This new relation allows to work with incomplete specifications with several levels of detail and, as a side-effect, it may play the rûle of genericity. The use of this notion of inheritance is shown by means of the GSBL specification language built around this new concept, whose use and formal semantics are sketched. [ABSTRACT FROM AUTHOR]

Incremental modification is a fundamental mechanism not only in software systems, but also in physical and mathematical systems. Inheritance owes its importance in large measure to its flexibility as a discrete incremental modification mechanism. Four increasingly permissive properties of incremental modification realizable by inheritance are examined: behavior compatibility, signature compatibility. name compatibility, and cancellation. Inheritance for entities with finite sets of attributes is defined and characterized as incremental modification with deferred binding of self-reference. Types defined as predicates for type checking are contrasted with classes defined as templates for object generation. Mathematical, operational, and conceptual models of inheritance are then examined in detail, leading to a discussion of algebraic models of behavioral compatibility. horizontal and vertical signature modification, algorithmically defined name modification, additive and subtractive exceptions, abstract inheritance networks, and parametric polymorphism. Liketypes are defined as a symmetrical general form of incremental modification that provide a framework for modeling similarity. The combination of safe behaviorally compatible changes and less safe radical incremental changes in a single programming language is considered. [ABSTRACT FROM AUTHOR]

This paper presents the user interface to programs and their execution in the Mjølner Programming Environment. The key idea is to present the programming language abstractions, such as classes and procedures, as individual windows which the user can interact with directly. This approach is used consistently to visualize both a program and its execution. The windows are arranged hierarchically reflecting the static nesting of blocks. The window hierarchy gives powerful support for interaction and navigation in a program. Incremental compilation techniques are used to make a high level of interaction and integration possible. [ABSTRACT FROM AUTHOR]

One of the important obligations of an expanding research area is to discuss how to approach the teaching of the subject. Without this discussion, we may find that the word is not spread properly, and thus that the results are not properly utilized in industry. Furthermore, discussing teaching the research area gives additional insight into the research area and its underlying theoretical foundation. In this paper we will report on our approach to teaching programming languages as a whole and especially teaching object-oriented programming. The prime message to be told is that working from a theoretical foundation pays off. Without a theoretical foundation, the discussions are often centered around features of different languages. With a foundation, discussions may be conducted on solid pound. Furthermore, the students have significantly fewer difficulties in grasping the concrete programming languages when they have been presented with the theoretical foundation than without it. [ABSTRACT FROM AUTHOR]