Most object-oriented programs have imperfectly designed inheritance hierarchies and imperfectly factored methods, and these imperfections tend to increase with maintenance. Hence, even objectoriented programs are more expensive to maintain, harder to understand and larger than necessary. Automatic restructuring of inheritance hierarchies and refactoring of methods can improve the design of inheritance hierarchies, and the factoring of methods. This results in programs being smaller, having better code re-use and being more consistent. This paper describes Guru, a prototype tool for automatic inheritance hierarchy restructuring and method refactoring of Self programs. Results from realistic applications of the tool are presented. 1 Introduction Factoring shared methods into classes and shared code into methods allows systems to be compact and improves consistency, making them more easily understood and less expensive to maintain. Manually designing inheritance hierarchies and methods ...

Reorganization of classes for object-oriented programming and object-oriented database design has recently received considerable attention in the literature. In this paper a small set of primitive transformations is presented which forms an orthogonal basis for object-preserving class reorganizations. This set is proven to be correct, complete, and minimal. The primitive transformations help form a theoretical basis for class organization and are a powerful tool for reasoning about particular organizations.

The contributions of this paper are two-fold: First we introduce a novel, axiomatically defined, object-oriented data model, called the Demeter kernel model, and second we present abstraction and optimization algorithms and their relationships for designing classes from objects in the kernel model. We analyze several computational problems underlying the class design process which is divided into two phases: a learning phase and an optimization phase. This study focuses on approximation algorithms for the optimization phase and leads to a better understanding and a partial automation of the object-oriented design process. The algorithms and the theory presented in this paper have been implemented in the C++ Demeter System TM , a CASE tool for object-oriented design and programming. Keywords: Object-oriented programming and design, reverse engineering, formal software engineering techniques, class hierarchy optimization. Acknowledgements: Preliminary versions of this paper ...

ii Class organizations (schemas) evolve over the life cycle of object-oriented systems for avariety of reasons. This issue has recently been a subject of increasing attention in the literature of both object-oriented languages and object-oriented database systems. One of the most common forms of evolution involves the extension of an existing system by addition of new classes of objects or the addition of attributes to the original objects. Sometimes class structures are reorganized even when the set of objects is unchanged. In this case the reorganization might represent an optimization of the system, or just a change in the users ' perspective. At the other extreme, a class reorganization might re ect not only the extension and reclassi cation of existing objects, but also structural changes (other than addition of attributes) in the original objects. This work provides a mathematical treatment of a calculus of class transformations. Three kinds of transformations that commonly occur in the evolution of class structures are considered: object-extending, object-preserving, and language-preserving. For each kind of transformation, methods for automating the maintenance of systems based on the evolving class structure are discussed. The language-preserving transformations are a special case of transformations that change the structure of existing objects. If an object schema is decorated with concrete syntax, it de nes not only a class structure, but also a language for describing the objects. When two schemas de ne the same language but di erent classes, the language may be used to guide the discovery of analogies between the classes. The resulting analogies may then be used to transport functionality between domains. iii Acknowledgments Iwould like to thank my advisor, Karl Lieberherr, for his generous support, guidance, and feedback. I would also like to thank my wife, Vickie, for her constant encouragement and understanding without which thiswork would not have been possible. iv

In order to design and develop object-oriented programs, one must experience what is known as a "paradigm shift". This shift requires that one do not think in terms of the procedures that a software system must perform, but rather in terms of the entities or objects that participate in the system. As programmers experience a paradigm shift, so must existing software systems somehow be transformed into object-orientation if they are to benefit from object-oriented features.

This paper 1 introduces Guru, a prototype tool for restructuring inheritance hierarchies in Self, while preserving the behavior of objects. Guru reverse engineers from existing inheritance hierarchies. Unlike previous work, Guru handles resends, redefined methods and the restructuring of only part of a system. Furthermore, Guru handles dynamic and cyclical inheritance, which are more specific to Self. Guru removes duplicated methods, and can create inheritance hierarchies with no overridden methods. The results of two nontrivial tests are presented and assessed. 1 Introduction Some object-oriented design methods encourage the designer to think of the inheritance hierarchy very early in the production of a software system. Many developers think of the inheritance hierarchy as basically static; they will add new classes, but are reluctant to restructure it. This is not surprising, as restructuring inheritance hierarchies is difficult. Guru is a prototype reverse engineering tool whic...

This paper 1 describes an algorithm for inferring inheritance hierarchies. It is simple both to understand and to implement. It is also efficient enough for use with realistically sized problems. The solutions produced meet a set of criteria, which are justified as producing the inheritance hierarchy which most clearly reflects the inherent structure of the objects to which it is applied. The motivation for such an algorithm is discussed, and a comparison is made with two similarly motivated algorithms. An example of an application using the algorithm is presented. 1 Introduction Inheritance is one of the defining characteristics of object oriented programming. It allows programs to capture the shared characteristics of objects, at different levels of abstraction. For example, the object 3 is not only an integer but also a number, hence shares abstract behaviour with other numbers, and shares more specific behaviour with other integers. The structure of the inheritance hierarchy re...