Ownership-Based Alias Managemant

Object-oriented programming relies on sharing and the mutable states of objects for common data structures, patterns and programming idioms. Sharing and mutable state is a powerful but dangerous co ...

[1]  Jan Vitek,et al.  Real-time Java scoped memory: design patterns and semantics , 2004, Seventh IEEE International Symposium onObject-Oriented Real-Time Distributed Computing, 2004. Proceedings..

[2]  David Walker,et al.  Typed memory management in a calculus of capabilities , 1999, POPL '99.

[3]  John C. Reynolds,et al.  Towards a theory of type structure , 1974, Symposium on Programming.

[4]  Martin C. Rinard,et al.  ACM Conference on Object-Oriented Programming, Systems, Languages and Applications (OOPSLA), November 2002 Ownership Types for Safe Programming: Preventing Data Races and Deadlocks , 2022 .

[5]  John Hogg.  Islands: aliasing protection in object-oriented languages , 1991, OOPSLA 1991.

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

[7]  Martin Fowler,et al.  Refactoring - Improving the Design of Existing Code , 1999, Addison Wesley object technology series.

[8]  Dave Clarke,et al.  External Uniqueness Is Unique Enough , 2003, ECOOP.

[9]  Robert DeLine,et al.  Enforcing high-level protocols in low-level software , 2001, PLDI '01.

[10]  Jean-Yves Girard,et al.  Linear Logic , 1987, Theor. Comput. Sci..

[11]  Peter Müller,et al.  Universes: Lightweight Ownership for JML , 2005, J. Object Technol..

[12]  James Noble,et al.  Checking Ownership and Confinement Properties , 2002 .

[13]  William E. Lorensen,et al.  Object-Oriented Modeling and Design , 1991, TOOLS.

[14]  David Walker,et al.  Alias Types , 2000, ESOP.

[15]  Tobias Wrigstad,et al.  A mode system for read-only references in Java , 2001 .

[16]  James Noble,et al.  Overcoming Representation Exposure , 1999, ECOOP Workshops.

[17]  K. Rustan M. Leino,et al.  Virginity: A Contribution to the Specification of Object-Oriented Software , 1999, Inf. Process. Lett..

[18]  Emin Gün Sirer,et al.  Static Analyses for Eliminating Unnecessary Synchronization from Java Programs , 1999, SAS.

[19]  Peter W. O'Hearn,et al.  Local Reasoning about Programs that Alter Data Structures , 2001, CSL.

[20]  Grady Booch,et al.  Object-Oriented Design with Applications , 1990 .

[21]  Naftaly H. Minsky.  Towards Alias-Free Pointers , 1996, ECOOP.

[22]  Ian M. Graham.  Object-oriented methods , 1991 .

[23]  James Noble,et al.  Ownership types for flexible alias protection , 1998, OOPSLA '98.

[24]  James Noble,et al.  Towards a Model of Encapsulation , 2003 .

[25]  Martin C. Rinard,et al.  Ownership types for safe region-based memory management in real-time Java , 2003, PLDI '03.

[26]  Martin Odersky,et al.  Making the future safe for the past: adding genericity to the Java programming language , 1998, OOPSLA '98.

[27]  K. Rustan M. Leino,et al.  Using data groups to specify and check side effects , 2002, PLDI '02.

[28]  Jonathan Aldrich,et al.  Using Types to Enforce Architectural Structure , 2008, Seventh Working IEEE/IFIP Conference on Software Architecture (WICSA 2008).

[29]  Martín Abadi,et al.  A Theory of Objects , 1996, Monographs in Computer Science.

[30]  John Tang Boyland,et al.  Alias burying: Unique variables without destructive reads , 2001, Softw. Pract. Exp..

[31]  James Noble,et al.  The ins and outs of objects , 1998, Proceedings 1998 Australian Software Engineering Conference (Cat. No.98EX233).

[32]  Henry G. Baker,et al.  Infant mortality and generational garbage collection , 1993, SIGP.

[33]  Michael D. Ernst,et al.  A practical type system and language for reference immutability , 2004, OOPSLA '04.

[34]  Rebecca Wirfs-Brock,et al.  Designing object-oriented software , 1990 .

