A new kind of type is described whose objects ("qualifiers") have bracket methods which can modify the run-time behaviour of other objects ("targets"). Bracket methods can qualify either specific methods of a target or can separately qualify their reader and writer methods, thus allowing general qualifiers to be developed for standard activities such as synchronisation, monitoring and protection. Qualifiers are associated with a target when it is created, in the form of a qualifier list. Individual qualifiers can be dynamically added to and removed from the list even while the target object is active.

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.

The paper describes how the idea of persistent objects is integrated into the Timor programming language. The strategy adopted allows types to be instantiated at two levels: as "files", i.e. objects accessible at the operating system level, and as local objects within files, which resemble objects found in conventional object oriented programs. File objects (with associated methods) can be instantiated and manipulated via capabilities, which are accessible both internally and via the operating system. Local objects are accessible via references, which are not visible at the operating system level. PERSISTENT OBJECTS AND CAPABILITIES IN TIMOR104 J OURNAL OF OBJECT TECHNOLOGY V OL. 6, NO. 4 PERSISTENT OBJECTS AND CAPABILITIES IN TIMOR 106 J OURNAL OF OBJECT TECHNOLOGY V OL. 6, NO. 4 final op String name(String name); final enq String name(); and the abstract reference spouse corresponds to the methods: final op Person* spouse(Person* spouse); final enq Person* spouse(); PERSISTENT OBJECTS AND CAPABILITIES IN TIMOR 122 J OURNAL OF OBJECT TECHNOLOGY

The paper describes one aspect of multiple inheritance in the Timor programming language, viz. how "parts" such as a type Radio and a type Cassette Player can be inherited, where appropriate repeatedly, in subtypes such as a Radio Double Cassette Player. Because such types can also be defined via aggregation the paper begins by comparing inheritance with aggregation. It then shows how such cases can be handled first at the type level and then at the implementation level in Timor.

In Timor multiple inheritance of methods from a common abstract ancestor (e.g. Collection) and of separate "parts" (possibly repeatedly) from distinct supertypes (e.g. a Radio, a Cassette Player) are handled in different ways. The paper shows that neither technique is suitable for cases where a common concrete ancestor (e.g. Person) is specialised in different subtypes (e.g. as a Student, an Employee) and then brought together in a new subtype, possibly with repeated inheritance (e.g. a Doubly Employed Student). For such cases a new kind of type ("attribute types") is proposed, which provides an alternative programming paradigm to inheritance, based on the idea of adjectives and their use in noun phrases in natural languages.