Gisela Menger

Inheriting from a Common Abstract Ancestor in Timor

A particular case of multiple inheritance, involving a family of related types with a common abstract ancestor, is examined, and a substantial example, involving five abstract and nine concrete collection types, is presented. The separation of types and implementations, together with the separation of subtyping and code re-use, results in a clearly structured and easily intelligible type library which allows extensive polymorphic use of collections at the type level. A full implementation of only one of these types, together with a few additional trivial code units, can be re -used to implement all nine concrete types. The paper concludes by describing how the binary methods and constructors can also be easily and efficiently designed and implemented.

Software Reuse in an Object Oriented Framework: Distinguishing Types from Implementations and Objects from Attributes

Almost no object oriented programming languages offer distinct language constructs for the definition of types and their implementations; instead these are united into a single class concept. Similarly object oriented programming languages do not normally distinguish between object types, which may be independently instantiated, and attribute types, which may not. The paper shows how these distinctions can be used to develop both a specialized and a generalized bracket technique, and how the ideas lead to interesting possibilities for reusing code in a flexible and modular way.

Qualifying Types Illustrated by Synchronisation Examples

Qualifying types represent a new approach to modifying the behaviour of instances of other types in a general way, in the form of components which can be designed and implemented without a prior knowledge of the types to be modified or their implementations. This paper illustrates the idea by showing how they can be used to program various standard synchronisation problems, including mutual exclusion, reader-writer synchronisation and several variants of the bounded buffer problem.

Genja-a new proposal for parameterised types in Java

Recent proposals for adding parameterised types to Java have left a number of important practical issues undiscussed. We present the language Genja which is a novel generic extension of Java oriented towards practical support for generic collection types. We discuss design alternatives related to extending the power of unconstrained genericity, solving the weaknesses of constrained genericity in other proposals and defining the compatibility of named and anonymous instantiations. By enhancing support for reusability and providing a higher level style of programming via a library of standard generic collection types, Genja aims to extend Javas contribution to efficient software production.

How Well Do Inheritance Mechanisms Support Inheritance Concepts

Inheritance mechanisms are used to express many different programming concepts. In this paper we analyse these inheritance concepts to determine the requirements for an inheritance mechanism which is to support the concepts well. On the basis of this analysis we identify weaknesses in current mechanisms, particularly in the areas of modelling and signature modification and show how an inheritance mechanism can better fulfil the requirements while remaining type-safe.

Support for Object Oriented Transactions in Timor

An important aim in the design of the Timor programming language is to provide programmers with features which enable them to build complex systems from components which can be developed in isolation from each other (i.e. without knowledge of each others existence). The database transaction concept serves as an interesting test case for this objective, since it is a general concept which can be applied to many different applications. The paper discusses those features of Timor which allow this objective to be achieved.

Collection types and implementations in object-oriented software libraries

Collection classes are ideal candidates for software reuse and therefore have an important role in the development and use of object-oriented class libraries. We analyze representative collection libraries, pointing out the main problems from the viewpoint of their practical usability in programs. We then identify a small number of independent concepts relevant to the design of libraries of collections and show how an orthogonal treatment of these concepts can solve the problems identified. Because existing object-oriented languages, even newer ones, do not completely support all the relevant concepts (although most of the critical points are well-known), we show to what extent it would be possible to realize our proposals, and what remains as a challenge in the design of future languages.

Reuse Variables: Reusing Code and State in Timor

The standard approach to code reuse in object oriented languages is via inheritance. This is restrictive in a number of ways. For example, it leads to well known conflicts between subtyping and subclassing. Furthermore, where no type relationship exists, programmers must resort to inefficient techniques such as delegation to achieve code reuse. In the paper it is described how the language Timor decouples subtyping and code reuse and presents a new concept known as reuse variables, showing how these can be used to eliminate such restrictions in object oriented and component oriented contexts.

Using and teaching information hiding in single-semester software engineering projects

The information-hiding principle is recognised as one of the fundamental principles of software engineering. This paper reports on two kinds of experience the authors have gained in using and teaching information hiding in software engineering projects. The first relates to the enormous practical and pedagogical advantages of taking a strict approach. The second is the suprising lack of support for such an approach in the object-oriented programming languages commonly used for such projects.

Persistent Processes and Distribution in Timor.

The paper explains the concept of persistent processes and threads in Timor, showing how it is based on the in-process (procedure oriented) model of process execution. In their Timor form processes and threads can persist even when a user is logged out. They can also invoke remote persistent objects with the same semantics as invocation of local objects.