ECOOP’ 99 — Object-Oriented Programming

Object-oriented programs [Dahl, Goldberg, Meyer] are notoriously prone to the following kinds of error, which could lead to increasingly severe problems in the presence of tasking 1. Following a null pointer 2. Deletion of an accessible object 3. Failure to delete an inaccessible object 4. Interference due to equality of pointers 5. Inhibition of optimisation due to fear of (4) Type disciplines and object classes are a great help in avoiding these errors. Stronger protection may be obtainable with the help of assertions, particularly invariants, which are intended to be true before and after each call of a method that updates the structure of the heap. This note introduces a mathematical model and language for the formulation of assertions about objects and pointers, and suggests that a graphical calculus [Curtis, Lowe] may help in reasoning about program correctness. It deals with both garbage-collected heaps and the other kind. The theory is based on a trace model of graphs, using ideas from process algebra; and our development seeks to exploit this analogy as a unifying principle.

[1]  David J. DeWitt,et al.  Implementing crash recovery in QuickStore: a performance study , 1995, SIGMOD '95.

[2]  Robert Wahbe,et al.  Practical data breakpoints: design and implementation , 1993, PLDI '93.

[3]  Michael J. Carey,et al.  Adaptive, fine-grained sharing in a client-server OODBMS: a callback-based approach , 1997, TODS.

[4]  Doug Kimelman,et al.  Visualizing the behavior of object-oriented systems , 1993, OOPSLA '93.

[5]  Jr. Guy L. Steele,et al.  Common LISP: the language (2nd ed.) , 1990 .

[6]  Marc H. Brown,et al.  Zeus: a system for algorithm animation and multi-view editing , 1991, Proceedings 1991 IEEE Workshop on Visual Languages.

[7]  Martin Hofmann,et al.  A unifying type-theoretic framework for objects , 1994, Journal of Functional Programming.

[8]  David W. Binkley,et al.  Program slicing , 2008, 2008 Frontiers of Software Maintenance.

[9]  Andrew Shalit,et al.  The Dylan Reference Manual: The Definitive Guide to the New Object-Oriented Dynamic Language , 1996 .

[10]  Andrew C. Myers,et al.  Subtypes vs. where clauses: constraining parametric polymorphism , 1995, OOPSLA.

[11]  Michael J. Carey,et al.  Fine-grained sharing in a page server OODBMS , 1994, SIGMOD '94.

[12]  Randall B. Smith,et al.  Self: The power of simplicity , 1987, OOPSLA 1987.

[13]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[14]  Kresten Krab Thorup Genericity in Java with Virtual Types , 1997, ECOOP.

[15]  Chris Laffra,et al.  Advanced Java: Idioms, Pitfalls, Styles and Programming Tips , 1996 .

[16]  Andreas Paepcke Object-oriented programming: the CLOS perspective , 1993 .

[17]  Erich Gamma,et al.  Integration of a Programming Environment into ET++ - A Case Study , 1989, ECOOP.

[18]  Ashok Malhotra,et al.  HotWire - A Visual Debugger for C++ , 1994, C++ Conference.

[19]  Luca Cardelli,et al.  Comparing Object Encodings , 1997, TACS.

[20]  Craig Chambers,et al.  Object-Oriented Multi-Methods in Cecil , 1992, ECOOP.

[21]  Stephen M. Omohundro,et al.  Sather Iters: Object-Oriented Iteration Abstraction , 1993 .

[22]  Adriana B. Compagnoni,et al.  Decidability of Higher-Order Subtyping with Intersection Types , 1994, CSL.

[23]  John C. Reynolds,et al.  Syntactic control of interference , 1978, POPL.

[24]  Jan Vitek,et al.  Compact Dispatch Tables for Dynamically Typed Programming Languages , 1996 .

[25]  Robert Bruce Findler,et al.  Modular object-oriented programming with units and mixins , 1998, ICFP '98.

[26]  Timothy A. Budd,et al.  Multiparadigm programming in Leda , 1994 .

[27]  Barbara Liskov,et al.  Collecting cyclic distributed garbage by controlled migration , 1995, PODC '95.

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

[29]  Mads Torgersen Virtual types are statically safe , 1998 .

[30]  Arvind Parthasarathi,et al.  The NetLog : an efficient, highly available, stable storage abstraction , 1998 .

[31]  Stephan Merz,et al.  Type checking higher-order polymorphic multi-methods , 1997, POPL '97.

[32]  Benjamin C. Pierce,et al.  Simple type-theoretic foundations for object-oriented programming , 1994, Journal of Functional Programming.

[33]  Mads Torgersen,et al.  Unifying Genericity - Combining the Benefits of Virtual Types and Parameterized Classes , 1999, ECOOP.

