Content area
This thesis shows that automatic restructuring improves object-oriented programs. Most programs are imperfectly designed, and their imperfections tend to increase with maintenance and evolution. Even object-oriented programs suffer from these faults, and so are more expensive to maintain, harder to understand and larger than necessary. This thesis explores automatic restructuring of object- oriented programs in the language Self, and describes the implementation of a restructuring tool called Guru. Many forms of restructuring are possible. This thesis describes an algorithm for creating inheritance hierarchies from object definitions. Solutions are given to problems which arise when applying such an algorithm to restructuring actual programs. Inheritance hierarchies can be restructured by Guru into equivalent ones in which there are no duplicated methods. Furthermore, Guru can refactor shared expressions from methods at the same time as restructuring a hierarchy, resulting in hierarchies in which no methods, and none of the expressions that can be factored out, are duplicated. Results from applying Guru to real Self code are described. Restructured programs are smaller, more consistent and have better code revise than the original programs. Inheritance hierarchies resulting from the application of Guru have exactly the structures that should be expected of well designed hierarchies. Guru is shown to preserve the behaviour of programs, by replacing original objects with their equivalent restructured objects. Previous work on restructuring object-oriented programs has considered only 7 class-centric languages. This thesis explores the restructuring of programs in Self, an object-centric language. Complementary tools which provide program analyses and restructurings, useful both in combination with and separately from Guru, are described, and the way that a user can interact with such tools is considered.