The programming language jigsaw: mixins, modularity and multiple inheritance

This dissertation provides a framework for modularity in programming languages. In this framework, known as Jigsaw, inheritance is understood to be an essential linguistic mechanism for module manipulation. In Jigsaw, the roles of classes in existing languages are "unbundled," by providing a suite of operators independently controlling such effects as combination, modification, encapsulation, name resolution, and sharing, all on the single notion of module. All module operators are forms of inheritance. Thus, inheritance is not in conflict with modularity in this system, but is indeed its foundation. This allows a previously unobtainable spectrum of features to be combined in a cohesive manner, including multiple inheritance, mixins, encapsulation and strong typing. Jigsaw has a rigorous semantics, based upon a denotational model of inheritance. Jigsaw provides a notion of modularity independent of a particular computational paradigm. Jigsaw can therefore be applied to a wide variety of languages, especially special-purpose languages where the effort of designing specific mechanisms for modularity is difficult to justify, but which could still benefit from such mechanisms. The framework is used to derive an extension of Modula-3 that supports the new operations. An efficient implementation strategy is developed for this extension. The performance of this scheme is on a par with the methods employed by the highest performance object-oriented language processors currently available.

[1]  Didier Rémy,et al.  Type checking records and variants in a natural extension of ML , 1989, POPL '89.

[2]  Benjamin C. Pierce,et al.  A record calculus based on symmetric concatenation , 1991, POPL '91.

[3]  Gul A. Agha,et al.  ACTORS - a model of concurrent computation in distributed systems , 1985, MIT Press series in artificial intelligence.

[4]  Henry Lieberman,et al.  Using prototypical objects to implement shared behavior in object-oriented systems , 1986, OOPLSA '86.

[5]  Mark A. Linton,et al.  Interviews: A C++ graphical interface toolkit , 1988 .

[6]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[7]  A. Snyder CommonObjects: an overview , 1986, OOPWORK '86.

[8]  John C. Mitchell,et al.  An extension of standard ML modules with subtyping and inheritance , 1991, POPL '91.

[9]  Craig Chambers,et al.  Making pure object-oriented languages practical , 1991, OOPSLA '91.

[10]  Brad J. Cox,et al.  Object-oriented programming ; an evolutionary approach , 1986 .

[11]  Roy H. Campbell,et al.  A Class Hierarchy for Building Stream-Oriented File Systems , 1989, ECOOP.

[12]  John C. Mitchell,et al.  F-bounded polymorphism for object-oriented programming , 1989, FPCA.

[13]  Stein Krogdahl Multiple inheritance in Simula-like languages , 1985, BIT Comput. Sci. Sect..

[14]  Bent Bruun Kristensen,et al.  The BETA Programming Language , 1987, Research Directions in Object-Oriented Programming.

[15]  Oscar Nierstrasz,et al.  Towards an Object Calculus ∗ , 1991 .

[16]  Robin Milner,et al.  Communication and concurrency , 1989, PHI Series in computer science.

[17]  Craig Chambers,et al.  Parents are shared parts of objects: Inheritance and encapsulation in SELF , 1991, LISP Symb. Comput..

[18]  Luca Cardelli,et al.  Operations on records , 1989, Mathematical Structures in Computer Science.

[19]  Bjarne Stroustrup,et al.  The Annotated C++ Reference Manual , 1990 .

[20]  Bruce G. Lindsay,et al.  Static type checking of multi-methods , 1991, OOPSLA '91.

[21]  簡聰富,et al.  物件導向軟體之架構(Object-Oriented Software Construction)探討 , 1989 .

[22]  Kristen Nygaard,et al.  SIMULA: an ALGOL-based simulation language , 1966, CACM.

[23]  Rajendra K. Raj,et al.  A Compositional Model for Software Reuse , 1989, Computer/law journal.

[24]  Luca Cardelli,et al.  On understanding types, data abstraction, and polymorphism , 1985, CSUR.

[25]  Bjarne Stroustrup,et al.  C++ Programming Language , 1986, IEEE Softw..

[26]  Luca Cardelli,et al.  A Semantics of Multiple Inheritance , 1984, Inf. Comput..

[27]  Ronald Morrison,et al.  An object addressing mechanism for statically typed languages with multiple inheritance , 1989, OOPSLA '89.