[34]  Dennis Shasha,et al.  2Q: A low overhead high performance buffer replacement algorithm , 1994 .

[35]  AxB,et al.  Multi-Method Dispatch Using Single-Receiver Projections , 1998 .

[36]  Mark Lillibridge,et al.  A type-theoretic approach to higher-order modules with sharing , 1994, POPL '94.

[37]  Xavier Leroy,et al.  Manifest types, modules, and separate compilation , 1994, POPL '94.

[38]  Jeffrey F. Naughton,et al.  A stochastic approach for clustering in object bases , 1991, SIGMOD '91.

[39]  Kim B. Bruce,et al.  Semantics-Driven Language Design: Statically Type-safe Virtual Types in Object-oriented Languages , 1999, MFPS.

[40]  Gang Chen,et al.  Subtyping Parametric and Dependent Types , 1996 .

[41]  William R. Cook,et al.  Object-Oriented Programming Versus Abstract Data Types , 1990, REX Workshop.

[42]  Donald Kossmann Efficient main-memory management of persistent objects , 1995, Berichte aus der Informatik.

[43]  R. Nigel Horspool,et al.  Near Optimal Hierarchical Encoding of Types , 1997, ECOOP.

[44]  Benjamin C. Pierce,et al.  Higher-Order Subtyping , 1994, Theor. Comput. Sci..

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

[46]  Peter Honeyman,et al.  Multi-level Caching in Distributed File Systems or Your cache ain't nuthin' but trash , 1992 .

[47]  Gruia-Catalin Roman,et al.  Pavane: a system for declarative visualization of concurrent computations , 1992, J. Vis. Lang. Comput..

[48]  Frank Wm. Tompa,et al.  Efficiently updating materialized views , 1986, SIGMOD '86.

[49]  Frank Tip,et al.  A survey of program slicing techniques , 1994, J. Program. Lang..

[50]  Doug Kimelman,et al.  Strata-various: multi-layer visualization of dynamics in software system behavior , 1994, Proceedings Visualization '94.

[51]  Wilf R. LaLonde,et al.  An exemplar based Smalltalk , 1986, OOPLSA '86.

[52]  Barbara Liskov,et al.  Fault-tolerant distributed garbage collection in a client-server object-oriented database , 1994, Proceedings of 3rd International Conference on Parallel and Distributed Information Systems.

[53]  Richard S. Bird,et al.  Introduction to functional programming , 1988, Prentice Hall International series in computer science.

[54]  Wilf R. LaLonde Discovering smalltalk , 1994, Benjamin/Cummings series in object-oriented software engineering.

[55]  Marvin H. Solomon,et al.  A trace-based simulation of pointer swizzling techniques , 1995, Proceedings of the Eleventh International Conference on Data Engineering.

[56]  Stephen M. Omohundro,et al.  The Sather programming language , 1993 .

[57]  Giuseppe Castagna,et al.  A calculus for overloaded functions with subtyping , 1992, LFP '92.

[58]  Ken Arnold,et al.  The Java Programming Language , 1996 .

[59]  Andrew C. Myers,et al.  References to remote mobile objects in Thor , 1993, LOPL.

[60]  Pierre Jouvelot,et al.  Algebraic reconstruction of types and effects , 1991, POPL '91.

[61]  Bjarne Steensgaard,et al.  Points-to analysis in almost linear time , 1996, POPL '96.

[62]  Marc H. Brown,et al.  Exploring algorithms using Balsa-II , 1988, Computer.

[63]  Peter G. Neumann Risks to the public in computer systems , 1986, SOEN.

[64]  J. T. Robinson,et al.  Data cache management using frequency-based replacement , 1990, SIGMETRICS '90.

[65]  Bjarne Stroustrup,et al.  C++ : programovací jazyk : The C++ programming language (Orig.) , 1997 .

[66]  Giuseppe Castagna,et al.  Object-Oriented Programming A Unified Foundation , 1997, Progress in Theoretical Computer Science.

[67]  Vivek Singhal,et al.  Texas: An Efficient, Portable Persistent Store , 1992, POS.

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

[69]  Yike Guo,et al.  Parallel skeletons for structured composition , 1995, PPOPP '95.

[70]  Danny B. Lange,et al.  Object-Oriented Program Tracing and Visualization , 1997, Computer.

[71]  Giuseppe Castagna,et al.  Covariance and contravariance: conflict without a cause , 1995, TOPL.

[72]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[73]  Martin Odersky,et al.  A Statically Safe Alternative to Virtual Types , 1998, ECOOP.

[74]  Eric K. Clemons,et al.  Efficiently monitoring relational databases , 1979, ACM Trans. Database Syst..

[75]  Gary T. Leavens,et al.  Multiple dispatch as dispatch on Tuples , 1998, OOPSLA '98.

