Revisiting multiple inheritance for modularity and reuse

Abstract

Since software modularity makes software systems controllable, maintainable and extensible, improving software modularity has been a hot topic in the programming community for many years since the beginning of programs. Researchers and software developers often apply different modularity techniques to reduce the complexity of software systems and make them more modular. These techniques include new design patterns, new programming languages, new type systems and tool support. Object-Oriented Programming (OOP) is a programming paradigm, which has been investigated and used for a long time. It improves modularity by modeling the world as objects and providing abstractions by wrapping data and functions into a single unit. Later, the idea of multiple inheritance is proposed to further improve modularity in OOP. However, there are still unsolved (or not elegantly solved) problems such as the Expression Problem and issues in supporting multiple inheritance.

This thesis investigates various software modularity and multiple inheritance related issues in the context of OOP. In particular, we divide the thesis into two parts: (I) multiple inheritance for modularity and reuse, and (II) revisiting models of multiple inheritance. In part I, we explore the canonical modularity problem (the Expression Problem) and discuss various existing solutions. These solutions are not satisfactory because they are complex and require either advanced type systems or complex language features. Our proposed solution in both Scala and Java uses simple subtyping feature and it shows that only subtyping is enough to solve the EP. Then we propose a new programming paradigm called interface-based programming, as opposed to class-based programming and prototype-based programming. The purpose is to lower coupling among software components. We implement this programming style into Java and it is called Classless Java, where OO programs and reusable libraries can be defined and used without defining a single class.

In part II, we explore the conflicts issues in multiple inheritance. In particular, we explore the unintentional conflict problems, which previous approaches/models either do not support or cannot provide satisfactory solutions. The reason is that they have to compromise between code reuse and type safety. Moreover, they do not support hierarchical overriding in the presence of unintentional conflicts. We propose the formal multiple inheritance model FHJ, solving the unintentional method conflicts issue by supporting hierarchical dispatching and hierarchical overriding algorithms. To further solve the unintentional state conflicts problem and provide a general treatment to the diamond problem, we propose FHJ+ as an extension to FHJ. Both models are formalized following the style of Featherweight Java. We also propose many properties of the two models to prove the models to be sound.

In summary, this thesis investigates and solves the interesting problems around modularity and multiple inheritance, providing insights for future researchers to improve software modularity further.