[28]  Greg Nelson,et al.  Systems programming in modula-3 , 1991 .

[29]  Ole Lehrmann Madsen,et al.  Strong typing of object-oriented languages revisited , 1990, OOPSLA/ECOOP '90.

[30]  Henry Ledgard,et al.  Reference Manual for the ADA® Programming Language , 1983, Springer New York.

[31]  Thomas A. Cargill,et al.  Controversy: The Case Against Multiple Inheritance in C++ , 1991, Comput. Syst..

[32]  Uday S. Reddy,et al.  Objects as closures: abstract semantics of object-oriented languages , 1988, LISP and Functional Programming.

[33]  Craig Schaffert,et al.  An introduction to Trellis/Owl , 1986, OOPLSA '86.

[34]  Luca Cardelli,et al.  Modula-3 Report (revised) , 1992 .

[35]  AmericaPierre,et al.  A parallel object-oriented language with inheritance and subtyping , 1990 .

[36]  Mitchell Wand,et al.  Type inference for record concatenation and multiple inheritance , 1989, [1989] Proceedings. Fourth Annual Symposium on Logic in Computer Science.

[37]  Oscar Nierstrasz,et al.  Viewing object as patterns of communicating agents , 1990, OOPSLA/ECOOP '90.

[38]  Luca Cardelli,et al.  The Modula–3 type system , 1989, POPL '89.

[39]  Mark A. Linton,et al.  Unidraw: a framework for building domain-specific graphical editors , 1990, TOIS.

[40]  John McCarthy,et al.  Mathematical Theory of Computation , 1991 .

[41]  Alan Borning,et al.  Classes versus Prototypes in Object-Oriented Languages , 1986, FJCC.

[42]  William R. Cook,et al.  Mixin-based inheritance , 1990, OOPSLA/ECOOP '90.

[43]  Nuno Guimarães Building Generic User Interface Tools: an Experience with Multiple Inheritance , 1991, OOPSLA.

[44]  Erich Gamma,et al.  ET++—an object oriented application framework in C++ , 1988, OOPSLA 1988.

[45]  David A. Moon,et al.  Object-oriented programming with flavors , 1986, OOPLSA '86.

[46]  Daniel G. Bobrow,et al.  Book review: The Art of the MetaObject Protocol By Gregor Kiczales, Jim des Rivieres, Daniel G. and Bobrow(MIT Press, 1991) , 1991, SGAR.

[47]  Klaus-Peter Löhr,et al.  Object-Oriented Concurrent Programming , 1992, TOOLS.

[48]  Andreas V. Hense Wrapper Semantics of an Object-Oriented Programming Language with State , 1991, TACS.

[49]  Pierre America,et al.  A parallel object-oriented language with inheritance and subtyping , 1990, OOPSLA/ECOOP '90.

[50]  William R. Cook,et al.  A denotational semantics of inheritance , 1989 .

[51]  Ole Lehrmann Madsen,et al.  Virtual classes: a powerful mechanism in object-oriented programming , 1989, OOPSLA '89.

[52]  Roland Ducournau,et al.  On Some Algorithms for Multiple Inheritance in Object-Oriented Programming , 1987, ECOOP.

[53]  William R. Cook,et al.  Inheritance is not subtyping , 1989, POPL '90.

[54]  David B. MacQueen Modules for standard ML , 1984, LFP '84.

[55]  Alan Snyder Encapsulation and inheritance in object-oriented programming languages , 1986, OOPSLA 1986.

[56]  Juris Hartmanis,et al.  The Programming Language Ada Reference Manual American National Standards Institute, Inc. ANSI/MIL-STD-1815A-1983 , 1983, Lecture Notes in Computer Science.

[57]  Professor Dr. Niklaus Wirth,et al.  Programming in Modula-2 , 1982, Springer Berlin Heidelberg.

[58]  Oscar Nierstrasz,et al.  Towards and Object Calculus , 1991, Object-Based Concurrent Computing.

[59]  Samuel N. Kamin Inheritance in smalltalk-80: a denotational definition , 1988, POPL '88.

[60]  William R. Cook,et al.  Interfaces for strongly-typed object-oriented programming , 1989, OOPSLA '89.