[76]  K Thomas The Function Object Pattern , 1997 .

[77]  Sanjay Ghemawat,et al.  The Modified Object Buffer: A Storage Management Technique for Object-Oriented Databases , 1995 .

[78]  Robert Martin Discovering patterns in existing applications , 1995 .

[79]  Craig Chambers,et al.  The cecil language: specification and rationale , 1993 .

[80]  Wolfgang Klas,et al.  Efficient Dynamic Look-Up Strategy for Multi-Methods , 1994, ECOOP.

[81]  Mark Evered,et al.  Collection types and implementations in object-oriented software libraries , 1998, Proceedings. Technology of Object-Oriented Languages. TOOLS 26 (Cat. No.98EX176).

[82]  Kim B. Bruce,et al.  PolyTOIL: A Type-Safe Polymorphic Object-Oriented Language , 1995, ECOOP.

[83]  Ole Lehrmann Madsen,et al.  Strong typing of object-oriented languages revisited , 1990 .

[84]  Bertrand Meyer,et al.  Eiffel: The Language , 1991 .

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

[86]  Abdul Waheed,et al.  VIZIR: an integrated environment for distributed program visualization , 1995, MASCOTS '95. Proceedings of the Third International Workshop on Modeling, Analysis, and Simulation of Computer and Telecommunication Systems.

[87]  Martín Abadi,et al.  An Imperative Object Calculus , 1995, TAPSOFT.

[88]  Luca Cardelli,et al.  A Semantics of Multiple Inheritance , 1984, Information and Computation.

[89]  Robert E. Gruber,et al.  Optimism vs. locking: a study of concurrency control for client-server object-oriented databases , 1997 .

[90]  Guido Moerkotte,et al.  On the cost of monitoring and reorganization of object bases for clustering , 1996, SGMD.

[91]  Bjørn N. Freeman-Benson,et al.  Visualizing dynamic software system information through high-level models , 1998, OOPSLA '98.

[92]  Craig S. Kaplan,et al.  Predicate Dispatching: A Unified Theory of Dispatch , 1998, ECOOP.

[93]  Olivier Gruber,et al.  Optimizing Multi-Method Dispach Using Compressed Dispach Tables , 1994, BDA.

[94]  David Notkin,et al.  Using C++ Templates to Implement Role-Based Designs , 1996, ISOTAS.

[95]  Erich Gamma,et al.  ET++—a portable, homogeneous class library and application framework , 1995 .

[96]  John G. Hosking,et al.  Multi-Methods in a Statically-Typed Programming Language , 1991, ECOOP.

[97]  Karel Driesen Selector table indexing & sparse arrays , 1993, OOPSLA '93.

[98]  Sheng Liang,et al.  Dynamic class loading in the Java virtual machine , 1998, OOPSLA '98.

[99]  Jack A. Orenstein,et al.  The ObjectStore database system , 1991, CACM.

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

[101]  Matthias Felleisen,et al.  Classes and mixins , 1998, POPL '98.

[102]  Martin Odersky,et al.  Pizza into Java: translating theory into practice , 1997, POPL '97.

[103]  J. O'Toole,et al.  Opportunistic Log : Efficient Reads in a Reliable Object Server , 1994 .

[104]  J. Eliot B. Moss,et al.  Design of the Mneme persistent object store , 1990, TOIS.

[105]  Gary T. Leavens,et al.  BeCecil, A Core Object-Oriented Language with Block Structure and Multimethods: Semantics and Typing , 1997 .

[106]  Andreas Reuter,et al.  Transaction Processing: Concepts and Techniques , 1992 .

[107]  James Coplien,et al.  Supporting Truly Object-Oriented Debugging of C++ Programs , 1994, C++ Conference.

[108]  David J. DeWitt,et al.  QuickStore: A High Performance Mapped Object Store , 1994, SIGMOD Conference.

[109]  David Notkin,et al.  On the use of static typing to support operations on frameworks , 1996, Object Oriented Syst..

[110]  T. Kaehler,et al.  LOOM: large object-oriented memory for Smalltalk-80 systems , 1989 .

[111]  Gruia-Catalin Roman,et al.  A taxonomy of program visualization systems , 1993, Computer.

[112]  Mark S. Day,et al.  Client cache management in a distributed object database , 1995 .

[113]  H. Mossenbock,et al.  Films as graphical comments in the source code of programs , 1997, Proceedings of TOOLS USA 97. International Conference on Technology of Object Oriented Systems and Languages.

[114]  Thomas Kühne,et al.  A functional pattern system for object-oriented design , 1999 .

[115]  J. Hopcroft,et al.  Robust Iterators in ET++ , 1992 .

[116]  K. Rustan M. Leino,et al.  Data groups: specifying the modification of extended state , 1998, OOPSLA '98.

