It has been recognized in several works that a slice of behavior affecting a set of collaborating classes is a better unit of reuse than a single class. Different techniques and language extensions have been suggested to express such slices in programming languages. We propose delegation layers, an approach that scales the OO mechanisms for single objects, such as delegation, late binding, and subtype polymorphism, to sets of collaborating objects. Technically, delegation layers combine and generalize delegation and virtual class concepts. Due to their runtime semantics, delegation layers are more flexible than previous compile time approaches like mixin layers.

The development of concurrent object-based programmig languages has suffered from the lack of any generally accepted formal foun ion for de finn their semantics. Furthermore, the delicate relation p between object-oriented features supportin reuse an operation features con n g in teraction a n state chan is poorlyun rstood in a con urren t settin To address this problem, we propose the developmen t of an object calculus, borrowi n heavily from relevan t work in the area of process calculi. To this en we briefly review some of this work, we pose some i ormal requiremen ts for an object calculus, an we present the syntax, operation seman tics an use through examples of a proposed object calculus, called OC.

Modeling object-oriented applications using collaborations and roles is now well accepted. Collaboration-based or role-based designs decompose an application into tasks performed by a subset of the applications' classes. Collaborations provide a larger unit of understanding and reuse than classes, and are an important aid in the maintenance and evolution of the software. This kind of design information is lost, however, at the implementation level, making it hard to maintain and evolve an existing software application. The extraction of collaborations from code is therefore an important issue in design recovery. In this paper we propose an iterative approach which uses dynamic information to support the recovery and understanding of collaborations. We describe a tool we have developed to support our approach and demonstrate its use on a case study.

Abstract: Systems are defined by their components and the relationships among their components, hence when modelling systems using an objectoriented (OO) approach, objects alone are insufficient to describe the system behaviour. There is also the need to represent relationships between objects in terms of cooperations for the accomplishment of a particular task. The approach described in this paper makes use of Coordinated Atomic Actions (CA actions)- a structural design and modelling mechanism, for representing the cooperation between objects, at different stages of the software development. The original concept of an CA action has been expanded for accommodating the modelling needs of the initial stages of software development.

Components come in a variety of formats, designs and implementations. Components can be designed to work together or their designs can be totally incompatible. This influences greatly the amount and kind of composition work that is to be done. In this work, we build on the work of architectural description languages to improve current visual component composition environments. This is done using the concept of composition patterns. A composition pattern describes an interaction between a set of roles using an extended sequence chart. It serves as a bridge between the design and the implementation. We further propose a component documentation using the same kind of extended sequence charts. The concept of composition patterns lifts the abstraction level of current composition techniques to the same level of the components. I.e. composition patterns are first class objects that can be defined, stored and reused independently of the components. We further develop and implement algorithms to perform automatic compatibility checking based on finite automata theory. We also developed tool support that gives

Subtype polymorphism, based on syntactic conformance of objects' methods and used for substituting subtype objects for supertype objects, is a characteristic feature of the object-oriented programming style. While certainly very useful, typechecking of syntactic conformance of subtype objects to supertype objects is insufficient to guarantee correctness of object substitutability. In addition, the behaviour of subtype objects must be constrained to achieve correctness. In class-based systems classes specify the behaviour of the objects they instantiate. In this paper we define the class refinement relation which captures the semantic constraints that must be imposed on classes to guarantee correctness of substitutability in all clients of the objects these classes instantiate. Clients of class instances are modelled as programs making an iterative choice over invocation of class methods, and we formally prove that when a class C # refines a class C, substituting instances of C # for instances of C is refinement for the clients.

. Current Object-oriented Design (OOD) methodologies tend to focus on objects as the unit of reuse, but it is increasingly recognised that frameworks, or groups of interacting objects, are a better unit of reuse. Thus, in next-generation Component-based Development (CBD) methodologies, we can expect components to be frameworks rather than objects. In this paper, we describe a preliminary attempt at a formal semantics for OOD frameworks in CBD in computational logic. 1 Introduction Most of the existing (semi-formal) Object-oriented Design (OOD) methods such as Fusion [4, 6] and Syntropy [5] use classes or objects as the basic unit of design or reuse. These methods are based on the traditional view of an object, as shown in Figure 1, which regards an object as a closed entity with one fixed role. visible functions structure internal encapsulated Fig. 1. Traditional view of an object. This, however, does not reflect the nature of objects (and classes that describe them) in practical syst...

In this paper, we specify an open problem: predictable component assembly, and state a position on compositional reasoning techniques that we believe are necessary for this purpose. 1 A Rhetorical Question? Yes, naturally, the question in the title is meant to be rhetorical. However, by formality I do not mean that which is exemplified by existing formal methods. Rather, I mean the use of a priori reasoning, instead of the prevalent a posteriori reasoning used for verification-based software construction. 2 What is A Priori Reasoning? Verification-based methods take the `posit-and-see' approach: given the specification for a program, first posit a program, then see if the program is correct (wrt to the given specification); similarly, to construct a specified composite, first posit the components and their composition, then see if their composition meets the given specification. This is what I call a posteriori reasoning: reasoning about correctness (or other properties) takes place...

In OO Design, it is widely recognised that the distribution of tasks between objects and the contracts between them are key to effective design. In composing designs from reusable parts, the parts are therefore frameworks, namely descriptions of the interactive relationships between objects which participate in the interactions. Designs are then built by composing these frameworks, and any object in the final design will play (various) roles from several frameworks. Practitioners of OO Design use pictorial notations for design. However, in order to reason formally about design, we need a sound (formal) semantics for the diagrams. In this paper, we show that frameworks can be formalised as many-sorted theories, and then present a pictorial representation of such theories, developed in the Catalysis project. 1. Introduction Formal methods for program or system development need to have a good pictorial notation if they are to be adopted by practitioners for real-world work. Such a notati...

Independent development of components according to their specifications is complicated by the fact that a thread of control can exit and re-enter the same component. This kind of re-entrance may cause problems as the internal representation of a component can be observed in an inconsistent state. We argue that the ad-hoc reasoning used in establishing conformance of components to their specifications that intuitively appears to be correct does not account for the presence of re-entrance. Such reasoning leads to a conflict between assumptions that component developers make about the behaviour of components in a system, resulting in the component re-entrance problem. We formulate the modular reasoning property that captures the process of independent component development and introduce two requirements that must be imposed to avoid the re-entrance problem. Then we define a customised theory of components, component systems, and component refinement which models the process of component d...