[35]  Mickey Williams.  Microsoft Visual C , 2002 .

[36]  James Gosling,et al.  The Real-Time Specification for Java , 2000, Computer.

[37]  Anindya Banerjee,et al.  Ownership confinement ensures representation independence for object-oriented programs , 2002, JACM.

[38]  Bruce W. Weide,et al.  Copying and Swapping: Influences on the Design of Reusable Software Components , 1991, IEEE Trans. Software Eng..

[39]  Gordon S. Blair,et al.  Object-oriented languages, systems and applications , 1991 .

[40]  Martin Rinard,et al.  Safe Runtime Downcasts With Ownership Types , 2002 .

[41]  Jan Vitek,et al.  Scoped types for real-time Java , 2004, 25th IEEE International Real-Time Systems Symposium.

[42]  Ralf Hinze,et al.  Haskell 98 — A Non−strict‚ Purely Functional Language , 1999 .

[43]  David Walker,et al.  Alias Types for Recursive Data Structures , 2000, Types in Compilation.

[44]  David Gerard Clarke,et al.  Object ownership and containment , 2003 .

[45]  Ignacio Amostoy,et al.  M.T.M. , 1994 .

[46]  John Tang Boyland.  Alias Killing: Unique Variables without Destructive Reads , 1999, ECOOP Workshops.

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

[48]  James Noble,et al.  Simple Ownership Types for Object Containment , 2001, ECOOP.

[49]  Riccardo Pucella,et al.  Phantom types and subtyping , 2002, Journal of Functional Programming.

[50]  Liuba Shrira,et al.  Ownership Types and Safe Lazy Upgrades in Object-Oriented Databases , 2002 .

[51]  Stuart Kent,et al.  Encapsulation and Aggregation , 1995 .

[52]  K. Rustan M. Leino,et al.  Modular Verification of Static Class Invariants , 2005, FM.

[53]  Nick Mitchell,et al.  LeakBot: An Automated and Lightweight Tool for Diagnosing Memory Leaks in Large Java Applications , 2003, ECOOP.

[54]  Philip Wadler,et al.  Linear Types can Change the World! , 1990, Programming Concepts and Methods.

[55]  Paulo Sérgio Almeida.  Balloon Types: Controlling Sharing of State in Data Types , 1997, ECOOP.

[56]  David Gay,et al.  Fast Escape Analysis and Stack Allocation for Object-Based Programs , 2000, CC.

[57]  Guido Rossum,et al.  Python Reference Manual , 2000 .

[58]  John C. Reynolds,et al.  Separation logic: a logic for shared mutable data structures , 2002, Proceedings 17th Annual IEEE Symposium on Logic in Computer Science.

[59]  John Tang Boyland,et al.  Capabilities for Sharing: A Generalisation of Uniqueness and Read-Only , 2001, ECOOP.

[60]  Gavin M. Bierman,et al.  Separation logic and abstraction , 2005, POPL '05.

[61]  Gregory Kulczycki,et al.  Direct reasoning , 2004 .

[62]  Bruno Blanchet,et al.  Escape analysis: correctness proof, implementation and experimental results , 1998, POPL '98.

[63]  Robert DeLine,et al.  Adoption and focus: practical linear types for imperative programming , 2002, PLDI '02.

[64]  Peter Müller,et al.  Modular Specification and Verification of Object-Oriented Programs , 2002, Lecture Notes in Computer Science.

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

[66]  A.P.W. Eliëns.  Principles of Object-Oriented Software Development, 2nd Edition , 2000 .

[67]  Craig Chambers,et al.  Alias annotations for program understanding , 2002, OOPSLA '02.

[68]  Naoki Kobayashi.  Quasi-linear types , 1999, POPL '99.

[69]  Mads Tofte,et al.  Region-based Memory Management , 1997, Inf. Comput..

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

[71]  Richard C. Holt,et al.  The Geneva convention on the treatment of object aliasing , 1992, OOPS.

[72]  Hinrich Schütze,et al.  Book Reviews: Foundations of Statistical Natural Language Processing , 1999, CL.

[73]  Jan Vitek,et al.  Flexible Alias Protection , 1998, ECOOP.