[117]  Weimin Chen Efficient multiple dispatching based on automata , 1996 .

[118]  Peter F. Patel-Schneider,et al.  Modeling dynamic collections of interdependent objects using path-based rules , 1997, OOPSLA '97.

[119]  David Kenneth Gifford,et al.  Information storage in a decentralized computer system , 1981 .

[120]  Barbara Liskov,et al.  Program Development in Java - Abstraction, Specification, and Object-Oriented Design , 1986 .

[121]  Eric Simon,et al.  Fast algorithms for compressed multimethod dispatch table generation , 1998, TOPL.

[122]  Luca Cardelli,et al.  A Semantic Basis for Quest , 1991, J. Funct. Program..

[123]  Miguel Castro,et al.  Type-Safe Heterogeneous Sharing can be Fast , 1996, POS.

[124]  Urs Hölzle,et al.  Binary Component Adaptation , 1997, ECOOP.

[125]  J. Eliot B. Moss,et al.  Working with Persistent Objects: To Swizzle or Not to Swizzle , 1992, IEEE Trans. Software Eng..

[126]  Pierre Jouvelot,et al.  Polymorphic type, region and effect inference , 1992, Journal of Functional Programming.

[127]  David R. Hanson,et al.  DUEL - A Very High-Level Debugging Language , 1993, USENIX Winter.

[128]  Yannis Smaragdakis,et al.  Implementing Layered Designs with Mixin Layers , 1998, ECOOP.

[129]  Luca Cardelli,et al.  Typeful Programming , 1989, Formal Description of Programming Concepts.

[130]  Richard B. Kieburtz,et al.  Programming with Algebras , 1995, Advanced Functional Programming.

[131]  Ole Lehrmann Madsen,et al.  Object-oriented programming in the BETA programming language , 1993 .

[132]  M. Lillibridge Translucent Sums: A Foundation for Higher-Order Module Systems , 1997 .

[133]  Bertrand Meyer,et al.  Genericity versus inheritance , 1986, OOPLSA '86.

[134]  Marc Eisenstadt,et al.  My hairiest bug war stories , 1997, CACM.

[135]  John C. Reynolds,et al.  Using category theory to design implicit conversions and generic operators , 1980, Semantics-Directed Compiler Generation.

[136]  Stephen N. Freund,et al.  Adding type parameterization to the Java language , 1997, OOPSLA '97.

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

[138]  Eileen Kraemer,et al.  Interactive visual exploration of distributed computations , 1997, Proceedings 11th International Parallel Processing Symposium.

[139]  Ambuj K. Singh,et al.  Query-based debugging of object-oriented programs , 1997, OOPSLA '97.

[140]  Gerhard Weikum,et al.  The LRU-K page replacement algorithm for database disk buffering , 1993, SIGMOD Conference.

[141]  David J. DeWitt,et al.  The oo7 Benchmark , 1993, SIGMOD Conference.

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

[143]  Elisa Bertino,et al.  Extending the ODMG object model with composite objects , 1998, OOPSLA '98.

[144]  David L. Mills,et al.  Network Time Protocol (Version 3) Specification, Implementation and Analysis , 1992, RFC.

[145]  David J. DeWitt,et al.  A Performance Study of Alternative Object Faulting and Pointer Swizzling Strategies , 1992, VLDB.

[146]  M. P. Zabinski,et al.  Introduction to APL and computer programming , 1977 .

[147]  Benjamin C. Pierce,et al.  Bounded quantification is undecidable , 1992, POPL '92.

[148]  J. O'Toole,et al.  Shared data management needs adaptive methods , 1995, Proceedings 5th Workshop on Hot Topics in Operating Systems (HotOS-V).

[149]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[150]  Roger King,et al.  Self-adaptive, on-line reclustering of complex object data , 1994, SIGMOD '94.

[151]  Mark N. Wegman,et al.  Execution Patterns in Object-Oriented Visualization , 1998, COOTS.

[152]  Andrew C. Myers,et al.  Parameterized types for Java , 1997, POPL '97.

[153]  Miguel Castro,et al.  Safe and efficient sharing of persistent objects in Thor , 1996, SIGMOD '96.

[154]  Jeffrey C. Mogul,et al.  Performance Implications of Multiple Pointer Sizes , 1995, USENIX.

[155]  Duane Szafron,et al.  Multi-method Dispatch Using Multiple Row Displacement , 1999, ECOOP.

[156]  J. Y. Girard,et al.  Interpretation fonctionelle et elimination des coupures dans l'aritmetique d'ordre superieur , 1972 .

[157]  Gary T. Leavens,et al.  Typechecking and modules for multi-methods , 1994, OOPSLA 1994.

[158]  Hans-Jörg Schek,et al.  A Signature Access Method for the Starburst Database System , 1989, VLDB.