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]