[74]  K. Rustan M. Leino,et al.  Object Invariants in Dynamic Contexts , 2004, ECOOP.

[75]  Tobias Wrigstad,et al.  Alias Control with Read-Only References , 2002, JCIS.

[76]  Benjamin C. Pierce,et al.  Types and programming languages: the next generation , 2003, 18th Annual IEEE Symposium of Logic in Computer Science, 2003. Proceedings..

[77]  Timothy A. Budd,et al.  An introduction to object-oriented programming , 1991 .

[78]  David F. Bacon,et al.  Guava: a dialect of Java without data races , 2000, OOPSLA '00.

[79]  Liuba Shrira,et al.  Ownership types for object encapsulation , 2003, POPL '03.

[80]  Toshiyuki Masui,et al.  Real-world programming , 2000, DARE '00.

[81]  David Notkin,et al.  ArchJava: connecting software architecture to implementation , 2002, ICSE '02.

[82]  Alexander Aiken,et al.  How is aliasing used in systems software? , 2006, SIGSOFT '06/FSE-14.

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

[84]  Albert L. Baker,et al.  JML: A Notation for Detailed Design , 1999, Behavioral Specifications of Businesses and Systems.

[85]  C. A. R. Hoare,et al.  An axiomatic basis for computer programming , 1969, CACM.

[86]  Peter H. Golde,et al.  C# Language Specification , 2003 .

[87]  Craig Chambers,et al.  Ownership Domains: Separating Aliasing Policy from Mechanism , 2004, ECOOP.

[88]  James Noble,et al.  Generic ownership: practical ownership control in programming languages , 2004, OOPSLA '04.

[89]  Doug Lea,et al.  Concurrent programming in Java - design principles and patterns , 1996, Java series.

[90]  Peter W. O'Hearn,et al.  Separation and information hiding , 2004, POPL.

[91]  Christopher G. Lasater,et al.  Design Patterns , 2008, Wiley Encyclopedia of Computer Science and Engineering.

[92]  Michael R. Clarkson,et al.  Polyglot: An Extensible Compiler Framework for Java , 2003, CC.

[93]  Martin C. Rinard,et al.  A parameterized type system for race-free Java programs , 2001, OOPSLA '01.

[94]  James Noble,et al.  Saving the world from bad beans: deployment-time confinement checking , 2003, OOPSLA 2003.

[95]  Dirk Theisen,et al.  JAC—Access right based encapsulation for Java , 2001, Softw. Pract. Exp..

[96]  Martín Abadi,et al.  Types for Safe Locking , 1999, ESOP.

[97]  Jens Palsberg,et al.  Encapsulating objects with confined types , 2001, OOPSLA 2001.

[98]  Jonathan Aldrich,et al.  Permission-based ownership: encapsulating state in higher-order typed languages , 2005, PLDI '05.

[99]  K. Rustan M. Leino,et al.  Verification of Object-Oriented Programs with Invariants , 2003, J. Object Technol..

[100]  Jens Palsberg,et al.  Type-based confinement , 2006, J. Funct. Program..

[101]  William R. Cook,et al.  A virtual class calculus , 2006, POPL '06.

[102]  David Walker,et al.  On Regions and Linear Types , 2001, ACM SIGPLAN International Conference on Functional Programming.

[103]  Henry G. Baker,et al.  “Use-once” variables and linear objects: storage management, reflection and multi-threading , 1995, SIGP.

[104]  James Noble,et al.  Iterators and encapsulation , 2000, Proceedings 33rd International Conference on Technology of Object-Oriented Languages and Systems TOOLS 33.

[105]  James Cheney,et al.  Region-based memory management in cyclone , 2002, PLDI '02.

[106]  Jan Vitek,et al.  Confined types , 1999, OOPSLA '99.

[107]  David Gay,et al.  Language support for regions , 2001, PLDI '01.

[108]  George Shepherd,et al.  Microsoft Visual C++ .NET (Core Reference) , 2002 .

[109]  Greg Nelson,et al.  Wrestling with rep exposure , 1998 .

[110]  Peter Grogono,et al.  Copying, Sharing, and Aliasing , 1994, COODBSE.