Index: doc/bibliography/cfa.bib =================================================================== --- doc/bibliography/cfa.bib (revision e55ca0532660df6b168cbfe023499f87bda57a53) +++ doc/bibliography/cfa.bib (revision ab60d6d17cfff355f0806c9b966de1f177e7e4fd) @@ -1,1 +1,6871 @@ -/usr/local/bibliographies/pl.bib +% Conventions: uncross-referenced entries appear first, then +% cross-referenced entries. In both groups, entries are sorted by their +% title field. Lines like "% A" exist to speed searches. The main +% paper on a language uses the language name as the citation key. Other +% papers use ``:'' as a prefix. Please consider leaving +% keyword lists and an abstract or comment for future generations, and +% put some identification in a contributer field. + +% Predefined journal names: +% acmcs: Computing Surveys acta: Acta Infomatica +% cacm: Communications of the ACM +% ibmjrd: IBM J. Research & Development ibmsj: IBM Systems Journal +% ieeese: IEEE Trans. on Soft. Eng. ieeetc: IEEE Trans. on Computers +% ieeetcad: IEEE Trans. on Computer-Aided Design of Integrated Circuits +% ipl: Information Processing Letters jacm: Journal of the ACM +% jcss: J. Computer & System Sciences scp: Science of Comp. Programming +% sicomp: SIAM J. on Computing tocs: ACM Trans. on Comp. Systems +% tods: ACM Trans. on Database Sys. tog: ACM Trans. on Graphics +% toms: ACM Trans. on Math. Software toois: ACM Trans. on Office Info. Sys. +% toplas: ACM Trans. on Prog. Lang. & Sys. +% tcs: Theoretical Computer Science +@string{ieeepds="IEEE Transactions on Parallel and Distributed Systems"} +@string{ieeese="IEEE Transactions on Software Engineering"} +@string{spe="Software---\-Practice and Experience"} +@string{sigplan="SIGPLAN Notices"} +@string{joop="Journal of Object-Oriented Programming"} +@string{popl="Conference Record of the ACM Symposium on Principles of Programming Languages"} +@string{osr="Operating Systems Review"} +@string{pldi="Programming Language Design and Implementation"} + +% A + +@incollection{ABC++, + keywords = {concurrency, parallel, distributed, C++}, + contributer = {pabuhr@plg}, + author = {William G. O'Farrell and Frank Ch. Eigler and S. David Pullara and Gregory V. Wilson }, + title = {{ABC}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + editor = {Gregory V. Wilson and Paul Lu}, + booktitle = {Parallel Programming in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + publisher = {MIT Press}, + series = {Scientific and Engineering Computation Series}, + year = 1996, + pages = {1-42}, +} + +@techreport{CL90abstract, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Luca Cardelli and Xavier Leroy}, + title = {Abstract Types and the Dot Notation}, + institution = {Systems Research Center}, + year = 1990, + address = {130 Lytton Avenue, Palo Alto, CA 94301}, + number = 56, + summary = { + The existential types of Mitchell and Plotkin \cite{atet} model + abstract types, but their ``open'' notation is unlike the usual dot + notation used in programming languages. This paper gives + translations between the ``open'' and ``dot'' forms, and suggests + extensions for nested and for parameterized abstractions. + } +} + +@article{atet, + keywords = {lambda calculus, polymorphism}, + contributer = {gjditchfield@plg}, + author = {John C. Mitchell and Gordon D. Plotkin}, + title = {Abstract Types have Existential Type}, + journal = toplas, + year = 1988, + month = jul, volume = 10, number = 3, pages = {470-502}, + abstract = { + Abstract data type declarations appear in typed programming + languages like Ada, Alphard, CLU and ML. This form of declaration + binds a list of identifiers to a type with associated operations, a + composite ``value'' we call a {\em data algebra}. We use a + second-order typed lambda calculus SOL to show how data algebras + may be given types, passed as parameters, and returned as results of + function calls. In the process, we discuss the semantics of + abstract data type declarations and review a connection between + typed programming languages and constructive logic. + } +} + +@article{alphard:intro, + keywords = {encapsulation, data abstraction}, + contributer = {gjditchfield@plg}, + author = {Wm. A. Wulf and Ralph L. London and Mary Shaw}, + title = {Abstraction and Verification in Alphard: Introduction to Language and Methodology}, + journal = ieeese, + year = 1976, + month = dec, volume = {SE-2}, number = 4, pages = {253-265}, + note = {Reprinted in \cite{alphard}.}, + abstract = { + Alphard is a programming language whose goals include supporting + both the development of well-structured programs and the formal + verification of these programs. This paper attempts to capture the + symbiotic influence of these two goals on the design of the + language. To that end the language description is interleaved with + the presentation of a proof technique and discudssion of + programming methodology. Examples to illustrate both the language + and the verification technique are included. + } +} + +@book{Hilfinger83, + keywords = {ada}, + author = {Paul N. Hilfinger}, + title = {Abstraction Mechanisms and Language Design}, + publisher = {MIT Press}, + series = {ACM Distinguished Dissertations}, + year = 1983, +} + +@incollection{Lavender96, + author = {R. Greg Lavender and Douglas C. Schmidt}, + chapter = {Active Object: An Object Behavioral Pattern for Concurrent Programming}, + title = {Pattern Languages of Program Design 2}, + editor = {John M. Vlissides and James O. Coplien and Norman L. Kerth}, + year = 1996, + pages = {483-499}, + publisher = {Addison-Wesley Longman Publishing Co., Inc.}, + address = {Boston, MA, USA}, +} + +@article{Nierstrasz87, + keywords = {Hybrid, active objects, object-oriented languages, + object-based languages, delegation, concurrency}, + contributer = {pabuhr@plg}, + author = {O. M. Nierstrasz}, + title = {Active Objects in {Hybrid}}, + journal = sigplan, + volume = 22, + number = 12, + month = dec, + year = 1987, + pages = {243-253}, + note = {Proceedings of the OOPSLA'87 Conference, Oct. 4--8, 1987, Orlando, Florida}, + abstract = { + Most object-oriented languages are strong on reusability or on + strong-typing, but weak on concurrency. In response to this gap, + we are developing {\it Hybrid}, an object-oriented language in which + objects are the active entities. Objects in Hybrid are organized + into {\it domains}, and concurrent executions into {\it activities}. + All object communications are based on remote procedure calls. + Unstructured {\it sends\/} and {\it accepts\/} are forbidden. To + this the mechanisms of {\it delegation\/} and {\it delay queues\/} + are added to enable switching and triggering of activities. + Concurrent subactivities and atomic actions are provided for + compactness and simplicity. We show how solutions to many important + concurrent problems [sic], such as pipelining, constraint management + and ``administration'' can be compactly expressed using these + mechanisms. + }, + comment = {Mentions Thoth in reference to delegation} +} + +@book{Actors, + keywords = {actors, concurrency}, + contributer = {pabuhr@plg}, + author = {Gul A. Agha}, + title = {Actors: A Model of Concurrent Computation in Distributed Systems}, + publisher = {MIT Press, Cambridge, Mass.}, + year = 1986 +} + +@article{polymorphImpl, + keywords = {Napier88}, + contributer = {gjditchfield@plg}, + author = {R. Morrison and A. Dearle and R. C. H. Connor and A. L. Brown}, + title = {An Ad Hoc Approach to the Implementation of Polymorphism}, + journal = toplas, + year = 1991, + month = jul, + volume = 13, + number = 3, + pages = {342-371}, + abstract = { + Polymorphic abstraction provides the ability to write programs that + are independent of the form of the data over which they operate. + There are a number of different categories of polymorphic + expression---ad hoc and universal, which includes parametric and + inclusion---all of which have many advantages in terms of code + reuse and software economics. It has proved difficult to provide + efficient implementations of polymorphism. Here, we address this + problem and describe a new technique that can implement all forms + of polymorphism, use a conventional machine architecture, and + support nonuniform data representations. Furthermore, the method + ensures that any extra cost of implementation applies to + polymorphic forms only, and allows such polymorphic forms to + persist over program invocations. + }, + summary = { + They give three ways to implement polymorphism: {\em textual + polymorphism}, which seems to be template instantiation, {\em + uniform polymorphism}, which they explain badly, and {\em tagged + polymorphism}, where object code performs type tests. + + They use first-class procedures to implement polymorphism: routines + with type parameters are implemented as curried routines that + return a nested routine that refers to the type parameter. + } +} + +@article{dim:ada, + keywords = {Dimensional Analysis, Ada}, + contributer = {gjditchfield@plg}, + author = {Paul N. Hilfinger}, + title = {An {Ada} Package for Dimensional Analysis}, + journal = toplas, + month = apr, + year = 1988, + volume = 10, + number = 2, + pages = {189-203}, +} + +@mastersthesis{Younger91, + keywords = {concurrency, C++, postponing requests}, + contributer = {pabuhr@plg}, + author = {Brian M. Younger}, + title = {Adding Concurrency to {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + school = {University of Waterloo}, + year = 1991, + address = {Waterloo, Ontario, Canada, N2L 3G1}, +} + +@inproceedings{Buhr92c, + keywords = {concurrency}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr and Glen Ditchfield}, + title = {Adding Concurrency to a Programming Language}, + booktitle = {USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Technical Conference Proceedings}, + organization= {USENIX Association}, + address = {Portland, Oregon, U.S.A.}, + month = aug, + year = 1992, + pages = {207-224}, +} + +@article{Buhr89b, + keywords = {concurrency, C++}, + contributer = {pabuhr@plg}, + author = {P. A. Buhr and Glen Ditchfield and C. R. Zarnke}, + title = {Adding Concurrency to a Statically Type-Safe Object-Oriented Programming Language}, + journal = sigplan, + volume = 24, + number = 4, + month = apr, + year = 1989, + pages = {18-21}, + note = {Proceedings of the ACM SIGPLAN Workshop on Object-Based Concurrent Programming, Sept. 26--27, 1988, San Diego, California, U.S.A.}, +} + +@article{Knuth66, + keywords = {N-thread software-solution mutual exclusion}, + contributer = {pabuhr@plg}, + author = {Donald E. Knuth}, + title = {Additional Comments on a Problem in Concurrent Programming Control}, + journal = cacm, + month = may, + year = 1966, + volume = 9, + number = 5, + pages = {321-322}, + note = {Letter to the Editor} +} + +@article{DeBruijn67, + keywords = {N-thread software-solution mutual exclusion}, + contributer = {pabuhr@plg}, + author = {Nicolaas Govert de Bruijn}, + title = {Additional Comments on a Problem in Concurrent Programming Control}, + journal = cacm, + month = mar, + year = 1967, + volume = 10, + number = 3, + pages = {137-138}, + note = {letter to the Editor} +} + +@phdthesis{Krischer10, + author = {Roy Krischer}, + title = {Advanced Concepts in Asynchronous Exception Handling}, + school = {University of Waterloo}, + year = 2010, + month = dec, + address = {Waterloo, Ontario, Canada, N2L 3G1}, + optnote = {\textsf{http://uwspace.uwaterloo.ca/\-bitstream/10012/\-5751\-/1/Krischer\_Roy.pdf}}, + note = {\href{http://uwspace.uwaterloo.ca/bitstream/10012/5751/1/Krischer_Roy.pdf}{http://uwspace.uwaterloo.ca/\-bitstream/10012/\-5751\-/1/Krischer\_Roy.pdf}}, +} + +@article{Buhr00a, + keywords = {exception handling}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr and W. Y. Russell Mok}, + title = {Advanced Exception Handling Mechanisms}, + journal = ieeese, + volume = 26, + number = 9, + month = sep, + year = 2000, + pages = {820-836}, +} + +@book{Richter97, + keywords = {Win32, threads}, + author = {Jeffrey M. Richter}, + title = {Advanced Windows}, + publisher = {Microsoft Press}, + year = 1997, + edition = {third}, +} + +@article{Francez77, + keywords = {parameter passing, named/positional arguments}, + contributer = {pabuhr@plg}, + author = {Nissim Francez}, + title = {Another Advantage of Key word Notation for Parameter Communication with Subprograms}, + journal = cacm, + volume = 20, + number = 8, + month = aug, + year = 1977, + pages = {604-605}, +} + +@article{Algol60, + keywords = {Algol60}, + contributer = {pabuhr@plg}, + author = {J. W. Backus and F. L. Bauer and J. Green and C. Katz and + J. McCarthy and P. Naur and A. J. Perlis and H. Rutishauser and K. Samuelson + and B. Vauquois and J.H. Wegstein and A. van Wijngaarden and M. Woodger}, + title = {Revised Report on the Algorithmic Language Algol 60}, + editor = {Peter Nauer}, + journal = cacm, + volume = 6, + number = 1, + month = jan, + year = 1963, + pages = {1-17}, +} + +@article{Mellor-Crummey91, + keywords = {spin locks, compare-and-swap, barriers}, + contributer = {pabuhr@plg}, + author = {John M. Mellor-Crummey and Michael L. Scott}, + title = {Algorithm for Scalable Synchronization on Shared-Memory Multiprocessors}, + journal = tocs, + volume = 9, + number = 1, + month = feb, + year = 1991, + pages = {21-65}, +} + +@article{Cor:overload, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Gordon V. Cormack}, + title = {An Algorithm for the Selection of Overloaded Functions in {Ada}}, + journal = sigplan, + year = 1981, + month = feb, volume = 16, number = 2, pages = {48-52}, + comment = { + A one-pass, top-down algorithm for overload resolution. Input is a + parse tree and the desired result type, and output is the number of + solutions. For each overloading of the root identifier with a + matching parameter list, recursively solve for each parameter for + the corresponding argument type---there should be one solution. + } +} + +@book{Raynal86, + keywords = {mutual exclusion, locks}, + contributer = {pabuhr@plg}, + author = {M. Raynal}, + title = {Algorithms for Mutual Exclusion}, + publisher = {The MIT Press}, + address = {Cambridge, Massachusetts}, + series = {Scientific Computation Series}, + year = 1986, + note = {Translated by D. Beeson}, +} + +@incollection{Gidenstam05, + keywords = {lock free, dynamic memory allocation}, + contributer = {pabuhr@plg}, + author = {Anders Gidenstam and Marina Papatriantafilou and Philippas Tsigas}, + title = {Allocating Memory in a Lock-free Manner}, + editor = {Gerth St{\o}lting Brodal and Stefano Leonardi}, + booktitle = {Algorithms -- ESA 2005}, + pages = {329-342}, + publisher = {Springer}, + year = 2005, + volume = 3669, + series = {Lecture Notes in Computer Science}, +} + +@book{Sites92, + keywords = {computers, Alpha}, + contributer = {pabuhr@plg}, + editor = {Richard L. Sites}, + title = {Alpha Architecture Reference Manual}, + publisher = {Digital Press, One Burlington Woods Drive, Burlington, MA, U. S. A., 01803}, + year = 1992, +} + +@book{alphard, + keywords = {Parametric polymorphism, alphard, iterators, nested types}, + contributer = {gjditchfield@plg}, + editor = {Mary Shaw}, + title = {{ALPHARD}: Form and Content}, + publisher = {Springer-Verlag}, + year = 1981, + comment = {Collection of papers about Alphard.} +} + +@article{Kessels77, + keywords = {monitors}, + contributer = {pabuhr@plg}, + author = {Joep L. W. Kessels}, + title = {An Alternative to Event Queues for Synchronization in Monitors}, + journal = cacm, + volume = 20, + number = 7, + month = jul, + year = 1977, + pages = {500-503}, + annote = { + } +} + +@article{descr, + keywords = {X2, subclasses, inheritance, parameterized classes}, + contributer = {gjditchfield@plg}, + author = {David Sandberg}, + title = {An Alternative to Subclassing}, + journal = sigplan, + volume = {21}, number = {11}, + pages = {424-428}, + month = nov, year = 1986, + comment = { + The Smalltalk class hierarchy has three uses: factoring out code; + ``Abstraction superclasses'' such as Collection; rapid construction + of new classes by incremental change. + + ``A descriptive class specifies a partial behavior by specifying a + set of procedure headings that describe what can be done with + instances of classes that belong to the descriptive class.'' An + ``instance'' statement declares a class to be an instance of a + descriptive class and defines the correspondence between + operations. Procedures with descriptive class parameters take any + instance as arguments. Descriptive classes can describe relations + like ``c is a collection with element type e'', but how such things + are used isn't explained. + + For each descriptive class used in a parameter list, an implicit + parameter is created that is passed a vector of procedures. + } +} + +@incollection{Matsuoka93, + keywords = {inheritance anomaly}, + contributer = {pabuhr@plg}, + author = {Satoshi Matsuoka and Akinori Yonezawa}, + title = {Analysis of Inheritance Anomaly in Object-Oriented Concurrent Programming Languages}, + booktitle = {Research Directions in Concurrent Object-Oriented Programming}, + editor = {Gul Agha and Peter Wegner and Akinori Yonezawa}, + publisher = {MIT Press}, + year = 1993, + pages = {107-150}, +} + +@article{Sinha00, + author = {Saurabh Sinha and Mary Jean Harrold}, + title = {Analysis and Testing of Programs with Exception-Handling Constructs}, + journal = ieeese, + year = 2000, + month = sep, + volume = 26, + number = 9, + pages = {849--871}, +} + +@inproceedings{Robillard99, + author = {Martin P. Robillard and Gail C. Murphy}, + title = {Analyzing Exception Flow in {J}ava Programs}, + booktitle = {ESEC/FSE-7: Proceedings of the 7th European Software Engineering Conference held jointly + with the 7th ACM SIGSOFT International Symposium on Foundations of Software Engineering}, + year = 1999, + pages = {322--337}, + isbn = {3-540-66538-2}, + location = {Toulouse, France}, + doi = {http://doi.acm.org/10.1145/318773.319251}, + publisher = {Springer-Verlag}, + address = {London, UK}, +} + +@book{C++, + keywords = {C++, ANSI}, + author = {Margaret A. Ellis and Bjarne Stroustrup}, + title = {The Annotated {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Reference Manual}, + publisher = {Addison-Wesley}, + year = 1990, + edition = {first}, +} + +@book{APL, + keywords = {APL}, + contributer = {pabuhr@plg}, + author = {K. E. Iverson}, + title = {A Programming Language}, + publisher = {Wiley, New York}, + year = 1962 +} + +@article{PS-Algol:old, + author = {M. Atkinson and P. Bailey and K. Chisholm and P. Cockshott and R. Morrison}, + title = {An Approach to Persistent Programming}, + journal = {The Computer Journal}, + year = 1983, + volume = 26, + number = 4, + pages = {360-365}, +} + +@article{Kessels82, + keywords = {concurrency, critical section}, + contributer = {pabuhr@plg}, + author = {Joep L. W. Kessels}, + title = {Arbitration Without Common Modifiable Variables}, + journal = acta, + volume = 17, + number = 2, + month = jun, + year = 1982, + pages = {135-141}, +} + +@article{Buhr95a, + keywords = {concurrency, library approach}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr}, + title = {Are Safe Concurrency Libraries Possible?}, + journal = cacm, + month = feb, + year = 1995, + volume = 38, + number = 2, + pages = {117-120}, +} + +@book{ARMv7, + key = {ARM processor}, + title = {ARM Architecture Reference Manual}, + publisher = {ARM}, + volume = {ARM DDI 0406C.b (ID072512)}, + year = 2012, +} + +@book{Herlihy08, + contributer = {pabuhr@plg}, + author = {Herlihy, Maurice and Shavit, Nir}, + title = {The Art of Multiprocessor Programming}, + year = 2008, + isbn = {0123705916, 9780123705914}, + publisher = {Morgan Kaufmann Publishers Inc.}, + address = {San Francisco, CA, USA}, +} + +@inproceedings{Chung10, + keywords = {transactional memory, lock-free programming, x86 architecture}, + contributer = {pabuhr@plg}, + author = {Jaewoong Chung and Luke Yen and Stephan Diestelhorst and Martin Pohlack and Michael Hohmuth and David Christie and Dan Grossman}, + title = {ASF: AMD64 Extension for Lock-Free Data Structures and Transactional Memory}, + booktitle = {Proceedings of the 2010 43rd Annual IEEE/ACM International Symposium on Microarchitecture}, + series = {MICRO '43}, + year = 2010, + pages = {39--50}, + numpages = {12}, + publisher = {IEEE Computer Society}, + address = {Washington, DC, USA}, +} + +@article{Buhr94a, + keywords = {assignment, parameter passing, multiple assignment}, + contributer = {pabuhr@plg}, + author = {P. A. Buhr and David Till and C. R. Zarnke}, + title = {Assignment as the Sole Means of Updating Objects}, + journal = spe, + month = sep, + year = 1994, + volume = 24, + number = 9, + pages = {835-870}, +} + +@inproceedings{Krischer08, + keywords = {exception handling, asynchronous, blocked tasks}, + contributer = {pabuhr@plg}, + author = {Roy Krischer and Peter A. Buhr}, + title = {Asynchronous Exception Propagation in Blocked Tasks}, + booktitle = {4th International Workshop on Exception Handling (WEH.08)}, + organization= {16th International Symposium on the Foundations of Software Engineering (FSE 16)}, + address = {Atlanta, U.S.A}, + month = nov, + year = 2008, + pages = {8-15}, +} + +@article{oop:modpascal, + keywords = {ModPascal}, + contributer = {gjditchfield@plg}, + author = {Walter G. Olthoff}, + title = {Augmentation of Object-Oriented Programming by Concepts of Abstract Data Type Theory: The ModPascal Experience}, + journal = sigplan, + volume = 21, + number = 11, + pages = {429-443}, + month = nov, + year = 1986 +} + +@inproceedings{Shen91, + keywords = {Ada, polymorphism}, + contributer = {pabuhr@plg}, + author = {Jun Shen and Gordon V. Cormack}, + title = {Automatic instantiation in Ada}, + booktitle = {Proceedings of the ACM Tri-Ada Conference}, + organization= {ACM}, + address = {San Jose, California, U.S.A}, + month = oct, + year = 1991, + pages = {338-346}, +} + +@article{Havender68, + keywords = {deadlock}, + contributer = {pabuhr@plg}, + author = {J. W. Havender}, + title = {Avoiding Deadlock in Multitasking Systems}, + journal = ibmsj, + volume = 7, + number = 2, + year = 1968, + pages = {74-84}, +} + +% B + +@incollection{beta:old, + keywords = {beta, patterns, virtual types}, + contributer = {gjditchfield@plg}, + author = {Bent Bruun Kristensen and Ole Lehrmann Madsen and Birger M{\o}ller-Pedersen and Kristen Nygaard}, + title = {The BETA Programming Language}, + booktitle = {Research Directions in Object-Oriented Programming}, + publisher = {MIT Press}, + series = {Computer Systems Series}, + year = 1987, + pages = {7-48}, + editor = {Bruce Shriver and Peter Wegner} +} + +@article{Knudsen87, + keyword = {static exception handling mechanism, BETA, sequel}, + contributor = {wyrmok@plg}, + author = {J{\o}rgen Lindskov Knudsen}, + title = {Better Exception Handling in Block Structured Systems}, + journal = {IEEE Software}, + year = 1987, + month = may, + volume = 4, + number = 3, + pages = {40-49}, + comments = { + Going up the call hierarchy to look for a handler does not fit an + otherwise statically scoped language. Also, not knowing which handler + to be used when raising an abnormal event is seen as a weakness of the + (dynamic) exception handling mechanism. Knudsen believed that raising + an exception should specify the handler for the exception -- the + handler is chosen when the exception is raised. However, I don't think + his scheme can solve the problem, especially with all the callback + routines commonly found in OO programming. + + BETA exception handling mechanism uses his work as a foundation. + However, I don't see any benefits BETA has over other language that is + a direct consequence of Knudsen's work. On the other hand, my knowledge + on BETA is very limited. + } +} + +@book{BCPL, + keywords = {BCPL}, + contributer = {pabuhr@plg}, + author = {M. Richards and C. Whitby-Strevens}, + title = {{BCPL} -- The Language and Its Compiler}, + publisher = {Cambridge University Press, Cambridge}, + year = 1979, +} + +@incollection{Madsen87, + keywords = {nested classes}, + contributer = {pabuhr@watmsg}, + author = {Ole Lehrmann Madsen}, + title = {Block Structure and Object Oriented Languages}, + booktitle = {Research Directions in Object-Oriented Programming}, + editor = {Bruce Shriver and Peter Wegner}, + publisher = {MIT Press}, + series = {Computer Systems Series}, + year = 1987, + pages = {113-128} +} + +@inproceedings{booleanClasses, + keywords = {specifications}, + contributer = {gjditchfield@plg}, + author = {David McAllester and Ramin Zabih}, + title = {Boolean Classes}, + crossref = "OOPSLA86", + pages = {417-423}, + abstract = { + We extend the notion of class so that any Boolean combination of + classes is also a class. Boolean classes allow greater precision + and conciseness in naming the class of objects governed a + particular method [sic]. A class can be viewed as a predicate + which is either true or false of any given object. Unlike + predicates however classes have an inheritance hierarchy which is + known at compile time. Boolean classes extend the notion of class, + making classes more like predicates, while preserving the compile + time computable inheritance hierarchy. + }, + comment = { + Classes are predicates; if object {\tt o} is in class {\tt C}, then + {\tt C} is true of {\tt o}. Classes are combined with {\tt :AND}, + {\tt :OR}, and {\tt :NOT}. Inheritance is treated as implication: + {\tt (:implies C E)} means that if class {\tt C} is true of {\tt + o}, class expression {\tt E} is true of {\tt o}, so if {\tt E} is a + class, it is a superclass of {\tt C}. Some class expressions, i.e. + {\tt (:OR c1 c2)}, can't be instantiated. Others, i.e. {\tt (:NOT + c)}, can't be given methods or members because almost all classes + would inherit them, violating modularity. The rules for spotting + these problems are complex. Determining if one class inherits from + another needs an exponential algorithm. + } +} + +@mastersthesis{Krischer02, + author = {Roy Krischer }, + title = {Bound Exceptions in Object-Oriented Programming Languages}, + school = {Universit\"at Mannheim}, + address = {Mannheim, Deutschland}, + year = 2002, + month = oct, + type = {Diplomarbeit}, + note = {{\small\textsf{ftp://\-plg.uwaterloo.ca/\-pub/\-theses/\-KrischerThesis.ps.gz}}}, +} + +@inproceedings{Buhr03, + keywords = {exception handling, bound handler}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr and Roy Krischer}, + title = {Bound Exceptions in Object Programming}, + booktitle = {Proceedings of the ECOOP 2003 Workshop on Exception Handling in Object Oriented Systems: + Towards Emerging Application Areas and New Programming Paradigms}, + organization= {ECOOP}, + address = {Darmstadt, Germany}, + month = jul, + year = 2003, + pages = {20-26}, +} +% note = {http://www.cs.umn.edu/research/technical_reports.php/listing/technical_reports.php?page=report&report_id=03-028} + +@inproceedings{Buhr06b, + keywords = {exception handling, bound exceptions}, + author = {Peter A. Buhr and Roy Krischer}, + title = {Bound Exceptions in Object-Oriented Programming}, + editor = {C. Dony and J. L. Knudsen and A. Romanovsky and A. Tripathi}, + booktitle = {Advanced Topics in Exception Handling Techniques}, + publisher = {Springer-Verlag}, + series = {Lecture Notes in Computer Science}, + volume = 4119, + year = 2006, + pages = {1-21} +} + +% C + +@book{C, + keywords = {C}, + contributer = {pabuhr@plg}, + author = {Brian W. Kernighan and Dennis M. Ritchie}, + title = {The {C} Programming Language}, + publisher = {Prentice Hall}, + year = 1988, + edition = {second}, + series = {Prentice Hall Software Series}, + comment = { + based on draft-proposed ANSI C + } +} + +@book{C:old, + keywords = {C}, + contributer = {pabuhr@plg}, + author = {Brian W. Kernighan and Dennis M. Ritchie}, + title = {The {C} Programming Language}, + publisher = {Prentice Hall}, + year = 1978, + edition = {first}, +} + +@manual{ANSI89:C, + keywords = {ANSI C 89}, + contributer = {gjditchfield@plg}, + title = {American National Standard for Information Systems -- Programming Language -- {C}}, + organization= {American National Standards Institute}, + address = {1430 Broadway, New York, New York 10018}, + month = dec, + year = 1989, + note = {X3.159-1989} +} + +@manual{C11, + keywords = {ISO/IEC C 11}, + contributer = {pabuhr@plg}, + key = {C11}, + title = {American National Standard Information technology -- Programming Languages -- {C}}, + organization= {International Standard ISO/IEC 9899-2011[2012]}, + publisher = {International Standard Organization}, + address = {http://www.iso.org}, + year = 2012, +} + +@mastersthesis{Esteves04, + keywords = {Cforall, parametric polymorphism, overloading}, + contributer = {pabuhr@plg}, + author = {Rodolfo Gabriel Esteves}, + title = {C$\forall$, a Study in Evolutionary Design in Programming Languages}, + school = {School of Computer Science, University of Waterloo}, + year = 2004, + address = {Waterloo, Ontario, Canada, N2L 3G1}, + note = {\href{http://plg.uwaterloo.ca/theses/EstevesThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-EstevesThesis.pdf}}, +} + +@inproceedings{c++scheme, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Vincent F. Russo and Simon M. Kaplan}, + title = {A {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Interpreter for {S}cheme}, + booktitle = {Usenix {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Conference}, + year = 1988, + pages = {95-108}, + summary = { + The SIOD interpreter for a Scheme subset, written in C, has a + tagged union representing data objects, and read(), eval(), and + print() functions that are basically large switch statements that + switch based on the tag. The authors rewrote it to use a class + with virtual read(), eval(), and print() members, without changing + any algorithms. The result was more modular, more easily + extensible, more reliable, and slightly faster. + }, + comment = { + The evidence given is thin. + } +} + +@article{doskernel, + keywords = {light weight processes}, + contributer = {gjditchfield@plg}, + author = {Tom Green}, + title = {A {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Multitasking Kernel}, + journal = {Dr. Dobb's Journal of Software Tools}, + year = 1989, + month = feb, volume = 14, number = 2, pages = {45-51}, + comment = { + A light-weight multitasking kernel for MS-DOS. A task\_control + object holds task objects, which may block themselves on signal + objects. Task switching is normally preemptive, but tasks can turn + off preemption before calling non-reentrant routines. Source code + is given. + } +} + +@inproceedings{Doeppner87, + keywords = {concurrency}, + contributer = {pabuhr@plg}, + author = {Thomas W. Doeppner and Alan J. Gebele}, + title = {{C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} on a Parallel Machine}, + booktitle = {Proceedings and Additional Papers {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Workshop}, + organization= {USENIX Association}, + address = {Santa Fe, New Mexico, U.S.A}, + month = nov, + year = 1987, + pages = {94-107}, +} + +@book{Lippman91, + keywords = {C++}, + contributer = {pabuhr@plg}, + author = {Stanley B. Lippman}, + title = {{C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Primer}, + publisher = {Addison-Wesley}, + year = 1991, + edition = {second}, + note = {QA76.73.C15L57}, +} + +@book{c++:v1, + keywords = {C++}, + contributer = {gjditchfield@plg}, + author = {Bjarne Stroustrup}, + title = {The {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Programming Language}, + publisher = {Addison-Wesley}, + year = 1986, + edition = {first}, + series = {Addison-Wesley Series in Computer Science} +} + +@book{c++:v2, + keywords = {C++}, + contributer = {pabuhr@plg}, + author = {Bjarne Stroustrup}, + title = {The {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Programming Language}, + publisher = {Addison-Wesley}, + year = 1991, + edition = {second}, +} + +@book{c++:v3, + keywords = {C++}, + contributer = {pabuhr@plg}, + author = {Bjarne Stroustrup}, + title = {The {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Programming Language}, + publisher = {Addison-Wesley}, + year = 1997, + edition = {third}, +} + +@manual{Csharp, + keywords = {C#}, + contributer = {pabuhr@plg}, + title = {C\# Language Specification, Standard ECMA-334}, + organization= {ECMA International Standardizing Information and Communication Systems}, + month = jun, + year = 2006, + edition = {4th}, +} + +@article{Buhr85, + keywords = {goto, multi-exit loop}, + contributer = {pabuhr@plg}, + author = {P. A. Buhr}, + title = {A Case for Teaching Multi-exit Loops to Beginning Programmers}, + journal = sigplan, + volume = 20, + number = 11, + month = nov, + year = 1985, + pages = {14-22} +} + +@techreport{cforall-ug, + keywords = {cforall, user guide}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr and Glen Ditchfield and David Till and Charles R. Zarnke}, + title = {\mbox{\mdseries\sffamily C{$\mathbf{\forall}$}}\ Users Guide, Version 0.1}, + institution = {Department of Computer Science, University of Waterloo}, + address = {Waterloo, Ontario, Canada, N2L 3G1}, + month = oct, + year = 2001, + note = {\href{http://plg.uwaterloo.ca/~cforall/cfa.ps}{http://\-plg.uwaterloo.ca/\-\char`\~cforall/\-cfa.ps}}, +} + +@manual{cforall, + keywords = {polymorphism}, + contributer = {gjditchfield@plg}, + author = {Glen Ditchfield}, + title = {Cforall Reference Manual and Rationale}, + edition = {Revision 1.82}, + month = jan, + year = 1998, + note = {{\small\textsf{ftp://\-plg.uwaterloo.ca/\-pub/\-Cforall/\-refrat.ps.gz}}}, +} + +@book{Yourdon79, + keywords = {software engineering}, + contributer = {pabuhr@plg}, + editor = {Edward Nash Yourdon}, + title = {Classics in Software Engineering}, + publisher = {Yourdon Press}, + year = 1979, +} + +@inproceedings{Crnogorac98, + keywords = {inheritance anomaly}, + contributer = {pabuhr@plg}, + author = {Lobel Crnogorac and Anand S. Rao and Kotagiri Ramamohanarao}, + title = {Classifying Inheritance Mechanisms in Concurrent Object-Oriented Programming}, + editor = {Eric Jul}, + booktitle = {{ECOOP}~'98---Object-Oriented Programming}, + series = {Lecture Notes in Computer Science}, + publisher = {Springer}, + volume = 1445, + year = 1998, + pages = {571-601}, + ISBN = {3-540-64737-6}, + ISSN = {0302-9743}, + abstract = { + Inheritance is one of the key concepts in object-oriented rogramming. However, the + usefulness of inheritance in concurrent object-oriented programming is greatly + reduced by the problem of inheritance anomaly. Inheritance anomaly is manifested + by undesirable re-definitions of inherited code. The problem is aggravated by the + lack of a formal analysis, with a multitude of differing proposals and conflicting + opinions causing the current state of research, and further directions, to be + unclear. In this paper we present a formal analysis of inheritance anomaly in + concurrent object-oriented programming. Starting from a formal definition of the + problem we develop a taxonomy of the anomaly, and use it to classify the various + proposals. As a result, the major ideas, trends and limitations of the various + proposals are clearly exposed. Formal analysis of the anomaly and a thorough + exposition of its causes and implications are the pre-requisites for a successful + integration of inheritance and concurrency. + }, +} + +@book{CLU, + keywords = {CLU}, + contributer = {gjditchfield@plg}, + author = {Barbara Liskov and Russell Atkinson and Toby Bloom and Eliot + Moss and J. Craig Schaffert and Robert Scheifler and Alan Snyder}, + title = {CLU Reference Manual}, + publisher = {Springer-Verlag}, + year = 1981, + volume = 114, + series = {Lecture Notes in Computer Science} +} + +@manual{Cobol14, + keywords = {ISO/IEC Cobol 14}, + contributer = {pabuhr@plg}, + key = {Cobol14}, + title = {Programming Languages -- {Cobol}}, + edition = {second}, + organization= {International Standard ISO/IEC 1989:2014}, + publisher = {International Standard Organization}, + address = {http://www.iso.org}, + year = 2014, +} + +@article{coagulation, + keywords = {register allocation, instruction selection, jello}, + contributer = {gjditchfield@plg}, + author = {Michael Karr}, + title = {Code Generation by Coagulation}, + journal = sigplan, + year = 1984, + month = jun, volume = 19, number = 6, pages = {1-12}, + note = {Proceedings of the ACM SIGPLAN '84 Symposium on Compiler Construction}, + abstract = { + This paper describes a new approach to code-generation. The + central tenet is that there must be a more intimate coupling + between register allocation and instruction selection than exists + in present-day technology. This is achieved by generating code in + very small regions and gradually coalescing the part of the program + that is ``compiled''. + }, + comment = { + Imagine the program, including the subroutines, spread out over a + table, with the compiler dropping Jello on the parts as they are + compiled. At first little drops appear in seemingly random places. + These get bigger and combine with other drops to form growing + globs. When two globs meet, ripples will go out through each as + they adjust to each other's presence, although the parts of the + globs that formed first are less affected by the ripples. When + compilation is complete, there is one congealed mass. + } +} + +@article{Soloway83, + keywords = {goto, structure programming}, + contributer = {pabuhr@plg}, + author = {E. Soloway and J. Bonar and K. Ehrlich}, + title = {Cognitive Strategies and Looping Constructs: An Empirical Study}, + journal = cacm, + month = nov, + year = 1983, + volume = 26, + number = 11, + pages = {853-860}, +} + +@book{sml:commentary, + author = {Robin Milner and Mads Tofte}, + title = {Commentary on Standard {ML}}, + publisher = {MIT Press}, + address = {Cambridge, Massachusetts, U.S.A.}, + year = 1991 +} + +@article{Hyman66, + keywords = {mutual exclusion, software solution, incorrect}, + contributer = {pabuhr@plg}, + author = {Harris Hyman}, + title = {Comments on a Problem in Concurrent Programming Control}, + journal = cacm, + month = jan, + year = 1966, + volume = 9, + number = 1, + pages = {45}, + note = {Letter to the Editor} +} + +@inproceedings{clos, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Linda G. DeMichiel and Richard P. Gabriel}, + title = {The Common Lisp Object System: An Overview}, + booktitle = {ECOOP '87. European Conference on Object-Oriented Programming}, + year = 1987, + pages = {151-170}, + publisher = {Springer-Verlag} +} + +@book{CommonLisp, + keywords = {common lisp}, + contributer = {pabuhr@plg}, + author = {G. Steele}, + title = {COMMON LISP: The Language}, + publisher = {Digital Press}, + year = 1984 +} + +@article{CommonLoops, + author = {D. Bobrow and K. Kahn and G. Kiczales and L. Masinter and M. Stefik and F. Zdybel}, + title = {CommonLoops: Merging Common Lisp and Object-Oriented Programming}, + address = {Portland, Oregon, U.S.A.}, + journal = {Proc. ACM Conf. on Object-Oriented Systems, Languages and Applications}, + year = 1986, + month = sep, + pages = {17-29}, +} + +@article{co-overview, + keywords = {CommonObjects, implementation, encapsulation}, + contributer = {gjditchfield@plg}, + author = {Alan Snyder}, + title = {CommonObjects: An Overview}, + journal = sigplan, + year = 1986, + month = oct, volume = 21, number = 10, pages = {19-28}, + note = {Object Oriented Programming Workshop} +} + +@article{CSP, + keywords = {CSP, concurrency}, + contributer = {pabuhr@plg}, + author = {C. A. R. Hoare}, + title = {Communicating Sequential Processes}, + journal = cacm, + month = aug, + year = 1978, + volume = 21, + number = 8, + pages = {666-677} +} + +@book{Hoare85, + author = {C. A. R. Hoare}, + title = {Communicating Sequential Processes}, + year = 1985, + isbn = {0-13-153271-5}, + publisher = {Prentice-Hall, Inc.}, + address = {Upper Saddle River, NJ, USA}, + note = {\href{http://www.usingcsp.com/cspbook.pdf}{http://\-www.usingcsp.com/\-cspbook.pdf}}, +} + +@article{Hansen72a, + keywords = {monitors, automatic signal}, + contributer = {pabuhr@plg}, + author = {Per {Brinch Hansen}}, + title = {A Comparison of Two Synchronizing Concepts}, + journal = acta, + volume = 1, + year = 1972, + pages = {190-199}, +} + +@book{Aho06, + author = {Alfred V. Aho and Monica S. Lam and Ravi Sethi and Jeffrey D. Ullman}, + title = {Compilers: Principles, Techniques, and Tools}, + edition = {second}, + year = {2006}, + publisher = {Addison-Wesley Longman Publishing Co., Inc.}, + address = {Boston, MA, USA}, +} + +@article{Bacon94, + keywords = {parallelizing compiler}, + contributer = {pabuhr@plg}, + author = {David F. Bacon and Susan L. Graham and Oliver J. Sharp}, + title = {Compiler Transformations for High-Performance Computing}, + journal = acmcs, + volume = 26, + number = 4, + month = dec, + year = 1994, + pages = {345-420}, +} + +@inproceedings{Berger01, + author = {Emery D. Berger and Benjamin G. Zorn and Kathryn S. McKinley}, + title = {Composing High-Performance Memory Allocators}, + booktitle = {{SIGPLAN} Conference on Programming Language Design and Implementation}, + pages = {114-124}, + year = 2001, + url = {http://citeseer.ist.psu.edu/berger01composing.html} +} + +@article{Andrews83, + keywords = {general concurrency}, + contributer = {pabuhr@plg}, + author = {Gregory R. Andrews and Fred B. Schneider}, + title = {Concepts and Notations for Concurrent Programming}, + journal = acmcs, + volume = 15, + number = 1, + month = mar, + year = 1983, + pages = {3-43}, +} + +@mastersthesis{Mok97, + author = {Wing Yeung Russell Mok}, + title = {Concurrent Abnormal Event Handling Mechanisms}, + school = {University of Waterloo}, + year = 1997, + month = sep, + address = {Waterloo, Ontario, Canada, N2L 3G1}, + note = {{\small\textsf{ftp://\-plg.uwaterloo.ca/\-pub/\-theses/\-MokThesis.ps.gz}}}, +} + +@article{Gehani86, + keywords = {Concurrent programming, C, Distributed systems, rendezvous}, + contributer = {dgharriss@plg}, + author = {N. H. Gehani and W. D. Roome}, + title = {{Concurrent C}}, + journal = spe, + volume = 16, + number = 9, + month = sep, + year = 1986, + pages = {821-844}, + abstract = { + Our objective is to enhance C so that it can be used to write + concurrent programs that can run efficiently on both single computers + and multicomputers. Our concurrent programming extensions to C are + based on the {\it rendezvous\/} concept. These extensions include + mechanisms for the declaration and creation of processes, for process + synchronization and interaction, for process termination and abortion. + We give a rationale for our decisions and compare Concurrent C + extensions with the concurrent programming facilities in Ada. + Concurrent C has been implemented on the UNIX system running on a + single processor. A distributed version of Concurrent C is being + implemented. + }, + comment = { + Select with guarded and screened accepts. Typed processes. + Process-valued expressions and process variables. Processes have + execution priority: Create {\em process-type-name}(args) [with + priority(p)], + and the priority can be changed on the fly. Complicated guard/ + screen structure on accept: accept {\em transaction}(param names) + [suchthat (exp)] [by (exp)] [compoundstatement]. Accepts cannot + appear in functions! Can specify timeouts on transaction calls. + Code examples: buffer process, dining philosophers, lock manager. + Section on diffs between Concurrent C and Ada. + } +} + +@article{ConcurrentC++, + keywords = {concurrency, C++}, + contributer = {pabuhr@plg}, + author = {N. H. Gehani and W. D. Roome}, + title = {Concurrent {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}: Concurrent Programming with Class(es)}, + journal = spe, + month = dec, + year = 1988, + volume = 18, + number = 12, + pages = {1157-1177} +} + +@article{Courtois71, + keywords = {reader and writer, p and v}, + contributer = {pabuhr@plg}, + author = {P. J. Courtois and F. Heymans and D. L. Parnas}, + title = {Concurrent Control with Readers and Writers}, + journal = cacm, + volume = 14, + number = 10, + month = oct, + year = 1971, + pages = {667-668}, + annote = { + Many errors in the two solutions. + } +} + +@incollection{Reppy93, + keywords = {ML, concurrency, continuation passing}, + contributer = {pabuhr@plg}, + author = {John H. Reppy}, + title = {Concurrent {ML}: Design, Application and Semantics}, + booktitle = {Functional Programming, Concurrency, Simulation and Automated Reasoning}, + editor = {P. E. Lauer}, + pages = {165-198}, + publisher = {Springer-Verlag}, + address = {Berlin, DE}, + year = 1993, + ISBN = {3-540-56883-2}, + abstract = { + Concurrent ML (CML) is a high-level language for concurrent + programming. It is an extension of Standard ML (SML) and is implemented + on top of Standard ML of New Jersey (SML/NJ). CML is a practical + language and is being used to build real systems. It demonstrates that + one need not sacrifice high-level notation in order to have good + performance. CML is also a well-defined language. In the tradition of + SML, it has a formal semantics and its type-soundness has been + proven.}, + note = { + Proceedings of International Lecture Series 1991-92, McMaster + UniversityLecture Notes in Computer Science 693.}, +} + +@article{BLASE-2, + keywords = {concurrency, BLASE-2}, + contributer = {pabuhr@plg}, + author = {Piyush Mehrotra and John Van Rosendale}, + title = {Concurrent Object Access in BLASE~2}, + journal = sigplan, + volume = 24, + number = 4, + month = apr, + year = 1989, + pages = {40-42}, + note = {Proceedings of the ACM SIGPLAN Workshop on Object-Based Concurrent Programming, + Sept. 26--27, 1988, San Diego, California, U.S.A}, +} + +@techreport{Kafura88, + keywords = {objects, concurrency}, + contributer = {pabuhr@plg}, + author = {Dennis Kafura}, + title = {Concurrent Object-Oriented Real-Time Systems Research}, + institution = {Department of Computer Science, Virginia Polytechnic}, + number = {TR 88-47}, + year = 1988 +} + +@article{Buhr92a, + keywords = {C++, concurrency, light-weight process, shared memory}, + contributer = {pabuhr@plg}, + author = {P. A. Buhr and Glen Ditchfield and R. A. Stroobosscher and B. M. Younger and C. R. Zarnke}, + title = {$\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}: Concurrency in the Object-Oriented Language {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + journal = spe, + volume = 22, + number = 2, + month = feb, + year = 1992, + pages = {137-172}, +} + +@techreport{uC++, + keywords = {C++, concurrency, light-weight process, shared memory}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr}, + title = {$\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Annotated Reference Manual, Version 6.1.0}, + institution = {School of Computer Science, University of Waterloo}, + address = {Waterloo, Ontario, Canada, N2L 3G1}, + month = jul, + year = 2015, + note = {\href{http://plg.uwaterloo.ca/~usystem/pub/uSystem/u++-6.1.0.sh}{\textsf{http://plg.uwaterloo.ca/\-$\sim$usystem/\-pub/\-uSystem/\-u++-6.1.0.sh}}}, +} + +@book{Burns93, + keywords = {concurrency, Pascal}, + contributer = {pabuhr@plg}, + author = {Alan Burns and Geoff Davies}, + title = {Concurrent Programming}, + publisher = {Addison-Wesley}, + year = 1993, +} + +@article{Hansen73a, + keywords = {monitors}, + contributer = {pabuhr@plg}, + author = {Per {Brinch Hansen}}, + title = {Concurrent Programming Concepts}, + journal = spe, + month = dec, + year = 1973, + volume = 5, + number = 4, + pages = {223-245}, +} + +@book{Lea97, + keywords = {concurrency, Java}, + contributer = {pabuhr@plg}, + author = {Doug Lea}, + title = {Concurrent Programming in {J}ava: Design Principles and Patterns}, + publisher = {Addison-Wesley}, + year = 1997, + edition = {first}, +} + +@book{Hartley98, + keywords = {concurrency, Java}, + contributer = {pabuhr@plg}, + author = {Stephen J. Hartley}, + title = {Concurrent Programming: The {J}ava Programming Language}, + publisher = {Oxford University Press}, + year = 1998, + edition = {first}, +} + +@book{Lea00, + keywords = {concurrency, Java}, + contributer = {pabuhr@plg}, + author = {Doug Lea}, + title = {Concurrent Programming in {J}ava: Design Principles and Patterns}, + publisher = {Addison-Wesley}, + year = 2000, + edition = {second}, +} + +@book{ConcurrentC, + keywords = {concurrency, C}, + contributer = {pabuhr@plg}, + author = {N. H. Gehani and W. D. Roome}, + title = {The {Concurrent C} Programming Language}, + publisher = {Silicon Press, NJ}, + year = 1989, +} + +@book{Andrews91:book, + keywords = {concurrency}, + contributer = {pabuhr@plg}, + author = {Gregory R. Andrews}, + title = {Concurrent Programming: Principles and Practice}, + publisher = {Benjamin/Cummings Publishing Company, Inc., Redwood City, California}, + year = 1991, +} + +@article{Buhr05a, + keywords = {concurrency, myths}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr and Ashif S. Harji}, + title = {Concurrent Urban Legends}, + journal = {Concurrency and Computation: Practice and Experience}, + month = aug, + year = 2005, + volume = 17, + number = 9, + pages = {1133-1172}, +} + +@techreport{Buhr90, + keywords = {objects, concurrency}, + contributer = {gjditchfield@plg}, + author = {P. A. Buhr and G. J. Ditchfield and B. M. Younger and C. R. Zarnke}, + title = {Concurrency in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + institution = {Department of Computer Science, University of Waterloo}, + address = {Waterloo, Ontario, Canada, N2L 3G1}, + number = {CS-90-18}, + month = may, + year = 1990 +} + +@book{Burns98, + keywords = {concurrency, Ada}, + author = {Alan Burns and Andy Wellings}, + title = {Concurrency in {Ada}}, + publisher = {Cambridge University Press}, + year = 1998, + edition = {second}, +} + +@book{Bernstein93, + keywords = {concurrency}, + author = {Arthur J. Bernstein and Philip M. Lewis}, + title = {Concurrency in Programming and Database Systems}, + publisher = {Jones and Bartlett}, + year = 1993, +} + +@inproceedings{Pitman01, + keywords = {LISP, exception handling}, + contributer = {pabuhr@plg}, + author = {Kent M. Pitman}, + title = {Condition Handling in the Lisp Language Family}, + booktitle = {Exception Handling}, + publisher = {Springer-Verlag}, + volume = 2022, + series = {LNCS}, + year = 2001, + pages = {39-59} +} + +@inbook{enhancement, + keywords = {bounded polymorphism, Comandos}, + contributer = {gjditchfield@plg}, + author = {Chris Horn}, + title = {Conformace, Genericity, Inheritance and Enhancement}, + pages = {223-233}, + publisher = {Springer-Verlag}, + year = 1987, + volume = 276, + series = "Lecture Notes in Computer Science", + note = "ECOOP '87 European Conference on Object-Oriented Programming", + summary = { + Considers effect of conformance on Meyer's conclusions in + \cite{polymorphism}. + + Implementing a swap function as a member of a type {\cd Swappable} + with {\cd in out Top} parameters doesn't work, because conformance + requires arguments to be of type {\cd Top}. + + An enhancive type has a type parameter, bounded by some type, and + defines members. Types conforming to the bound can be passed as + arguments to create types with the extra members. The signature of + the enhanced type is based on the signature of the argument, not the + bound, as if enhancive types were macros. Hence enhanced types do not + necessarily conform to each other. Types conforming to the bound + conform to enhanced types, which allows new functions to be applied + to old types. + + Enhancive types are not generic types. If the argument is omitted, + the bound is used as a default. Assignment of enhanced types to + default-enhanced types is allowed (enhanced types conform to the + default-enhanced type). This is (probably) statically type-safe, + because arguments must conform to the bound, and the new members + only use operations defined for the bound. + + With facilities for member renaming and deletion, enhancive types + provide the equivalent of constrained generic types. + } +} + +@phdthesis{Ditchfield92, + keywords = {C, parametric polymorphism, overloading}, + contributer = {pabuhr@plg}, + author = {Glen Jeffrey Ditchfield}, + title = {Contextual Polymorphism}, + school = {Department of Computer Science, University of Waterloo}, + year = 1992, + address = {Waterloo, Ontario, Canada, N2L 3G1}, + note = {\href{http://plg.uwaterloo.ca/theses/DitchfieldThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-DitchfieldThesis.pdf}} +} + +@inproceedings{frameworks:HHG90, + keywords = {formal}, + contributer = {pabuhr@plg}, + author = {Richard Helm and Ian M. Holland and Dipayan Gangopadhyay}, + title = {Contracts: Specifying Behavioural Compositions in Cbject-Oriented Systems}, + booktitle = {Proceedings of ACM Symposium on Object-Oriented Programming: Systems, Languages and Applications}, + year = 1990, + pages = {169-180}, +} + +@article{Wand80, + keywords = {concurrency, continuation}, + contributer = {pabuhr@plg}, + author = {Mitchell Wand}, + title = {Continuation-Based Multiprocessing}, + publisher = {The Lisp Conference}, + journal = {Conference Record of the 1980 Lisp Conference}, + pages = {19-28}, + year = 1980, +} + +@article{Hieb90, + keywords = {continuations, concurrency}, + contributer = {pabuhr@plg}, + author = {Robert Hieb and R. Kent Dybvig}, + title = {Continuations and Concurrency}, + journal = sigplan, + volume = 25, + number = 3, + month = mar, + year = 1990, + pages = {128-136}, + note = {Proceedings of the Second ACM SIGPLAN Symposium on Principles \& Practise of Parallel Programming, + March. 14--16, 1990, Seattle, Washington, U.S.A}, +} + +@inproceedings{Haynes84, + keywords = {continuations, coroutines, Scheme}, + contributer = {pabuhr@plg}, + author = {Christopher T. Haynes and Daniel P. Friedman and Mitchell Wand}, + title = {Continuations and Coroutines}, + booktitle = {Conference Record of the 1984 {ACM} Symposium on Lisp and Functional Programming}, + organization= {Association for Computing Machinery}, + month = aug, + year = 1984, + pages = {293-298}, + abstract = { + The power of first class continuations is demonstrated by implementing + a variety of coroutine mechanisms using only continuations and + functional abstraction. The importance of general abstraction + mechanisms such as continuations is discussed.}, +} + +@inproceedings{Zahn74, + keywords = {goto, structured programming}, + contributer = {pabuhr@plg}, + author = {C. T. Zahn}, + title = {Control Statement for Natural Top-down Structured Programming}, + booktitle = {Symposium on Programming Languages}, + address = {Paris, France}, + year = 1974, +} + +@techreport{Dijkstra65, + keywords = {concurrency, Dekker's algorithm, semaphores}, + contributer = {pabuhr@plg}, + author = {Edsger W. Dijkstra}, + title = {Cooperating Sequential Processes}, + institution = {Technological University}, + address = {Eindhoven, Netherlands}, + year = 1965, + note = {Reprinted in \cite{Genuys68} pp. 43--112.} +} + +@book{Marlin80, + keywords = {coroutines}, + contributer = {pabuhr@plg}, + author = {Christopher D. Marlin}, + title = {Coroutines: A Programming Methodology, a Language Design and an Implementation}, + publisher = {Springer-Verlag}, + year = 1980, + volume = 95, + series = {Lecture Notes in Computer Science, Ed. by G. Goos and J. Hartmanis} +} + +@article{Wang71, + keywords = {coroutines}, + contributer = {pabuhr@plg}, + author = {Arne Wang and Ole-Johan Dahl}, + title = {Coroutine Sequencing in a Block Structured Environment}, + journal = "BIT", + volume = 11, + month = nov, + year = 1971, + pages = {425-449}, +} + +@article{Castagna95, + keywords = {type-systems, covariance, contravariance}, + contributer = {pabuhr@plg}, + author = {Giuseppe Castagna}, + title = {Covariance and Contravariance : Conflict without a Cause}, + journal = toplas, + volume = 17, + number = 3, + month = may, + year = 1995, + pages = {341-447}, +} + +@book{Fischer88, + keywords = {compiler construction}, + author = {Charles N. Fischer and Richard J. {LeBlanc, Jr.}}, + title = {Crafting a Compiler}, + publisher = {Benjamin Cummings}, + year = 1991, +} + +@inproceedings{Jim02, + keywords = {C dialect, parametric polymorphic, safe memory allocation}, + contributer = {pabuhr@plg}, + author = {Trevor Jim and Greg Morrisett and Dan Grossman and Michael Hicks and James Cheney and and Yanling Wang}, + title = {{C}yclone: A Safe Dialect of {C}}, + booktitle = {USENIX Annual Technical Conference}, + organization= {USENIX Association}, + address = {Monterey, California, U.S.A.}, + month = jun, + year = 2002, + pages = {275-288}, +} + +% D + +@manual{D, + keywords = {D programming language}, + contributer = {pabuhr@plg}, + title = {{D} Programming Language}, + author = {Walter Bright and Andrei Alexandrescu}, + organization= {Digital Mars}, + year = 2016, + note = {\href{http://dlang.org/spec/spec.html}{http://\-dlang.org/\-spec/\-spec.html}}, +} + +@techreport{Cui90, + keywords = {exception handling}, + contributer = {pabuhr@plg}, + author = {Qian Cui}, + title = {Data-Oriented Exception Handling}, + institution = {Department of Computer Science, University of Maryland}, + address = {College Park, Maryland, U.S.A., 20742}, + number = {CS-TR-2384}, + month = jan, + year = 1990, +} + +@article{Cui92, + contributer = {rkrische@plg}, + author = {Qian Cui and John Gannon}, + title = {Data-oriented Exception Handling}, + journal = {IEEE Transactions on Software Engineering}, + month = may, + year = 1992, + volume = 18, + number = 5, + pages = {393-401}, +} + +@manual{SIMULA87, + keywords = {Simula standard}, + contributer = {gjditchfield@plg}, + title = {Databehandling -- Programspr{\aa}k -- {SIMULA}}, + organization= {Standardiseringskommissionen i Sverige}, + note = {Svensk Standard SS 63 61 14}, + year = 1987, + abstract = { + Standard for the programming language SIMULA. Written in English. + } +} + +@article{Liskov75, + keywords = {abstract data types, encapsulation, verification}, + contributer = {gjditchfield@plg}, + author = {Barbara H. Liskov}, + title = {Data Types and Program Correctness}, + journal = sigplan, + year = 1975, + month = jul, + volume = 10, + number = 7, + pages = {16-17}, + summary = { + Type definitions should contain the implementation of the type and + its operations. The grouping makes programs simpler and more + understandable. Encapsulating the definition aids verification and + forces a precise specification of the interface. + } +} + +@article{dtav, + keywords = {Russell, types}, + contributer = {gjditchfield@plg}, + author = {James Donahue and Alan Demers}, + title = {Data Types are Values}, + journal = toplas, + month = jul, + year = 1985, + volume = 7, + number = 3, + pages = {426-445}, + comment = { + Data types are sets of operations providing interpretations of + values from a meaningless, typeless universal value space. Types + and operations are also contained in this value space. + + Functions returning types replace generic types. + + Polymorphic functions have type parameters. Evaluation is not + macro expansion: + \begin{verbatim} + R == func [n:val integer; T:type[]] val integer + {if n > 0 => r[n-1, Array[1,10,T]] # n <= 0 => 17 fi} + \end{verbatim} + } +} + +@article{Holt72, + keywords = {concurrency, deadlock}, + contributer = {pabuhr@plg}, + author = {Richard C. Holt}, + title = {Some Deadlock Properties of Computer Systems}, + journal = acmcs, + volume = 4, + number = 3, + month = sep, + year = 1972, + pages = {179-196}, +} + +@misc{debug-malloc, + keywords = {memory allocation debugger}, + contributer = {gjditchfield@plg}, + author = {Conor P. Cahill}, + title = {debug\_malloc}, + howpublished= {comp.sources.unix, volume 22, issue 112}, + abstract = { + This package is a collection of routines which are a drop-in + replacement for the malloc(3), memory(3), string(3), and bstring(3) + library functions. + } +} + +@book{sml, + keywords = {}, + contributer = {pabuhr@plg}, + author = {Robin Milner and Mads Tofte and Robert Harper}, + title = {The Definition of Standard {ML}}, + publisher = {MIT Press}, + address = {Cambridge, Massachusetts, U.S.A.}, + year = 1990 +} + +@techreport{sml:old, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Robert Harper and Robin Milner and Mads Tofte}, + title = {The Definition of Standard {ML}, Version 2}, + institution = {Department of Computer Science, University of Edinburgh}, + year = 1988, + address = {The King's Buildings, Edinburgh EH9 3JZ}, + type = {LFCS Report Series}, month = aug, number = {ECS-LFCS-88-62} +} + +@inproceedings{Reynolds72, + keywords = {continuation}, + contributer = {pabuhr@plg}, + author = {John Reynolds}, + title = {Definitional Interpreters for Higher Order Programming Languages}, + booktitle = {ACM Conference Proceedings}, + organization= {ACM}, + year = 1972, + pages = {717-740} +} + +@article{Buhr16, + keywords = {Dekker's algorithm, software solution, mutual exclusion, performance experiment}, + author = {Peter A. Buhr and David Dice and Wim H. Hesselink}, + title = {Dekker's Mutual Exclusion Algorithm Made RW-Safe}, + journal = {Concurrency and Computation: Practice and Experience}, + volume = 28, + number = 1, + pages = {144-165}, + month = jan, + year = 2016, +} + +@misc{steelman, + keywords = {Ada}, + contributer = {gjditchfied@plg}, + author = {High Order Language Working Group}, + title = {Department of Defense Requirements for High Order Computer Programming Languages}, + month = jun, year = 1978, + note = {Reprinted in \cite{pldesign}.} +} + +@incollection{Tsay98, + keywords = {local spins, mutual exclusion, read/write atomicity, refinement, scalability}, + author = {Yih-Kuen Tsay}, + title = {Deriving a scalable algorithm for mutual exclusion}, + booktitle = {Distributed Computing}, + editor = {Shay Kutten}, + volume = {1499}, + series = {LNCS}, + publisher = {Springer}, + address = {Berlin Heidelberg}, + year = {1998}, + pages = {393-407}, +} + +@article{Conway63, + keywords = {coroutine, original}, + contributer = {pabuhr@plg}, + author = {Melvin E. Conway}, + title = {Design of a Separable Transition-Diagram Compiler}, + journal = cacm, + month = jul, + year = 1963, + volume = 6, + number = 7, + pages = {396-408}, +} + +@book{Stroustrup94, + keywords = {C++}, + contributor = {wyrmok@plg}, + author = {Bjarne Stroustrup}, + title = {The Design and Evolution of {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + publisher = {Addison-Wesley}, + year = 1994 +} + +@inproceedings{st:concurrent, + keywords = {concurrency, Smalltalk, futures}, + contributer = {gjditchfield@plg}, + author = {Yasuhiko Yokote and Mario Tokoro}, + title = {The Design and Implementation of {ConcurrentSmalltalk}}, + crossref = "OOPSLA86", + pages = {331-340}, + comment = { + Objects are ordinary Smalltalk objects or ``atomic'' objects, which + process messages one at a time in FIFO order. Asynchronous method + calls are made by appending ``\&'' at the call site. The sender does + not wait for a reply. If the method returns a value, it + (immediately?) returns a CBox object, which is like a future. The + sender can send the ``receive'' message to the CBox, which blocks + until the CBox contains a value. + + A method can execute the ``\verb|^|'' statement to return an object + and terminate, or it can execute ``\verb|^^|'' to return an object + and continue execution. If ``\verb|^^foo|'' is executed after + ``\verb|^^bar|'', foo is discarded, since bar has already been + returned. + + The article does not say whether asynchronous messages can be sent + to ordinary objects, or whether ordinary messages can be sent to + atomic objects. + } +} + +@inproceedings{Ichbiah83, + keywords = {Ada, packages, generics}, + contributer = {gjditchfield@plg}, + author = {Jean D. Ichbiah}, + title = {On the Design of {Ada}}, + booktitle = {Information Processing 83}, + year = 1983, + month = sep, pages = {1-10}, + editor = {R. E. A. Mason}, + organization= {IFIP}, + publisher = {North-Holland}, + summary = { + Packages group related declarations or subprograms, and encapsulate + data types. Separate interfaces and bodies promotes information + hiding by removing the need to scan the body, allows the body to be + confidential, and provides a better specification of the contract + between client and implementor. Generics are an efficient way to + factor out parts of similar definitions. + } +} + +@book{Motet96, + keywords = {Ada, exception handling}, + contributer = {wyrmok@plg}, + author = {G. Motet and A. Mapinard and J. C. Geoffroy}, + title = {Design of Dependable {A}da Software}, + publisher = {Prentice Hall}, + year = 1996, +} + +@article{Richardson93, + keywords = {C++, persistence, database}, + contributer = {pabuhr@plg}, + author = {Joel E. Richardson and Michael J. Carey and Daniel T. Schuh}, + title = {The Design of the {E} Programming Language}, + journal = toplas, + month = jul, + year = 1993, + volume = 15, + number = 3, + pages = {494-534}, +} + +@article{Hansen81b, + keywords = {concurrency, monitor, critical region}, + contributer = {pabuhr@plg}, + author = {Per {Brinch Hansen}}, + title = {The Design of {E}dison}, + journal = spe, + volume = 11, + number = 4, + month = apr, + year = 1981, + pages = {363-396}, +} + +@book{Gamma95, + keywords = {design patterns}, + author = {Erich Gamma and Richard Helm and Ralph Johnson and John Vlissides}, + title = {Design Patterns: Elements of Reusable Object-Oriented Software}, + publisher = {Addison-Wesley}, + year = 1995, + series = {Professional Computing Series}, +} + +@inproceedings{Wirth74, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Niklaus Wirth}, + title = {On the Design of Programming Languages}, + booktitle = {Information Processing 74}, + year = 1974, + pages = {386-393}, + publisher = {North Holland Publishing Company}, + note = {Reprinted in \cite{pldesign}.} +} + +@techreport{forceone, + keywords = {Parametric polymorphism, ForceOne}, + contributer = {gjditchfield@plg}, + author = {Andrew K. Wright}, + title = {Design of the Programming Language {ForceOne}}, + institution = {University of Waterloo}, + month = feb, year = 1987, + number = {CS-87-10} +} + +@techreport{x-2, + keywords = {object based}, + contributer = {gjditchfield@plg}, + author = {David W. Sandberg}, + title = {The Design of the Programming Language {X-2}}, + institution = {Oregon State University}, + year = 1985, + address = {Department of Computer Science, Corvallis, Oregon, 97331}, + number = {85-60-1} +} + +@article{design, + keywords = {Smalltalk, designing classes}, + contributer = {gjditchfield@plg}, + author = {Ralph E. Johnson and Brian Foote}, + title = {Designing Reusable Classes}, + journal = {Journal of Object-Oriented Programming}, + year = 1988, + volume = 1, number = 2, pages = {22-35}, + comment = { + Abstract classes represent standard protocols. ``It is better to + inherit from an abstract class than from a concrete class''. + Frameworks are collections of related abstract classes. Successful + abstractions are discovered, not designed. + + Protocols: ``If an operation X is implemented by performing a + similar operation on the components of the receiver, then that + operation should also be named X''. Eliminate case analysis by + creating classes with the same operations. Create classes to + represent bundles of parameters. Shrink methods larger than 30 + lines. + + Hierarchies should be deep and narrow. Subclasses should be + specializations. + + Frameworks: split large classes. Factor implementation differences + into subcomponents. Separate methods that do not share instance + variables into components that reflect the different views of the + object. Send messages to components, not self. Reduce implicit + parameter passing through instance variables. + } +} + +@article{dim:c++, + keywords = {Dimensional Analysis, C++}, + contributer = {gjditchfield@plg}, + author = {Robert F. Cmelic and Narain Gehani}, + title = {Dimensional Analysis with {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + journal = {IEEE Software}, + month = may, year = 1988, + volume = 5, number = 3, pages = {21-29} +} + +@article{Wegner87, + contributer = {pabuhr@plg}, + author = {Peter Wegner}, + title = {Dimensions of Object--Based Language Design}, + journal = sigplan, + volume = 22, + number = 12, + month = dec, + year = 1987, + pages = {168-182}, + note = {Proceedings of the OOPSLA'87 Conference, Oct. 4--8, 1987, Orlando, Florida}, +} + +@book{Dijkstra76, + keywords = {concurrent assignment}, + author = {E. W. Dijkstra}, + title = {A Discipline of Programming}, + publisher = {Prentice-Hall}, + year = 1976, +} + +@book{Lynch96, + keywords = {distributed algorithms}, + author = {Nancy A. Lynch}, + title = {Distributed Algorithms}, + publisher = {Morgan Kaufmann}, + year = 1996, +} + +@book{Tanenbaum02, + keywords = {distributed programming}, + author = {Andrew S. Tanenbaum and Maarten van Steen}, + title = {Distributed Systems: Principles and Paradigms}, + publisher = {Prentice-Hall}, + year = 2002, +} + +@inproceedings{Cargill90, + keywords = {concurrency}, + contributer = {pabuhr@plg}, + author = {Tom A. Cargill}, + title = {Does {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Really Need Multiple Inheritance?}, + booktitle = {USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Conference Proceedings}, + organization= {USENIX Association}, + address = {San Francisco, California, U.S.A.}, + month = apr, + year = 1990, + pages = {315-323} +} + +@unpublished{Duff83, + keywords = {C, switch statement, control flow}, + contributer = {pabuhr@plg}, + author = {Tom Duff}, + title = {Duff's Device}, + month = nov, + year = 1983, + note = {\href{http://www.lysator.liu.se/c/duffs-device.html}{http://\-www.lysator.liu.se/\-c/\-duffs-device.html}} +} + +@manual{dwarf2, + keywords = {Debugging DWARF2 specification}, + contributer = {rkrische@plg}, + title = {DWARF Debugging Information Format}, + organization= {Unix International Programming Languages SIG}, + publisher = {Unix International}, + address = {Waterview Corporate Center, 20 Waterview Boulevard, Parsippany, NJ 07054}, + year = {1993} +} + +@article{classicada, + keywords = {Classic Ada}, + contributer = {gjditchfield@plg}, + author = {Cameron M. Donaldson}, + title = {Dynamic Binding and Inheritance in an Object-Oriented {Ada} Design}, + journal = {Journal of Pascal, {Ada} \& Modula-2}, + year = 1990, + month = {jul/aug}, volume = 9, number = 4, pages = {12-19}, + comment = { + Classes are like packages: they can contain subprograms, types, + variables, generic instantiations, and exceptions. They can also + contain class methods, instance methods, and instance variables, + and define creation and initialization subprograms or methods for + instances. Single inheritance provides inheritance of + implementations. Dynamic binding is done with a {\em send} + statement that invokes a class or instance method. A preprocessor + converts Classic Ada to normal Ada. + } +} + +@article{Costanza03, + keywords = {dynamic call}, + contributer = {pabuhr@plg}, + author = {Pascal Costanza}, + title = {Dynamic Scoped Functions as the Essence of {AOP}}, + journal = sigplan, + volume = 38, + number = 8, + month = aug, + year = 2003, + pages = {29-35}, +} + +% E + +@inproceedings{Wegbreit71, + keywords = {polymorphism}, + contributer = {pabuhr@plg}, + author = {B. Wegbreit}, + title = {The ECL Programming System}, + booktitle = {Proceedings of AFIPS 1971 FJCC}, + publisher = {AFIPS Press, vol. 39}, + address = {Montvale, New Jersey, U.S.A}, + year = 1971, + pages = {253-262}, +} + +@manual{JavaScript, + keywords = {JavaScript}, + contributer = {pabuhr}, + title = {ECMAScript 2015 Language Specification {JavaScript}}, + organization= {ECAM International}, + address = {Rue du Rhone 114, CH-1204 Geneva, Switzerland}, + month = jun, + year = 2015, + note = {6th Edition} +} + +@inproceedings{Peterson77, + keywords = {N-thread software-solution mutual exclusion}, + contributer = {pabuhr@plg}, + author = {Gary L. Peterson and Michael J. Fischer}, + title = {Economical Solutions for the Critical Section Problem in a Distributed System (Extended Abstract)}, + booktitle = {Proceedings of the Ninth Annual ACM Symposium on Theory of Computing}, + series = {STOC '77}, + year = 1977, + location = {Boulder, Colorado, USA}, + pages = {91--97}, + numpages = {7}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@article{Hansen81a, + keywords = {concurrency, monitor, critical region}, + contributer = {pabuhr@plg}, + author = {Per {Brinch Hansen}}, + title = {{E}dison---a Multiprocessor Language}, + journal = spe, + volume = 11, + number = 4, + month = apr, + year = {1981}, + pages = {325-361}, +} + +@book{Eiffel, + keywords = {Eiffel}, + contributer = {pabuhr@plg}, + author = {Bertrand Meyer}, + title = {Eiffel: The Language}, + publisher = {Prentice-Hall}, + year = 1992, + series = {Prentice Hall Object-Oriented Series}, +} + +@article{WS:overload, + keywords = {compilation}, + contributer = {gjditchfield@plg}, + author = {Peter J. L. Wallis and Bernhard W. Silverman}, + title = {Efficient Implementation of the {Ada} Overloading Rules}, + journal = ipl, + year = 1980, + month = apr, volume = 10, number = 3, pages = {120-123}, + comment = { + The ``two-pass'' algorithm. An upward pass over a parse tree + calculates the set of possible result types of operators. The + root must have exactly one type, produced in one way. A + downward pass selects the version of the operator that produces the + desired result type, thus setting the result types of subtrees. + See \cite{D:overload}. + } +} + +@techreport{Habermann80, + keywords = {Ada, threads}, + contributer = {pabuhr@plg}, + author = {A. N. Habermann and I. R. Nassi}, + title = {Efficient Implementation of {Ada} Tasks}, + institution = {Carnegie-Mellon University}, + number = {CMU-CS-80-103}, + year = 1980 +} + +@article{Emerald, + keywords = {concurrency, polymorphism}, + contributer = {pabuhr@plg}, + author = {Rajendra K. Raj and Ewan Tempero and Henry M. Levy and Andrew P. Black and Norman C. Hutchinson and Eric Jul}, + title = {Emerald: A General-Purpose Programming Language}, + journal = spe, + month = jan, + year = 1991, + volume = 21, + number = 1, + pages = {91-118} +} + +@InProceedings{chambers89a, + keywords = {maps, delegation}, + author = "Craig Chambers and David Ungar and Elgin Lee", + title = "An Efficient Implementation of {SELF}, a Dynamically-Typed + Object-Oriented Language Based on Prototypes", + crossref = "OOPSLA89", + pages = {49-70} +} + +@article{oop:encapsulation, + keywords = {Encapsulation, Inheritance, Subclasses, Multiple Inheritance}, + contributer = {gjditchfield@plg}, + author = {Alan Snyder}, + title = {Encapsulation and Inheritance in Object-Oriented Programming + Languages}, + journal = sigplan, + volume = {21}, number = {11}, + pages = {38-45}, + month = nov, year = 1986, + comment = { + Client, child interfaces should be distinct. Child interface + shouldn't grant total access to parent. + + Rules for redefining parent variable name in a child affect + re-implementation of the parent. + + Inheritance can be a promise to obey the semantics of the parent, + or code reuse; the two may be contradictory. Unification + exposes use of inheritance: a child can not be re-implemented + without breaking code that assumes that it is a subclass of the + original parent. If a class uses the names of its parents' + ancestors, then inheritance is part of the parent's child + interface. + + Linearizing a multiple inheritance tree means that a class's use of + calls on super need to be understood before it is used as a parent. + Merging repeated ancestors exposes inheritance if an ancestor is + re-implemented. Forbidding inheritance of distinct methods with + the same name exposes implementation of ancestors. Proposed + solution treats the set of ancestors as a tree. + } +} + +@article{st:encapsulator, + keywords = {encapsulator, Smalltalk, monitor}, + contributer = {gjditchfield@plg}, + author = {Geoffrey A. Pascoe}, + title = {Encapsulators: A New Software Paradigm in Smalltalk-80}, + journal = sigplan, + volume = {21}, number = {11}, + pages = {341-346}, + month = nov, year = 1986, + comment = { + Encapsulators are objects that surround other objects. + Pre- and post-actions are performed when messages are sent to the + encapsulated object. They are created here by sending the message + object: to an encapsulator class. Examples given are monitors, + atomic objects, and Model (for model-view-controller interfaces). + + Encapsulator classes use a family of selectors that the + encapsulated object will not respond to. Messages for the + encapsulated object are passed on by trapping them with the + doesNotUnderstand method. Various fiddles were needed when setting + up the class and metaclass hierarchies. A few selectors (==, + class) always directly invoke primitive methods; they can't be + used. + + Can an encapsulated object be an encapsulator? Probably, but the + middle object's selectors are inaccessible. + } +} + +@manual{EPT, + keywords = {concurrency, light-weight threads}, + contributer = {pabuhr@plg}, + key = {Encore}, + title = {Encore Parallel Thread Manual, 724-06210}, + organization= {Encore Computer Corporation}, + month = may, + year = 1988, +} + +@manual{Erlang, + keywords = {Erlang}, + contributer = {pabuhr}, + title = {Erlang Reference Manual User's Guide, Vertion 7.0}, + organization= {Erlang/OTP System Documentation}, + address = {1430 Broadway, New York, New York 10018}, + month = jun, + year = 2015, + note = {\href{http://www.erlang.org/doc/pdf/otp-system-documentation.pdf}{\textsf{http://www.erlang.org/\-doc/\-pdf/\-otp-system-documentation.pdf}}}, +} + +@inproceedings{MH88, + keywords = {modules, general sums, general products}, + contributer = {gjditchfield@plg}, + author = {John C. Mitchell and Robert Harper}, + title = {The Essence of {ML}}, + booktitle = popl, + year = 1988, + pages = {28-46} +} + +@book{LeVerrand, + keywords = {}, + author = {D. Le Verrand}, + title = {Evaluating {Ada}}, + publisher = {North Oxford Academic}, + year = 1985 +} + +@inproceedings{Bloom79, + keywords = {concurrency}, + contributer = {pabuhr@plg}, + author = {Toby Bloom}, + title = {Evaluating Synchronization Mechanisms}, + booktitle = {Proceedings of the Seventh Symposium on Operating Systems Principles}, + organization= {ACM SIGOPS}, + address = {Pacific Grove, California, U.S.A}, + month = dec, + year = 1979, + pages = {24-32} +} + +@article{Buhr06a, + keywords = {concurrency, C++, uC++}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr and Richard C. Bilson}, + title = {Examining $\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} : + High-level Object-Oriented Concurrency in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + journal = {Dr. Dobb's Journal : Software Tools for the Professional Programmer}, + month = feb, + year = 2006, + volume = 31, + number = 2, + pages = {36-40}, +} + +@article{ExceptionalC, + keywords = {exception handling, asynchronous events}, + contributer = {wyrmok@plg}, + author = {N. H. Gehani}, + title = {Exceptional {C} or {C} with Exceptions}, + journal = spe, + year = 1992, + month = oct, + volume = 22, + number = 10, + pages = {827-848}, + comment = { + It is the most extensive exceptional handling mechanism thus + far. Though it doesn't have Mesa resumption, it has + asynchronous signal which is more general and abstract than + the unix signal mechanism. It has an Eiffel like retry + mechanism. Consequently, the scope of guarded region is not + immediately terminated when an exception is raised. In fact, + an exception handler creates a scope under its guarded + region. + } +} + +@incollection{Buhr02, + keywords = {exception handling}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr and Ashif Harji and W. Y. Russell Mok}, + title = {Exception Handling}, + editor = {Marvin V. Zelkowitz}, + booktitle = {Advances in COMPUTERS}, + publisher = {Academic Press}, + volume = 56, + year = 2002, + pages = {245-303}, +} + +@article{Cargill94, + keywords = {exception handling}, + contributer = {pabuhr@plg}, + author = {Tom Cargill}, + title = {Exception Handling: a False Sense of Security}, + journal = {{C}{\kern-.2em\hbox{\large\texttt{+\kern-.2em+}}} Report}, + year = 1994, + month = nov, + volume = 6, + number = 9, + note = {http://www.informit.com/\-content/\-images/\-020163371x/\-supplements/\-Exception\_\-Handling\_\-Article.\-html} +} + +@article{Knudsen84, + keywords = {static exception handling, BETA, sequel}, + contributer = {wyrmok@plg}, + author = {J{\o}rgen Lindskov Knudsen}, + title = {Exception Handling --- A Static Approach}, + journal = spe, + year = 1984, + month = may, + volume = 14, + number = 5, + pages = {429-449}, +} + +@article{Drew94, + keywords = {exceptions, exception handling}, + contributer = {wyrmok@plg}, + author = {Steven J. Drew and K. John Gough}, + title = {Exception Handling: Expecting the Unexpected}, + journal = {Computer Languages}, + year = 1994, + month = may, + volume = 20, + number = 2, + comment = { + A recent and good survey on various exception handling mechanisms found + in imperative programming languages. It classifies various mechanism in + terms of flow control and scopes. Asynchronous exceptions and signals + are also covered as Exceptional C is in the survey. + } +} + +@article{Koenig90, + keywords = {exception handling}, + contributer = {pabuhr@plg}, + author = {Andrew Koenig and Bjarne Stroustrup}, + title = {Exception Handling for {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + journal = joop, + month = {July/August}, + year = 1990, + volume = 3, + number = 2, + pages = {16-33}, +} + +@article{Lee83, + keywords = {exception handling, C}, + contributer = {pabuhr@plg}, + author = {P. A. Lee}, + title = {Exception Handling in {C} Programs}, + journal = spe, + volume = 13, + number = 5, + month = may, + year = 1983, + pages = {389-405}, +} + +@article{Liskov79, + keywords = {exception handling}, + contributer = {pabuhr@plg}, + author = {Barbara H. Liskov and Alan Snyder}, + title = {Exception Handling in {CLU}}, + journal = ieeese, + month = nov, + year = 1979, + volume = {SE-5}, + number = 6, + pages = {546-558}, +} + +@article{Szalas85, + keywords = {concurrency, C++}, + contributer = {pabuhr@plg}, + author = {Andrzej Szalas and Danuta Szczepanska}, + title = {Exception Handling in Parallel Computations}, + journal = sigplan, + volume = 20, + number = 10, + month = oct, + year = 1985, + issn = {0362-1340}, + pages = {95-104}, + url = {http://doi.acm.org/10.1145/382286.382385}, + doi = {http://doi.acm.org/10.1145/382286.382385}, + acmid = {382385}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@article{MacLaren77, + keywords = {exception handling, PL/I}, + contributer = {pabuhr@plg}, + author = {M. Donald MacLaren}, + title = {Exception Handling in {PL/I}}, + journal = sigplan, + volume = 12, + number = 3, + month = mar, + year = 1977, + pages = {101-104}, + note = {Proceedings of an ACM Conference on Language Design for Reliable Software, + March 28--30, 1977, Raleigh, North Carolina, U.S.A.}, +} + +@article{Goodenough75, + keywords = {exception handling}, + contributer = {pabuhr@plg}, + author = {J. B. Goodenough}, + title = {Exception Handling: Issues and a Proposed Notation}, + journal = cacm, + month = dec, + year = 1975, + volume = 18, + number = 12, + pages = {683-696}, +} + +@article{Lampson80, + keywords = {monitors}, + contributer = {pabuhr@plg}, + author = {B. W. Lampson and D. D. Redell}, + title = {Experience with Processes and Monitors in Mesa}, + journal = cacm, + volume = 23, + number = 2, + month = feb, + year = 1980, + pages = {105-117}, +} + +@inproceedings{Shopiro87, + keywords = {concurrency}, + contributer = {pabuhr@plg}, + author = {Jonathan E. Shopiro}, + title = {Extending the {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Task System for Real-Time Control}, + booktitle = {Proceedings and Additional Papers {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Workshop}, + organization= {USENIX Association}, + address = {Santa Fe, New Mexico, U.S.A}, + month = nov, + year = 1987, + pages = {77-94} +} + +@article{Modula-2+, + keywords = {Modula-2, exceptions, garbage collection, concurrency}, + contributer = {gjditchfield@plg}, + author = {Paul Rovner}, + title = {Extending Modula-2 to Build Large, Integrated Systems}, + journal = {IEEE Software}, + month = nov, year = 1986, + volume = 3, number = 6, pages = {46-57}, + comment = { + Exceptions can have a parameter. Procedures can declare the + exceptions they can propagate; others are converted to {\tt + SYSTEM.Fail}. If they don't, all exceptions propagate. + Block cleanup statements execute no matter how control leaves the + block. + + {\tt REF t} is a garbage-collected pointer. A {\tt REFANY} can be + assigned any {\tt REF t}. Open array types can be used in + parameter and {\tt REF} types. {\tt NEW} creates arrays of fixed, + dynamically determined size. + + The {\tt THREAD} module provides lightweight processes, semaphores, + and conditions. A statement {\tt LOCK {\em semaphore} DO + {\em statements} END} is built in. + + {\tt SAFE} modules do run-time checks, and only import {\tt + SAFE} modules. One implementation module can implement several + definition modules. Opaque type implementations can be + repeated in modules that import its definition, so implementation + modules can collaborate. The linker checks that all + implementations are the same. + } +} + +@inproceedings{BNRPascal, + keywords = {concurrency, rendezvous}, + contributer = {pabuhr@plg}, + author = {R. Kamel and N. Gammage}, + title = {Experience with Rendezvous}, + booktitle = {Proceedings of the 1988 International Conference on Computer Languages}, + month = oct, + year = 1988, + pages = {143-149} +} + +% F + +@inproceedings{Knudsen01, + keywords = {Beta, exception handling}, + contributer = {pabuhr@plg}, + author = {J{\o}rgen Lindskov Knudsen}, + title = {Fault Tolerance and Exception Handling in {BETA}}, + booktitle = {Exception Handling}, + publisher = {Springer-Verlag}, + volume = 2022, + series = {Lecture Notes in Computer Science}, + year = 2001, + pages = {1-17} +} + +@article{Lamport87, + keywords = {software solutions, mutual exclusion, fast}, + contributer = {pabuhr@plg}, + author = {Leslie Lamport}, + title = {A Fast Mutual Exclusion Algorithm}, + journal = tocs, + volume = 5, + number = 1, + month = jan, + year = {1987}, + pages = {1--11}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@inproceedings{F-bound, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Peter Canning and William Cook and Walter Hill and Walter Olthoff and John C. Mitchell}, + title = {F-Bounded Polymorphism for Object-Oriented Programming}, + booktitle = {Fourth International Conference on Functional Programming Languages and Computer Architecture}, + year = 1989, + month = sep, + pages = {273-280} +} + +@mastersthesis{Wasik08, + author = {Ayelet Wasik}, + title = {Features of a Multi-Threaded Memory Allocator}, + school = {University of Waterloo}, + year = 2008, + month = jan, + address = {Waterloo, Ontario, Canada, N2L 3G1}, + note = {\textsf{http://uwspace.uwaterloo.ca/\-bitstream/\-10012/\-3501/\-1/\-Thesis.pdf}}, +} + +@article{Holzmann94, + keywords = {semaphore, flags}, + contributer = {pabuhr@plg}, + author = {Gerard J. Holzmann and Bj\"{o}rn Pehrson}, + title = {The First Data Networks}, + journal = {Scientific American}, + month = jan, + year = 1994, + volume = 12, + number = 1, + pages = {124-129}, +} + +@article{Bohm66, + keywords = {goto, structured programming}, + contributer = {pabuhr@plg}, + author = {C. B\"{o}hm and G. Jacopini}, + title = {Flow diagrams, Turing Machines and Languages with only two Formation Rules}, + journal = cacm, + month = may, + year = 1966, + volume = 9, + number = 5, + pages = {366-371}, +} + +@manual{Fortran95, + keywords = {Fortran 95}, + contributer = {pabuhr@plg}, + key = {Fortran95}, + title = {Fortran 95 Standard, ISO/IEC 1539}, + organization = {Unicomp, Inc.}, + address = {7660 E. Broadway, Tucson, Arizona, U.S.A, 85710}, + month = jan, + year = 1997, +} + +@manual{Fortran08, + keywords = {ISO/IEC Fortran 08}, + contributer = {pabuhr@plg}, + key = {Fortran08}, + title = {Programming Languages -- {Fortran} Part 1}, + organization= {International Standard ISO/IEC 1989:2014}, + publisher = {International Standard Organization}, + address = {http://www.iso.org}, + year = 2010, +} + +@book{Andrews00:book, + keywords = {concurrency}, + contributer = {pabuhr@plg}, + author = {Gregory R. Andrews}, + title = {Foundations of Multithreaded, Parallel and Distributed Programming}, + publisher = {Addison--Wesley}, + year = 2000, +} + +@article{Agha89, + keywords = {actors, concurrency}, + contributer = {pabuhr@plg}, + author = {Gul A. Agha}, + title = {Foundational Issues in Concurrent Computing}, + journal = sigplan, + month = apr, + year = 1989, + volume = 24, + number = 4, + pages = {60-65}, + note = {Proceedings of the ACM SIGPLAN Workshop on Object-Based Concurrent Programming, + Sept. 26--27, 1988, San Diego, California, U.S.A}, +} + +@article{ool, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Douglas T. Ross}, + title = {Toward Foundations for the Understanding of Type}, + journal = sigplan, + year = 1976, + volume = 11, pages = {63-65}, + note = {Conference on Data: Abstraction, Definition and Structure}, + summary = { + Possibly the first use (without definition, alas) of the phrase + "object oriented language". Metaphysical to the point of incoherence. + } +} + +@article{frames, + keywords = {frames}, + contributer = {gjditchfield@plg}, + author = {Paul G. Basset}, + title = {Frame-Based Software Engineering}, + journal = {IEEE Software}, + month = jul, year = 1987, + volume = 4, number = 4, pages = {9-16} +} + +@article{Sutter05, + keywords = {concurrency, C++}, + contributer = {pabuhr@plg}, + author = {Herb Sutter}, + title = {A Fundamental Turn Toward Concurrency in Software}, + journal = {Dr. Dobb's Journal : Software Tools for the Professional Programmer}, + month = mar, + year = 2005, + volume = 30, + number = 3, + pages = {16-22}, +} + +@inproceedings{Dony01, + keywords = {Smalltalk, exception handling}, + contributer = {pabuhr@plg}, + author = {Chistophe Dony}, + title = {A Fully Object-Oriented Exception Handling System: Rationale and Smalltalk Implementation}, + booktitle = {Exception Handling}, + publisher = {Springer-Verlag}, + volume = 2022, + series = {Lecture Notes in Computer Science}, + year = 2001, + pages = {18-38} +} + +@misc{FW, + key = {FW}, + contributer = {gjditchfield@plg}, + title = {Funk \& Wagnalls Standard Desk Dictionary}, + year = 1980 +} + +@book{Knuth73V1, + contributer = {pabuhr@plg}, + author = {Donald E. Knuth}, + title = {Fundamental Algorithms}, + series = {The Art of Computer Programming}, + publisher = {Addison-Wesley}, + year = 1973, + volume = 1, + edition = {second}, +} + +@inproceedings{Strachey, + keywords = {polymorphism}, + contributer = {gjditchfield@plg}, + author = {C. Strachey}, + title = {Fundamental Concepts in Programming Languages}, + booktitle = {Lecture Notes for the International Summer School in Computer Programming}, + year = 1967, + month = aug, + address = {Copenhagen}, + comment = { + Defines ad-hoc and parametric polymorphism. + } +} + +@article{Eisenberg72, + keywords = {concurrency, N-Process solution, O(N)}, + contributer = {pabuhr@plg}, + author = {Murray A. Eisenberg and Michael R. McGuire}, + title = {Further Comments on {D}ijkstra's Concurrent Programming Control Problem}, + journal = cacm, + month = nov, + year = 1972, + volume = 15, + number = 11, + pages = {999}, +} + +% G + +@article{Boehm88, + keywords = {conservative garbage collection, C}, + contributer = {gjditchfield@plg}, + author = {Hans-Juergen Boehm and Mark Weiser}, + title = {Garbage Collection in an Uncooperative Environment}, + journal = spe, + month = sep, + year = 1988, + volume = 18, + number = 9, + pages = {807-820} +} + +@manual{gcc, + keywords = {}, + contributer = {gjditchfield@plg}, + title = {GCC}, + author = {Richard M. Stallman}, + organization= {Free Software Foundation}, + address = {Cambridge, MA} +} + +@article{doUpon, + keywords = {formal verification, axiomatic semantics, control structures}, + contributer = {gjditchfield@plg}, + author = {Ed Anson}, + title = {A Generalized Iterative Construct and Its Semantics}, + journal = toplas, + volume = {9}, number = {4}, + pages = {567-581}, + month = oct, year = 1987, + comment = { + \begin{verbatim} + do + P1 -> L1 + [] P2 -> L2 + ... + [] Pm -> Lm + upon + Q1 -> M1 + [] Q2 -> M2 + ... + [] qn -> mn + od + \end{verbatim} + + If there is an i such that Qi is true, execute Mi and terminate. + Otherwise, if there is an i such that Pi is true, execute Li and + repeat the loop. Otherwise, fail. + } +} + +@article{Haskell, + keywords = {lazy evaluation, type class}, + contributer = {pabuhr}, + author = {Paul Hudak and Joseph H. Fasel}, + title = {A Gentle Introduction to Haskell}, + journal = sigplan, + volume = 27, + number = 5, + month = may, + year = 1992, + pages = {T1-53}, +} + +@manual{Go, + keywords = {Go programming language}, + contributer = {pabuhr@plg}, + title = {{Go} Programming Language}, + author = {Robert Griesemer and Rob Pike and Ken Thompson}, + organization= {Google}, + year = 2009, + note = {\href{http://golang.org/ref/spec}{http://golang.org/\-ref/\-spec}}, +} + +@article{Dijkstra68a, + keywords = {goto}, + contributer = {pabuhr@plg}, + author = {Edsger W. Dijkstra}, + title = {Go To Statement Considered Harmful}, + journal = cacm, + month = mar, + year = 1968, + volume = 11, + number = 3, + pages = {147-148}, + note = {Reprinted in \cite{Yourdon79} pp. 29--36.}, +} + +@article{Choi91, + keywords = {contra-variance, functions}, + contributer = {pabuhr@plg}, + author = {Injun Choi and Michael V. Mannino}, + title = {Graph Interpretation of Methods: A Unifying Framework for Polymorphism in Object-Oriented Programming}, + journal = {OOPS Messenger}, + volume = 2, + number = 1, + month = jan, + year = 1991, + pages = {38-54}, +} + +@misc{GNU-C, + keywords = {C, ANSI C}, + contributer = {pabuhr@plg}, + author = {Richard Stallman}, + title = {The Free Software Foundation's Gnu {C} Compiler}, + howpublished= {Free Software Foundation, 1000 Mass Ave., Cambridge, MA, U.S.A., 02138}, + year = 1989, +} + +@article{Dijkstra:green, + keywords = {ada}, + contributer = {gjditchfield@plg}, + author = {Edsger W. Dijkstra}, + title = {On the GREEN Language submitted to the DoD}, + journal = sigplan, + year = 1978, + month = oct, + volume = 13, + number = 10, + pages = {16-21} +} + +@inproceedings{Miller02, + keywords = {exception handling}, + contributer = {pabuhr@plg}, + author = {Robert Miller and Anand Tripathi}, + title = {The Guardian Model for Exception Handling in Distributed Systems}, + booktitle = {21st Symposium on Reliable Distributed Systems}, + organization= {IEEE}, + address = {Suita, Japan}, + year = 2002, + month = oct, + pages = {304-313} +} + +@phdthesis{Chen09, + author = {Jun Chen}, + title = {Guided Testing of Concurrent Programs Using Value Schedules}, + school = {University of Waterloo}, + year = 2009, + month = sep, + address = {Waterloo, Ontario, Canada, N2L 3G1}, + note = {\textsf{http://uwspace.uwaterloo.ca/bitstream/\-10012/\-4735/\-1/\-Chen-Jun.pdf}}, +} + +@misc{GNU-C++, + keywords = {C++, GNU C}, + contributer = {pabuhr@plg}, + author = {Michael D. Tiemann}, + title = {User's Guide to GNU {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + howpublished= {Free Software Foundation, 1000 Mass Ave., Cambridge, MA, U.S.A., 02138}, + month = mar, + year = 1990, +} + +% H + +@article{Michael04a, + keywords = {Lock-free, synchronization, concurrent programming, memory management, multiprogramming, dynamic data structures}, + author = {Maged M. Michael}, + title = {Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects}, + journal = ieeepds, + volume = 15, + number = 6, + month = jun, + year = 2004, + pages = {491-504}, + publisher = {IEEE Press}, + address = {Piscataway, NJ, USA}, +} + +@techreport{Hermes90, + keywords = {processes, distributed computing}, + contributer = {pabuhr@plg}, + author = {Robert E. Strom and David F. Bacon and Arthur P. Goldberg and Andy Lowry and Daniel M. Yellin and Shaula Alexander Yemini}, + title = {Hermes: A Language for Distributed Computing}, + institution = {IBM T. J. Watson Research Center}, + address = {Yorktown Heights, New York, U.S.A., 10598}, + month = oct, + year = 1990, +} + +@book{Hermes91, + keywords = {processes, distributed computing}, + contributer = {pabuhr@plg}, + author = {Robert E. Strom and David F. Bacon and Arthur P. Goldberg and Andy Lowry and Daniel M. Yellin and Shaula Alexander Yemini}, + title = {Hermes: A Language for Distributed Computing}, + publisher = {Prentice Hall}, + series = {Innovative Technology}, + year = 1991, +} + +@article{katzenelson83b, + contributer = {gjditchfield@plg}, + author = "Jacob Katzenelsen", + title = "Higher Level Programming and Data Abstraction---A Case Study using Enhanced C", + journal = spe, + year = 1983, + volume = 13, + number = 7, + pages = {577-596}, + month = jul +} + +@techreport{Hoare73, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {C. A. R. Hoare}, + title = {Hints on Programming Language Design}, + institution = {Stanford University Computer Science Department}, + year = 1973, + month = dec, + number = {CS-73-403}, + note = {Reprinted in \cite{pldesign}.} +} + +@article{Dijkstra71, + keywords = {monitor, secretary}, + contributer = {pabuhr@plg}, + author = {E. W. Dijkstra}, + title = {Hierarchical Ordering of Sequential Processes}, + journal = acta, + volume = 1, + pages = {115-138}, + year = 1971, +} + +@article{Buhr15a, + keywords = {software solution, mutual exclusion, performance experiment}, + author = {Peter A. Buhr and David Dice and Wim H. Hesselink}, + title = {High-Performance {$N$}-Thread Software Solutions for Mutual Exclusion}, + journal = {Concurrency and Computation: Practice and Experience}, + volume = 27, + number = 3, + pages = {651-701}, + month = mar, + year = 2015, +} + +@article{Ackermann28, + keywords = {recursion, Ackermann function}, + contributer = {pabuhr@plg}, + author = {Wilhelm Ackermann}, + title = {Zum Hilbertschen Aufbau der reellen Zahlen}, + publisher = {Springer}, + journal = {Mathematische Annalen}, + number = 1, + volume = 99, + pages = {118-133}, + month = dec, + year = 1928, +} + +@inproceedings{typeclass, + keywords = {Hindley/Miller type systems, Haskell}, + contributer = {gjditchfield@plg}, + author = {Philip Wadler and Stephen Blott}, + title = {How to make {\em Ad-Hoc} Polymorphism Less {\em Ad-Hoc}}, + booktitle = popl, + year = 1989, + pages = {60-76}, + organization= {Association for Computing Machinery} +} + +% I + +@book{IBM370, + keywords = {370, IBM}, + contributer = {pabuhr@plg}, + key = {IBM370}, + title = {{IBM} System/370 Principles of Operation}, + publisher = {IBM}, + number = {GA22-7000-8}, + month = oct, + year = 1981, + edition = {9th} +} + +@book{Icon, + keywords = {Icon}, + contributer = {pabuhr@plg}, + author = {Ralph E. Griswold and Madge T. Griswold}, + title = {The Icon Programming Language}, + publisher = {Prentice-Hall}, + year = 1983, +} + +@inproceedings{Valois94, + keywords = {lock free, queue}, + contributer = {pabuhr@plg}, + author = {John D. Valois}, + title = {Implementing Lock-Free Queues}, + booktitle = {Seventh International Conference on Parallel and Distributed Computing Systems}, + address = {Las Vegas, Nevada, U.S.A.}, + year = {1994}, + pages = {64-69}, +} + +@article{Hehner81, + keywords = {concurrency, critical section, bakery algorithm}, + contributer = {pabuhr@plg}, + author = {Eric C. R. Hehner and R. K. Shyamasundar}, + title = {An Implementation of {P} and {V}}, + journal = ipl, + year = 1981, + month = aug, + volume = 12, + number = 4, + pages = {196-198}, +} + +@incollection{Steenkiste91, + keywords = {lisp}, + contributer = {gjditchfield@plg}, + author = {Peter A. Steenkiste}, + title = {The Implementation of Tags and Run-Time Checking}, + booktitle = {Topics in Advanced Language Implementation}, + pages = {3-24}, + year = 1991, + editor = {Peter Lee}, + chapter = {1}, + publisher = {The MIT Press} +} + +@techreport{Roberts89, + keywords = {}, + contributer = {pabuhr@plg}, + author = {Eric S. Roberts}, + title = {Implementing Exceptions in {C}}, + institution = {Digital Systems Research Center}, + address = {130 Lytton Avenue, Palo Alto, California, 94301}, + number = {40}, + month = mar, + year = 1989, +} + +@mastersthesis{Bilson03, + keywords = {Cforall, parametric polymorphism, overloading}, + contributer = {pabuhr@plg}, + author = {Richard C. Bilson}, + title = {Implementing Overloading and Polymorphism in Cforall}, + school = {School of Computer Science, University of Waterloo}, + year = 2003, + address = {Waterloo, Ontario, Canada, N2L 3G1}, + note = {\href{http://plg.uwaterloo.ca/theses/BilsonThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-BilsonThesis.pdf}}, +} + +@article{Buhr05b, + keywords = {monitor, automatic signal, implicit signal}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr and Ashif S. Harji}, + title = {Implicit-signal monitors}, + journal = toplas, + volume = 27, + number = 6, + month = nov, + year = 2005, + issn = {0164-0925}, + pages = {1270--1343}, + doi = {http://doi.acm.org/10.1145/1108970.1108975}, + publisher = {ACM Press}, + address = {New York, NY, USA}, +} + +@article{Baker77, + author = {Henry C. Baker, Jr. and Carl Hewitt}, + title = {The Incremental Garbage Collection of Processes}, + journal = {SIGART Bulletin}, + publisher = {ACM}, + address = {New York, NY, USA}, + month = aug, + year = 1977, + pages = {55-59}, + issn = {0163-5719}, + doi = {http://doi.acm.org/10.1145/872736.806932}, + } + +@book{Algol68, + keywords = {Algol68}, + contributer = {pabuhr@plg}, + author = {C. H. Lindsey and S. G. van der Meulen}, + title = {Informal Introduction to ALGOL 68}, + publisher = {North-Holland}, + address = {London}, + year = 1977, +} + +@inproceedings{Cook90, + keywords = {f-bounded polymorhpism, lambda calculus}, + contributer = {gjditchfield@plg}, + author = {William R. Cook and Walter L. Hill and Peter S. Canning}, + title = {Inheritance is Not Subtyping}, + booktitle = popl, + year = 1990, + pages = {125-135}, + organization= {Association for Computing Machinery}, + abstract = { + In typed object-oriented languages the subtype relation is + typically based on the inheritance hierarchy. This approach, + however, leads either to insecure type-systems or to restrictions + on inheritance that make it less flexible than untyped Smalltalk + inheritance. We present a new typed model of inheritance that + allows more of the flexibility of Smalltalk inheritance within a + statically-typed system. Significant features of our analysis are + the introduction of polymorphism into the typing of inheritance and + the uniform application of inheritance to objects, classes and + types. The resulting notion of {\em type inheritance} allows us to + show that the type of an inherited object is an inherited type but + not always a subtype. + } +} + +@inproceedings{MMR92, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Robert E. Minnear and Patrick A. Muckelbauer and Vincent F. Russo}, + title = {Integrating the {Sun Microsystems} {XDR/RPC} Protocols + into the {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Stream Model}, + booktitle = {USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Conference Proceedings}, + year = 1992, + month = aug, + pages = {295-312}, + organization= {USENIX Association}, + address = {2590 Ninth Street, Suite 215, Berkeley, CA 94710}, + abstract = { + This paper reports our experiences integrating the Sun Microsystems + RPC and XDR protocol specifications into the C++ model of + input/output streams. As part of the {\it Renaissance} operating + system project, we wish to construct network servers and clients, + written in C++, which interoperate with existing UNIX clients + and servers. We discovered that, although it would be possible to + re-implement the procedural based XDR/RPC implementation + distributed by Sun Microsystems in C++, it is far cleaner to + integrate the protocols with the C++ I/O stream model. We + feel the resulting model provides a cleaner way of implementing RPC + clients and servers without losing functionality or compatibility + with existing clients and servers. + } +} + +@inproceedings{Zuo08, + keywords = {shared memory systems,intelligent multiport memory,multiprocessors systems,shared memory system}, + author = {Wang Zuo and Wang Zuo and Li Jiaxing}, + title = {An Intelligent Multi-Port Memory}, + booktitle = {Symposium on Intelligent Information Technology Application Workshops, Shanghai, China}, + month = dec, + year = 2008, + pages = {251-254}, + publisher = {IEEE Computer Society}, + address = {Los Alamitos, CA, USA}, +} + +@book{Francez96, + keywords = {await, formal}, + contributer = {pabuhr@plg}, + author = {Nissim Francez and Ira R. Forman}, + title = {Interacting Processes: A Multiparty Approach to Coordinated Distributed Programming}, + publisher = {Addison-Wesley}, + series = {ACM Press Books}, + year = 1996, +} + +@article{Labreche90, + keywords = {concurrency, C++}, + contributer = {pabuhr@plg}, + author = {Pierre Labr{\`{e}}che}, + title = {Interactors: A Real-Time Executive with Multiparty Interactions in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + journal = sigplan, + volume = 25, + number = 4, + month = apr, + year = 1990, + pages = {20-32}, +} + +@inproceedings{interfaces, + keywords = {parameterized interfaces, classes, recursion/inheritance}, + contributer = {gjditchfield@plg}, + author = {Peter S. Canning and William R. Cook and Walter L. Hill and + Walter G. Olthoff}, + title = {Interfaces for Strongly-Typed Object-Oriented Programming}, + crossref = "OOPSLA89", + pages = {457-467}, + abstract = { + This paper develops a system of explicit interfaces for + object-oriented programming. The system provides the benefits of + module interfaces found in languages like Ada and Modula-2 while + preserving the expressiveness that gives untyped object-oriented + languages like Smalltalk their flexibility. Interfaces are + interpreted as polymorphic types to make the system sufficiently + powerful. We use interfaces to analyze the properties of + inheritance, and identify three distinct kinds of inheritance in + object-oriented programming, corresponding to objects, classes, and + interfaces, respectively. Object interfaces clarify the + distinction between interface containment and inheritance and give + insight into limitations caused by equating the notions of type and + class in many typed object-oriented programming languages. + Interfaces also have practical consequences for design, + specification, and maintenance of object-oriented systems. + } +} + +@phdthesis{Girard72, + keywords = {universal quantification}, + contributer = {gjditchfield@plg}, + author = {J.-Y. Girard}, + title = {Interpretation fonctionelle et elimination des coupures de + l'arithmetique d'ordre superieur}, + school = {Universite Paris}, + year = {1972} +} + +@article{Karaorman93, + keywords = {Eiffel, concurrency libraries}, + contributer = {pabuhr@plg}, + author = {Murat Karaorman and John Bruno}, + title = {Introducing Concurrency to a Sequential Language}, + journal = cacm, + month = sep, + year = 1993, + volume = 36, + number = 9, + pages = {103-116} +} + +@book{Corman92, + keywords = {PRAM, parallel algorithms}, + contributer = {pabuhr@plg}, + author = {Thomas H. Cormen and Charles E. Leiserson and Ronald L. Rivest}, + title = {Introduction to Algorithms}, + publisher = {MIT Press/McGraw-Hill}, + series = {Electrical Engineering and Computer Science Series}, + year = 1992, +} + +@book{Hopcroft79, + keywords = {finite-state machine, push-dowm automata}, + contributer = {pabuhr@plg}, + author = {John E. Hopcroft and Jeffrey D. Ullman}, + title = {Introduction to Automata Theory, Languages and Computation}, + publisher = {Addison-Wesley}, + year = 1979, +} + +@techreport{walker87, + keywords = {CCS}, + contributer = {gjditchfield@plg}, + author = {David Walker}, + title = {Introduction to a Calculus of Communicating Systems}, + institution = {Laboratory for Foundations of Computer Science}, + year = 1987, + address = {Department of Computer Science, University of Edinburgh, Edinburgh EH9 3JZ}, + month = jun, + number = {ECS-LFCS-87-22}, +} + +@article{katzenelson83a, + author = {Jacob Katzenelson}, + title = {Introduction to Enhanced C (EC)}, + journal = spe, + volume = 13, + number = 7, + year = 1983, + month = jul, + pages = {551-576}, +} + +@book{Deitel90, + keywords = {concurrency, operating systems}, + contributer = {pabuhr@plg}, + author = {Harvey M. Deitel}, + title = {An Introduction to Operating Systems}, + publisher = {Addison-Wesley}, + year = 1990, + edition = {second}, +} + +@techreport{Birrell89, + keywords = {threads, monitors}, + contributer = {pabuhr@plg}, + author = {Andrew D. Birrell}, + title = {An Introduction to Programming with Threads}, + institution = {Digital Systems Research Center}, + address = {130 Lytton Avenue, Palo Alto, California, 94301}, + number = {35}, + month = jan, + year = 1989, + note = {{\textsf{http://www.hpl.hp.com/\-techreports/\-Compaq-DEC/\-SRC-RR-35.html}}}, + +} + +@article{t/o, + keywords = {Trellis/Owl}, + contributer = {gjditchfield@plg}, + author = {Craig Schaffert and Topher Cooper and Bruce Bullis and Mike Kilian and Carrie Wilpot}, + title = {An Introduction to Trellis/Owl}, + journal = sigplan, + volume = 21, + number = 11, + year = 1986, + month = nov, + pages = {9-16}, +} + +@inproceedings{Hibbard77, + keywords = {algol-68, concurrency}, + contributer = {pabuhr@plg}, + author = {Peter G. Hibbard and P. Knueven and B. W. Leverett}, + title = {Issues in the Efficient Implementation and Use of Multiprocessing in {Algol} 68}, + booktitle = {Proceedings of the 5th Annual iii Conference}, + address = {Guidel, France}, + month = may, + year = 1977, + pages = {203-221} +} + +@inproceedings{Miller97, + keywords = {exception handling, software-engineering}, + contributer = {pabuhr@plg}, + author = {Robert Miller and Anand Tripathi}, + title = {Issues with Exception Hnadling in Object-Oriented Systems}, + booktitle = {ECOOP'97}, + publisher = {Springer-Verlag}, + volume = 1241, + series = {Lecture Notes in Computer Science}, + year = 1997, + pages = {85-103} +} + +@article{Murer96, + keywords = {interators, generators, cursors}, + contributer = {pabuhr@plg}, + author = {Stephan Murer and Stephen Omohundro and David Stoutamire and Clemens Szyperski}, + title = {Iteration Abstraction in Sather}, + journal = toplas, + month = jan, + year = 1996, + volume = 18, + number = 1, + pages = {1-15}, +} + +% J + +@book{Java, + keywords = {Java}, + contributer = {pabuhr@plg}, + author = {James Gosling and Bill Joy and Guy Steele and Gilad Bracha}, + title = {The {Java} Language Specification}, + publisher = {Addison-Wesley}, + year = 2000, + edition = {second}, +} + +@manual{Java8, + keywords = {Java SE 8}, + contributer = {pabuhr@plg}, + author = {James Gosling and Bill Joy and Guy Steele and Gilad Bracha and Alex Buckley}, + title = {The {Java} Language Specification}, + publisher = {Oracle}, + year = 2015, + edition = {Java SE 8}, +} + +@manual{JUC, + keywords = {Java concurrency library}, + contributer = {pabuhr@plg}, + title = {java.util.concurrency}, + author = {Doug Lea}, + organization= {Oracle}, + year = 2014, + note = {\href{http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html}{\textsf{http://docs.oracle.com/\-javase/7/\-docs/\-api/\-java/\-util/\-concurrent/\-package-summary.html}}}, +} + +% K + +@article{Duggan96, + keywords = {concurrency, critical section}, + contributer = {pabuhr@plg}, + author = {Dominic Duggan and Gordon V. Cormack and John Ophel}, + title = {Kinded Type Inference for Parametric Overloading}, + journal = acta, + volume = 33, + number = 1, + year = 1996, + pages = {21-68}, +} + +@article{Peter35, + keywords = {recursion, Ackermann function}, + contributer = {pabuhr@plg}, + author = {R{\'{o}}zsa P{\'{e}}ter}, + title = {Konstruktion nichtrekursiver Funktionen}, + publisher = {Springer}, + journal = {Mathematische Annalen}, + number = 111, + volume = 1, + pages = {42-60}, + month = dec, + year = 1935, +} + +% L + +@TechReport{WVWR88:L, + contributer = {gjditchf@plg}, + author = {Hanno Wupper and Jan Vytopil and Martin Wieczorek and Dick de Reus}, + title = {{L}_{3333}: A Simple Language with Static Typing of Hard Real-Time Constraints}, + institution = {Department of Informatics, Faculty of Science, Catholic University Nijmegen}, + year = 1988, + number = {88-3}, + address = {Katholieke Universiteit Nijmegen, Fakulteit der Wiskunde + en Natuurwetenschappen, Infomatica V, Toernooiveld, 6512 + ED Nijmegen, The Netherlands}, + month = apr, + annote = {A polymorphic typed lambda calculus with \begin{itemize} + \item A trivial type, ``!'', with a single element. + \item Labelled types, distinct from each other. + ``!False'' and ``!True'' are distinct types, each + containing a single value serving as boolean false and + true. ``2'' is an abbreviation for ``!0 succ succ'', the + type containing only 2. + \item Disjunction types ``\{| !False, !True |\}''. Interval + types are abbreviations for disjunctions. + \item Conjunction types ``\{\& real Re, real Im \&\}'', where + ``Re'' and ``Im'' are type labels that distinguish between the + fields. + \item Pair types ``\{^ a, b ^\}'', for use in recursive types + and dyadic infix functions. + \item Function types, universal types, existential types, + and subtyping (viewed as coercion), as in Fun. + \end{itemize} + Disjunctions and conjunctions types are associative and + commutative (i.e. flat). Each type has a matching + constructor. Functions use pattern matching on type + labels to strip labels and extract conjunction fields: + \begin{verbatim} + \lambda n {0...1000000 Guilders}. ... n ... + -- both argument and n are amounts in Guilders. + \lambda n {0...1000000} Guilders. ... n ... + -- argument in Guilders, but n is in 0...1000000. + \end{verbatim} + ``Function bundles'' (conjunctions of functions), applied + to arguments, replace Dijkstra's guarded if...fi, but the + bundles are first-class and the guards are part of their + type. + + The same trick used to define the type ``2'' is used to + move absolute times into the type system, to allow static + checking. ``0`'' denotes a time before the system begins + execution. ``\#`'' denotes ``eventually'', and ``?`'' + denotes ``maybe never''. ``a\\t'' and ``a@t'' are types + of a value of type a that will be available no later + (earlier) than time t. Universals and existentials use + subtyping to parameterize functions by start time: + \begin{verbatim} + let f {\forall t > \#`}. {a\t} \on {b\t+d} + f{then} y -- argument y must be available at time ``then''. + \end{verbatim} + Functions can return before their arguments are available + if they don't use them. However, function {\em bundles} + can't return until their result type is known, so the + lower and upper time bounds of the bundle are the + second-last upper bound of the component functions: at + that time, there is only one alternative left. + + Explicit time parameterization allows slack in time + specification. Tools could point out slack or determine + degree of parallelism.} +} + +@mastersthesis{Clarke90, + keywords = {concurrency, postponing requests}, + contributer = {pabuhr@plg}, + author = {Charles L. A. Clarke}, + title = {Language and Compiler Support for Synchronous Message Passing Architectures}, + school = {University of Waterloo}, + year = 1990, + address = {Waterloo, Ontario, Canada, N2L 3G1} +} + +@article{Tennent77, + keywords = {abstraction, correspondence, Pascal}, + contributer = {gjditchfield@plg}, + author = {R. D. Tennent}, + title = {Language Design Methods Based on Semantic Principles}, + journal = acta, + year = 1977, + volume = 8, + number = 2, + pages = {97-112}, + note = {reprinted in \cite{pldesign}}, + abstract = { + Two language design methods based on principles derived from the + denotational approach to programming language semantics are + described and illustrated by an application to the language Pascal. + The principles are, firstly, the correspondence between parametric + and declarative mechanisms and secondly, a principle of abstraction + for programming languages adapted from set theory. Several useful + extensions and generalizations of Pascal emerge by applying these + principles, including a solution to the array parameter problem, + and a modularization facility. + }, +} + +@article{Liskov86, + keywords = {synchronous communication, concurrency}, + contributer = {pabuhr@plg}, + author = {Barbara Liskov and Maurice Kerlihy and Lucy Gilbert}, + title = {Limitations of Synchronous Communication with Static + Process Structure in Languages for Distributed Computing}, + journal = {}, + volume = {}, + number = {}, + month = {}, + year = {}, + pages = {}, +} + +@article{Linda, + keywords = {Linda, concurrency}, + contributer = {pabuhr@plg}, + author = {Nicholas Carriero and David Gelernter}, + title = {Linda in Context}, + journal = cacm, + volume = 32, + number = 4, + month = apr, + year = 1989, + pages = {444-458} +} + +@book{Weissman67, + keywords = {lisp}, + author = {Clark Weissman}, + title = {Lisp 1.5 Primer}, + publisher = {Dickenson Publishing}, + year = 1967, +} + +@article{Sundell08, + keywords = {lock free, deque}, + contributer = {pabuhr@plg}, + author = {H{\r{a}}kan Sundell and Philippas Tsigas}, + title = {Lock-free Deques and Doubly Linked Lists}, + journal = {J. Parallel Distrib. Comput.}, + volume = 68, + number = 7, + year = 2008, + pages = {1008-1020}, +} + +@article{Cormack89, + keywords = {parsing, LR, error recovery}, + contributer = {pabuhr@plg}, + author = {Gordon V. Cormack}, + title = {An {LR} Substring Parser for Noncorrecting Syntax Error Recovery}, + journal = sigplan, + volume = 24, + number = 7, + month = jul, + year = 1989, + pages = {161-169}, + note = {Proceedings of the {SIGPLAN}~'89 Conference on Programming Language Design and Implementation} +} + +% M + +@book{M68K, + keywords = {M680XX, Motorola}, + contributer = {pabuhr@plg}, + key = {Motorola}, + title = {M68000 Family Programmer's Reference Manual}, + publisher = {Motorola}, + year = 1992, +} + +@article{c++libs, + keywords = {directory structure}, + contributer = {gjditchfield@plg}, + author = {J. M. Coggins and G. Bollella}, + title = {Managing {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Libraries}, + journal = sigplan, + year = 1989, + month = jun, volume = 24, number = 6, pages = {37-48}, + abstract = { + This paper describes a scheme we have used to manage a large + library written in the C++ language. The scheme imposes a + directory structure, and represents dependency hierarchy in a + globally accessible file we call the 'prelude' file. We also + discuss the structure of the description files (makefiles) used + with the UNIX options we have found to be useful in reducing the + size of the library, and how to minimize recompilation time after + trivial changes to the source code of the library. + } +} + +@inproceedings{mprof, + keywords = {malloc}, + contributer = {gjditchfield@plg}, + author = {Benjamin Zorn and Paul Hilfinger}, + title = {A Memory Allocation Profiler for {C} and Lisp Programs}, + booktitle = {Summer 1988 {USENIX} proceedings}, + year = 1988 +} + +@manual{MMTk, + keywords = {Java memory management}, + contributer = {pabuhr@plg}, + title = {MMTk: The Memory Management Toolkit}, + author = {Steve Blackburn and Robin Garner and Daniel Frampton}, + month = sep, + year = 2006, + note = {\textsf{http://cs.anu.edu.au/\-\char`\~Robin.Garner/\-mmtk-guide.pdf}}, +} + +@article{Adve10, + keywords = {Java memory management}, + contributer = {pabuhr@plg}, + author = {Sarita V. Adve and Hans-J. Boehm}, + title = {Memory Models: A Case for Rethinking Parallel Languages and Hardware}, + journal = cacm, + volume = 53, + number = 8, + month = aug, + year = 2010, + pages = {90-101}, + publisher = {ACM}, + address = {New York, NY, USA}, +} +@techreport{Mesa, + keywords = {monitors, packages}, + contributer = {pabuhr@plg}, + author = {James G. Mitchell and William Maybury and Richard Sweet}, + title = {Mesa Language Manual}, + institution = {Xerox Palo Alto Research Center}, + number = {CSL--79--3}, + month = apr, + year = 1979 +} + +@article{Andrews89, + keywords = {semaphore, split-binary, baton}, + contributer = {pabuhr@plg}, + author = {Gregory R. Andrews}, + title = {A Method for Solving Synronization Problems}, + journal = scp, + volume = 13, + number = 4, + month = dec, + year = 1989, + pages = {1-21}, +} + +@inproceedings{Mitchell78, + keywords = {Mesa}, + contributer = {pabuhr@plg}, + author = {James G. Mitchell}, + title = {Mesa: A Designer's User Perspective}, + booktitle = {Spring CompCom 78}, + organization= {Sixteenth IEEE Computer Society International Conference}, + address = {San Francisco, California, U.S.A.}, + month = feb, + year = 1978, + pages = {36-39}, + note = {IEEE Catalog No. 78CH1328-4C}, +} + +@article{Gentleman81, + keywords = {messages, concurrency}, + contributer = {pabuhr@plg}, + author = {W. Morven Gentleman}, + title = {Message Passing between Sequential Processes: + the Reply Primitive and the Administrator Concept}, + journal = spe, + month = may, + year = 1981, + volume = 11, + number = 5, + pages = {435-466} +} + +@article{Cormack88, + keywords = {concurrency}, + contributer = {pabuhr@plg}, + author = {G. V. Cormack}, + title = {A Micro Kernel for Concurrency in C}, + journal = spe, + month = may, + year = 1988, + volume = 18, + number = 4, + pages = {485-491} +} + +@article{Buhr90a, + keywords = {concurrency, light-weight process, shared memory}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr and Richard A. Stroobosscher}, + title = {The $\mu${S}ystem: Providing Light-Weight Concurrency on Shared-Memory Multiprocessor Computers Running {UNIX}}, + journal = spe, + volume = 20, + number = 9, + month = sep, + year = 1990, + pages = {929-963}, +} + +@techreport{uSystem, + keywords = {C, concurrency, light-weight process, shared memory}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr and Hamish I. Macdonald and Richard A. Stroobosscher}, + title = {$\mu${S}ystem Annotated Reference Manual, Version 4.4.3}, + institution = {Department of Computer Science, University of Waterloo}, + address = {Waterloo, Ontario, Canada, N2L 3G1}, + month = sep, + year = 1994, + note = {{\small\textsf{ftp://\-plg.uwaterloo.ca/\-pub/\-uSystem/\-uSystem.ps.gz}}}, +} + +@book{Mips4000, + key = {Mips4000}, + title = {MIPS R4000 Microprocessor User's Manual}, + publisher = {MIPS Computer Systems Inc}, + year = 1991, +} + +@inproceedings{Mjolner, + keywords = {Mjolner, hierarchical windows}, + contributer = {pabuhr@plg}, + author = {G\"{o}rel Hedin and Boris Magnusson}, + title = {The Mj{\o}lner Environment: Direct Interaction with Abstractions}, + booktitle = {Proceedings of the European Conference on Object Oriented Programming}, + organization= {ECOOP'88}, + publisher = {Springer-Verlag}, + volume = 322, + editor = {S. Gjessing and K. Nygaard}, + address = {Oslo, Norway}, + month = aug, + year = 1988, + pages = {41-54}, + note = {Lecture Notes in Computer Science, Ed. by G. Goos and J. Hartmanis}, +} + +@article{Skillicorn98, + keywords = {parallel models}, + contributer = {pabuhr@plg}, + author = {David B. Skillicorn and Domenico Talia}, + title = {Models and Languages for Parallel Computation}, + journal = acmcs, + volume = 30, + number = 2, + month = jun, + year = 1998, + pages = {123-169}, +} + +@article{Werther96, + keywords = {C++, language syntax}, + contributer = {pabuhr@plg}, + author = {Ben Werther and Damian Conway}, + title = {A Modest Proposal: {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Resyntaxed}, + journal = sigplan, + volume = 31, + number = 11, + month = nov, + year = 1996, + pages = {74-82}, +} + +@book{Alexandrescu01, + keywords = {c design-patterns programming}, + contributer = {pabuhr@plg}, + author = {Andrei Alexandrescu}, + title = {Modern C++ Design: Generic Programming and Design Patterns Applied}, + publisher = {Addison-Wesley Professional}, + month = feb, + year = 2001, + isbn = {0201704315}, +} + +@book{Tanenbaum92, + keywords = {concurrency, operating systems}, + contributer = {pabuhr@plg}, + author = {Andrew S. Tanenbaum}, + title = {Modern Operating Systems}, + publisher = {Prentice-Hall}, + year = 1992, +} + +@article{Wirth77, + keywords = {modules, coroutines}, + contributer = {pabuhr}, + author = {Niklaus Wirth}, + title = {Modula: a Language for Modular Multiprogramming}, + journal = spe, + month = {January--February}, + year = 1977, + volume = 7, + number = 1, + pages = {3-35}, +} + +@book{Harbison92, + contributer = {mhcoffin}, + author = {Samuel P. Harbison}, + title = {Modula-3}, + publisher = {Prentise Hall, Inc.}, + year = {1992}, + comment = {This is a textbook for learning Modula-3.} +} + +@techreport{Modula-3:old, + keywords = {Modula-3, inheritance, type extension}, + contributer = {gjditchfield@plg}, + author = {Luca Cardelli and James Donahue and Lucille Glassman and Mick + Jordan and Bill Kalsow and Greg Nelson}, + title = {Modula-3 Report}, + institution = {Systems Research Center}, + address = {130 Lytton Avenue, Palo Alto, California 94301}, + month = aug, + year = 1988, + number = 31 +} + +@article{Dueck90, + keywords = {attribute grammars}, + contributer = {pabuhr@plg}, + author = {Gerald D. P. Dueck and Gordon V. Cormack}, + title = {Modular Attribute Grammars}, + journal = {The Computer Journal}, + month = apr, + year = 1990, + volume = 33, + number = 2, + pages = {164-172}, +} + +@article{Yemini85, + keywords = {exception handling}, + contributer = {pabuhr@plg}, + author = {Shaula Yemini and Daniel M. Berry}, + title = {A Modular Verifiable Exception-Handling Mechanism}, + journal = toplas, + month = apr, + year = 1985, + volume = 7, + number = 2, + pages = {214-243}, +} + +@article{Buhr95b, + keywords = {concurrency, monitors, classification}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr and Michel Fortier and Michael H. Coffin}, + title = {Monitor Classification}, + journal = acmcs, + volume = 27, + number = 1, + month = mar, + year = 1995, + pages = {63-107}, +} + +@article{Hoare74, + keywords = {monitor}, + contributer = {pabuhr@plg}, + author = {C. A. R. Hoare}, + title = {Monitors: An Operating System Structuring Concept}, + journal = cacm, + volume = 17, + number = 10, + month = oct, + year = 1974, + pages = {549-557}, + annote = { + } +} + +@inbook{Buhr99a, + keywords = {concurrency, monitors, classification}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr and Michel Fortier and Michael H. Coffin}, + title = {Encyclopedia of Computer Science and Technology}, + chapter = {Monitor Taxonomy}, + publisher = {Marcel Dekker, Inc}, + volume = {40, supplement 25}, + year = 1999, + pages = {191-212}, +} +% editor = {Allen Kent and James G. Williams}, + +@manual{MPI, + keywords = {MPI}, + contributer = {pabuhr@plg}, + title = {MPI: A Message-Passing Interface Standard, Version 3.1}, + organization= {Message Passing Interface Forum}, + address = {University of Tennessee, Knoxville, Tennessee}, + month = jun, + year = 2015, + note = {\href{http://www.mpi-forum.org/docs/mpi-3.1/mpi31-report.pdf}{\textsf{http://www.mpi-forum.org/\-docs/\-mpi-3.1/\-mpi31-report.pdf}}}, +} + +@article{multilisp, + keywords = {futures, scheme}, + contributer = {gjditchfield@plg}, + author = {Halstead, Jr.,Robert H.}, + title = {Multilisp: A Language for Concurrent Symbolic Programming}, + journal = toplas, + volume = 7, + number = 4, + pages = {501-538}, + month = oct, + year = 1985, + comment = { + (future E) begins evaluating the expression E, and + returns a ``future'' representing the value. When evaluation is + finished, the value of E replaces the future. Operations that need + the future's value suspend until it is available. Assignment and + parameter passing do not suspend. Future introduces concurrency + between the calculation of a value and its use; reference to + futures is a synchronization mechanism. + + (pcall F A B ... C) concurrently evaluates F, A, B, ... C, and then + applies F to the arguments. pcall can be built from future and a + ``touch'' operation. pcall is included because it may not be easy + to determine that there are no critical sections between the future + expression and the code between the future call and the value's + first use. + + (delay E) is like future, but E's process does not begin until its + value is needed. It provides lazy evaluation. Replacing delay + with future would launch an infinite number of processes. + } +} + +@techreport{Bretthauer89, + keywords = {multiple inheritance}, + contributer = {pabuhr@plg}, + author = {Harry Bretthauer and Thomas Christaller and J\"{u}rgen Kopp}, + title = {Multiple vs. Single Inheritance in Object-oriented Programming Languages. What do we really want?}, + institution = {Gesellschaft F\"{u}r Mathematik und Datenverarbeitung mbH}, + address = {Schlo$\beta$ Birlinghoven, Postfach 12 40, D-5205 Sankt Augustin 1, Deutschland}, + number = {Arbeitspapiere der GMD 415}, + month = nov, + year = 1989, +} + +@inproceedings{c++:multinh, + keywords = {C++, multiple inheritance, implementation}, + contributer = {gjditchfield@plg}, + author = {Bjarne Stroustrup}, + title = {Multiple Inheritance for {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + booktitle = {Proceedings of the Spring '87 EUUG Conference}, + month = may, year = 1987 +} + +@inproceedings{st:mult, + keywords = {smalltalk, multiple inheritance, implementation}, + contributer = {gjditchfield@plg}, + author = {Daniel H. H. Ingalls and A. H. Borning}, + title = {Multiple Inheritance in Smalltalk-80}, + booktitle = {Proceedings of the National Conference on Artificial Intelligence}, + month = aug, + year = 1982, + pages = {234-238}, + organization= {American Association for Artificial Intelligence}, + comment = { + Methods are looked up in the current class, the superclasses, the + supersuperclasses, etc. The same method can be inherited + repeatedly, but having different methods for the same message is an + error. Only one copy is made for multiply-inherited fields. + + {\tt X.m} is the method m in superclass X. {\tt super.m} is + allowed if there is no ambiguity; {\tt self super.m} replaces {\tt + super m}. {\tt all.m} invokes all inherited versions of m. + + Methods on the first-superclass chain are found as usual. Methods + from other superclasses are copied into the class dictionary. An + error method is created if inherited methods conflict. The parser + is changed to allow compound selectors. {\tt Object + messageNotUnderstood} is changed to look for compound selectors and + dynamically add a method with the right name and body to the class. + When methods are edited, they are copied into subclasses and + compound selector versions are deleted, as appropriate. + } +} + +@article{Lamport86I, + keywords = {software solutions, N-thread, mutual exclusions}, + contributer = {pabuhr@plg}, + author = {Leslie Lamport}, + title = {The Mutual Exclusion Problem: Part\,{I}--A Theory of Interprocess Communication}, + journal = jacm, + volume = 33, + number = 2, + month = apr, + year = 1986, + pages = {313--326}, + numpages = {14}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@article{Lamport86II, + keywords = {software solutions, N-thread, mutual exclusions}, + contributer = {pabuhr@plg}, + author = {Leslie Lamport}, + title = {The Mutual Exclusion Problem: Part\,{II}--Statement and Solutions}, + journal = jacm, + volume = 33, + number = 2, + month = apr, + year = 1986, + pages = {327--348}, + numpages = {22}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@article{Burns78, + keywords = {hardware, N-process solution, O(N)}, + contributer = {pabuhr@plg}, + author = {James E. Burns}, + title = {Mutual Exclusion with Linear Waiting Using Binary Shared Variables}, + journal = {SIGACT News}, + volume = 10, + number = 2, + month = {Summer}, + year = 1978, + pages = {42-47}, +} + +@inproceedings{Burns80, + keywords = {N-process software solution}, + contributer = {pabuhr@plg}, + author = {James E. Burns and Nancy A. Lynch}, + title = {Mutual Exclusion using Indivisible Reads and Writes}, + booktitle = {Proceedings of the 18th Annual Allerton Conference on Communications, Control and Computing, Monticello, Illinois, USA}, + year = 1980, + pages = {833-842}, + note = {\href{http://groups.csail.mit.edu/tds/papers/Lynch/allertonconf.pdf}{\textsf{http://\-groups.csail.mit.edu/\-tds/\-papers/\-Lynch/\-allertonconf.pdf}} [Accessed on March 2014]}, + optnote = {\textsf{http://\-groups.csail.mit.edu/\-tds/\-papers/\-Lynch/\-allertonconf.pdf}}, +} + +@article{Peterson81, + keywords = {concurrency, critical section}, + contributer = {pabuhr@plg}, + author = {G. L. Peterson}, + title = {Myths About the Mutual Exclusion Problem}, + journal = ipl, + year = 1981, + month = jun, + volume = 12, + number = 3, + pages = {115-116}, +} + +% N + +@article{Haddon77, + keywords = {monitors, nested monitor calls}, + contributer = {pabuhr@plg}, + author = {Bruce K. Haddon}, + title = {Nested Monitor Calls}, + journal = osr, + volume = 11, + number = 4, + month = oct, + year = 1977, + pages = {18-23}, +} + +@inproceedings{nesting, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Lori A. Clarke and Jack C. Wilenden and Alexander L. Wolf}, + title = {Nesting in {Ada} Programs is for the Birds}, + booktitle = {Proceedings of the ACM-SIGPLAN Symposium on the {Ada} + Programming Language}, + year = 1980, + month = dec, pages = {139-145}, + note = {SIGPLAN Notices, v. 15, n. 11}, + abstract = { + Given a data abstraction construct like the Ada package and in the + light of current thoughts on programming methodology, we feel that + nesting is an anachronism. In this paper we propose a nest-free + program style for Ada that eschews nested program units and + declarations within blocks and instead heavily utilizes packages + and context specifications as mechanisms for controlling + visibility. We view this proposal as a first step toward the + development of programming methods that exploit the novel language + features available in Ada. Consideration of this proposal's + ramifications for data flow, control flow, and overall program + structure substantiates our contention that a tree structure is + seldom a natural representation of a program and that nesting + therefore generally interferes with program development and + readability. + } +} + +@inproceedings{Buhr88, + keywords = {nested classes, persistence}, + contributer = {pabuhr@plg}, + author = {P. A. Buhr and C. R. Zarnke}, + title = {Nesting in an Object Oriented Language is NOT for the Birds}, + booktitle = {Proceedings of the European Conference on Object Oriented Programming}, + publisher = {Springer-Verlag}, + volume = 322, + editor = {S. Gjessing and K. Nygaard}, + address = {Oslo, Norway}, + month = aug, + year = 1988, + pages = {128-145}, + note = {Lecture Notes in Computer Science, Ed. by G. Goos and J. Hartmanis}, +} + +@inproceedings{Thompson90new, + keywords = {Plan 9}, + contributer = {pabuhr@plg}, + title = {A New C Compiler}, + author = {Ken Thompson}, + booktitle = {Proceedings of the Summer 1990 UKUUG Conference}, + year = 1990, + pages = {41--51}, + url = {http://doc.cat-v.org/bell_labs/new_c_compilers/new_c_compiler.pdf} +} + +@article{Trono94, + author = {John A. Trono}, + title = {A New Exercise in Concurrency}, + journal = {SIGCSE Bulletin}, + volume = {26}, + number = {3}, + month = sep, + year = {1994}, + pages = {8-10}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@article{Lamport74, + keywords = {concurrency, N-Process solution, O(N)}, + contributer = {pabuhr@plg}, + author = {Leslie Lamport}, + title = {A New Solution of Dijkstra's Concurrent Programming Problem}, + journal = cacm, + month = aug, + year = 1974, + volume = 17, + number = 8, + pages = {453-455}, +} + +@article{landin, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {P. J. Landin}, + title = {The Next 700 Programing Languages}, + journal = cacm, + year = 1966, + volume = 9, + pages = {157-164}, +} + +@article{Herlihy05, + keywords = {Multiprocessors, concurrent data structures, dynamic data structures, memory management, nonblocking synchronization}, + contributer = {pabuhr@plg}, + author = {Maurice Herlihy and Victor Luchangco and Paul Martin and Mark Moir}, + title = {Nonblocking Memory Management Support for Dynamic-sized Data Structures}, + journal = tocs, + volume = 23, + number = 2, + month = may, + year = 2005, + pages = {146-196}, + numpages = {51}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +% O + +@inproceedings{oop:abcl/1, + keywords = {concurrency, OOPL, futures}, + contributer = {gjditchfield@plg}, + author = {Akinori Yonezawa and Jean-Pierre Briot and Etsuya Shibayama}, + title = {Object-Oriented Concurrent Programming in {ABCL/1}}, + crossref = "OOPSLA86", + pages = {258-268}, + comment = { + Actions for messages sent to an object are executed concurrently + iff the object has no members. A select construct specifies a set + of message patterns. + + Express messages have priority. If an express message arrives + while an ordinary message is being processed, the action for the + ordinary message is suspended or aborted and the action for the + express message is executed. The sender decides which class a + message belongs in. Non-interruptible sections can be defined. + + Message sends can be non-blocking, or can block until a reply is + received, at the sender's option. The receiver can continue to + execute after sending the reply. + + Replies can send back ``futures'', and put values in them later. + Futures are queues of values, not single values. The caller can + use a ``ready?'' predicate to test for empty queue, or can use + operations to get the first or all queue elements; these operations + block if the queue is empty. + } +} + +@techreport{Schmidt95, + keywords = {ACE, concurrency, library}, + contributer = {pabuhr@plg}, + author = {Douglas C. Schmidt}, + title = {An OO Encapsulation of Lightweight OS Concurrency Mechanisms in the {ACE} Toolkit}, + institution = {Washington University in St. Louis}, + year = 1995, + number = 31, + note = {{\small\textsf{http://\-www.cs.wustl.edu/\-\char`\~schmidt/\-PDF/\-IPC\_SAP-92.pdf}}}, +} + +@inproceedings{OOEx, + keywords = {Exceptions, object-oriented programming languages}, + contributer = {gjditchfield@plg}, + author = {Christophe Dony}, + title = {An Object-oriented Exception Handling System for an Object-oriented Language}, + booktitle = {ECOOP '88. European Conference on Object-Oriented Programming}, + year = 1988, + pages = {146-161}, + editor = {S. Gjessing and K. Nygaard}, + organization= {DND, The Norwegian Computer Society}, + publisher = {Springer-Verlag}, + comment = { + Objectives: + - Users can define new exceptions. + - Default handlers can be attached to exceptions. + - Handlers can be attached to classes. + - Handlers can be attached to dynamic entities (expressions). + - Exceptions propagate first along the invocation chain. + - Exceptions should be hierarchically organized classes. + - Handlers should take into account the exception hierarchy (i.e., + should handle raising of sub-exceptions). + The ``exceptional-event'' class has two subclasses. ``Warning'' + has a ``resume'' method, and ``error'' has ``exit'' and + ``retry'' methods. Signalling an exception creates an instance + of the exception, whose members are used to pass information + back to the handler. Handlers are instances of class + ``protect-handler'' with a method ``protect {\em expression}'', + or are methods defined for the class or the exception. + } +} + +@article{CommonObjects, + author = {A. Snyder}, + title = {Object-Oriented Programming for Common Lisp}, + address = {Palo Alto CA}, + year = 1985, + publisher = {Software Technology Laboratory, Hewlett-Packard Laboratories}, + journal = {Report ATC-85-1}, +} + +@book{objective-c, + keywords = {}, + author = {Brad J. Cox}, + title = {Object-oriented programming; an evolutionary approach}, + publisher = {Addison-Wesley}, + year = 1986 +} + +@book{Beta, + keywords = {Beta, object oriented, concurrency, exceptions}, + contributer = {pabuhr@plg}, + author = {Ole Lehrmann Madsen and Birger M{\o}ller-Pedersen and Kristen Nygaard}, + title = {Object-oriented Programming in the {BETA} Programming Language}, + publisher = {Addison-Wesley}, + year = 1993, +} + +@article{Flavors, + author = {D. A. Moon}, + title = {Object-Oriented Programming with Flavors}, + address = {Portland OR}, + month = sep, + year = 1986, + journal = {Proc. ACM Conf. on Object-Oriented Systems, Languages and Applications}, +} + +@article{Buhr00b, + keywords = {concurrency, C++, real-time}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr and Ashif S. Harji and Philipp E. Lim and Jiongxiong Chen}, + title = {Object-Oriented Real-Time Concurrency}, + journal = sigplan, + volume = 35, + number = 10, + month = oct, + year = 2000, + pages = {29-46}, + note = {OOPSLA'00, Oct. 15--19, 2000, Minneapolis, Minnesota, U.S.A.}, +} + +@book{Meyer88, + keywords = {Eiffel}, + contributer = {pabuhr@plg}, + author = {Bertrand Meyer}, + title = {Object-oriented Software Construction}, + publisher = {Prentice Hall}, + year = {1988}, + series = {Prentice Hall International Series in Computer Science}, +} + +@article{objectPascal, + keywords = {objects, modules}, + contributer = {gjditchfield@plg}, + author = {Larry Tesler}, + title = {Object Pascal Report}, + journal = {Structured Language World}, + year = 1985, + volume = 9, + number = 3, +} + +@misc{obj-c:next, + keywords = {categories, protocols, Objective C}, + contributor = {gjditchfield@angus}, + author = {NeXT Computer, Inc.}, + title = {Objective C Extensions}, + howpublished= {On-line documentation in ``NEXTSTEP 3.1 Developer''}, + year = 1993 +} + +@book{Galletly96, + keywords = {occam}, + author = {John Galletly}, + title = {{OCCAM} 2: Including {OCCAM} 2.1}, + publisher = {{UCL} (University College London) Press Ltd.}, + edition = {second}, + year = 1996, +} + +@techreport{Morrison88, + keywords = {objects, concurrency, persistence}, + contributer = {pabuhr@plg}, + author = {R. Morrison and A. L. Brown and R. Carrick and R. Connor and A. Dearle}, + title = {On the integration of Object-Oriented and Process-Oriented computation in persistent environments}, + institution = {Department of Computational Science, University of St. Andrews, Scotland}, + number = {PPRR 57}, + month = jan, + year = 1988, +} + +@article{Peterson73, + keywords = {goto, structured programming}, + contributer = {pabuhr@plg}, + author = {W. W. Peterson and T. Kasami and N. Tokura}, + title = {On the Capabilities of While, Repeat, and Exit Statements}, + journal = cacm, + month = aug, + year = 1973, + volume = 16, + number = 8, + pages = {503-512} +} + +@article{Bak:overload, + keywords = {compilation}, + contributer = {gjditchfield@plg}, + author = {Theodore P. Baker}, + title = {A One-Pass Algorithm for Overload Resolution in {Ada}}, + journal = toplas, + year = 1982, + month = oct, + volume = 4, + number = 4, + pages = {601-614}, + abstract = { + A simple method is presented for detecting ambiguities and finding + the correct interpretations of expressions in the programming + language Ada. Unlike previously reported solutions to this + problem, which require multiple passes over a tree structure, the + method described here operates in one bottom-up pass, during which + a directed acyclic graph is produced. The correctness of this + approach is demonstrated by a brief formal argument. + }, + comment = { + See also \cite{D:overload}. + } +} + +@techreport{OpenMP, + keywords = {concurrency, openmp, spmd}, + contributer = {pabuhr@plg}, + author = {OpenMP Architecture Review Board}, + title = {OpenMP Application Program Interface, Version 4.0}, + month = jul, + year = 2013, + note = {\href{http://www.openmp.org/mp-documents/OpenMP4.0.0.pdf}{\textsf{http://www.openmp.org/mp-documents/OpenMP4.0.0.pdf}}}, +} + +@book{Deitel04, + keywords = {concurrency, operating systems}, + contributer = {pabuhr@plg}, + author = {Harvey M. Deitel and Paul J. Deitel and David R. Choffnes}, + title = {Operating Systems}, + publisher = {Pearson Prentice-Hall}, + year = 2004, + edition = {third}, +} + +@book{Stalling98, + keywords = {concurrency, operating systems}, + contributer = {pabuhr@plg}, + author = {William Stallings}, + title = {Operating Systems: Internals and Design Principles}, + publisher = {Prentice-Hall}, + year = 1998, + edition = {third}, +} + +@book{Stalling01, + keywords = {concurrency, operating systems}, + contributer = {pabuhr@plg}, + author = {William Stallings}, + title = {Operating Systems: Internals and Design Principles}, + publisher = {Prentice-Hall}, + year = 2001, + edition = {fourth}, +} + +@book{Silberschatz91, + keywords = {concurrency, operating systems}, + contributer = {pabuhr@plg}, + author = {Abraham Silberschatz and James L. Peterson and Peter Galvin}, + title = {Operating System Concepts}, + publisher = {Addision-Wesley}, + year = 1991, + edition = {third}, +} + +@book{Tanenbaum87, + keywords = {concurrency, operating systems}, + contributer = {pabuhr@plg}, + author = {Andrew S. Tanenbaum}, + title = {Operating Systems : Design and Implementation}, + publisher = {Prentice-Hall}, + series = {Software Series}, + year = 1987, +} + +@book{Hansen73, + keywords = {monitors}, + contributer = {pabuhr@plg}, + author = {Per {Brinch Hansen}}, + title = {Operating System Principles}, + publisher = {Prentice-Hall}, + year = 1973, +} + +@book{Bic03, + keywords = {concurrency, operating systems}, + contributer = {pabuhr@plg}, + author = {Lubomir F. Bic and Alan C. Shaw}, + title = {Operating System Principles}, + publisher = {Prentice-Hall}, + year = 2003, +} + +@techreport{milner88, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Robin Milner}, + title = {Operational and Algebraic Semantics of Concurrent Processes}, + institution = {Laboratory for Foundations of Computer Science}, + year = 1988, + address = {Department of Computer Science, University of Edinburgh, Edinburgh EH9 3JZ}, + month = feb, + number = {ECS-LFCS-88-46} +} + +@article{Ford82, + keywords = {}, + contributer = {pabuhr@plg}, + author = {G. Ford and B. Hansche}, + title = {Optional, Repeatable, and Varying Type Parameters}, + journal = sigplan, + volume = 17, + number = 2, + month = feb, + year = 1982, + pages = {41-48}, +} + +@manual{pli, + keywords = {PL/I}, + contributer = {gjditchfield@plg}, + key = {IBM}, + title = {{OS} and {DOS} {PL/I} Reference Manual}, + organization= {International Business Machines}, + edition = {first}, + month = sep, + year = 1981, + note = {Manual GC26-3977-0}, +} + +@techreport{D:overload, + keywords = {overload resolution, compilation}, + contributer = {gjditchfield@plg}, + author = {M. Dausmann et. al.}, + title = {Overloading in {Ada}}, + institution = {Universitat Karlsruhe}, + year = 1979, + number = {23/79}, + comment = { + Probably the earliest description of the two-pass (bottom-up, + top-down) overload resolution algorithm. See also + \cite{PW:overload,WS:overload,PDM:overload,Cor:overload,Bak:overload}. + } +} + +@article{EB87, + keywords = {packages, private types, assignment, equality}, + contributer = {gjditchfield@plg}, + author = {J. Dana Eckart and Richard J. LeBlanc}, + title = {Overloading in the {Ada} Language: Is it too restrictive?}, + journal = {Computer Languages}, + year = 1987, + volume = 12, number = {3/4}, pages = {163-172}, + abstract = { + Packages in the Ada language provide a mechanism for extending the + language through the development of additional data types. Such + types can be better integrated into the language using operator + overloading; however, key limitations prevent new types from being + transparently integrated into the language. Allowing function + names to overload private type names would give a cleaner and + clearer mechanism for building values of these types. Furthermore, + by allowing redefinitions of ``:='' and by making it easier to + overload ``='' for private types, Ada coud be transformed into a + more expressive language. + } +} + +@article{PW:overload, + keywords = {compilation}, + contributer = {gjditchfield@plg}, + author = {Guido Persch and Georg Winterstein and Manfred Dausman and Sophia Drossopoulou}, + title = {Overloading in Preliminary {Ada}}, + journal = sigplan, + year = 1980, + month = nov, volume = 15, number = 11, pages = {47-56}, + note = {Proceedings of the ACM-SIGPLAN Symposium on the {Ada} Programming + Language}, + comment = { + The two-pass (bottom-up, then top-down) algorithm, with a proof + that two passes suffice. See also \cite{D:overload}. + } +} + +@article{SR, + keywords = {concurrency, messages, rendezvous}, + contributer = {pabuhr@plg}, + author = {Gregory R. Andrews and Ronald A. Olsson and Michael Coffin and + Irving Elshoff and Kelvin Nilsen and Titus Purdin and Gregg Townsend}, + title = {An Overview of the {SR} Language and Implementation}, + journal = toplas, + month = jan, + year = 1988, + volume = 10, + number = 1, + pages = {51-86}, +} + +% P + +@article{Andrews91, + keywords = {general concurrency}, + contributer = {pabuhr@plg}, + author = {Gregory R. Andrews}, + title = {Paradigms for Process Interaction in Distributed Programs}, + journal = acmcs, + volume = 23, + number = 1, + month = mar, + year = 1991, + pages = {49-90}, +} + +@book{PPC++, + keywords = {concurrency, parallel, distributed, C++}, + contributer = {pabuhr@plg}, + editor = {Gregory V. Wilson and Paul Lu}, + title = {Parallel Programming in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + publisher = {MIT Press}, + series = {Scientific and Engineering Computation Series}, + year = 1996, + pages = {1-42}, +} + +@incollection{Stroustrup96, + keywords = {concurrency, C++}, + contributer = {pabuhr@plg}, + author = {Bjarne Stroustrup}, + title = {A Perspective on Concurrency in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + editor = {Gregory V. Wilson and Paul Lu}, + booktitle = {Parallel Programming in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + publisher = {MIT Press}, + series = {Scientific and Engineering Computation Series}, + year = 1996, + pages = {xxvi-xxvii}, +} + +@incollection{Yang96b, + keywords = {concurrency, C++}, + contributer = {pabuhr@plg}, + author = {Shelby X. Yang and Dennis Gannon and Peter Beckman and Jacob Gotwals and Neelakantan Sundaresan}, + editor = {Gregory V. Wilson and Paul Lu}, + title = {p{C}++}, + booktitle = {Parallel Programming in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + publisher = {MIT Press}, + address = {Cambridge, MA, USA}, + series = {Scientific and Engineering Computation Series}, + pages = {507-546}, + year = 1996, +} + +@article{goguen84, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Goseph A. Goguen}, + title = {Parameterized Programming}, + journal = ieeese, + year = 1984, + month = sep, volume = "SE-10", number = 5, pages = {528-543}, + abstract = { + Parameterized programming is a powerful technique for the reliable + reuse of software. In this technique, modules are parameterized + over very general interfaces that describe what properties of an + environment are required for the module to work correctly. + Reusability is enhanced by the flexibility of the parameterization + mechanism proposed here. Reliability is further enhanced by + permitting interface requirements to include more than purely + syntactic information. This paper introduces three new ideas that + seem especially useful in supporting parameterized programming: 1) + {\em theories}, which declare global properties of program modules + and interfaces; 2) {\em views}, which connect theories with program + modules in an elegant way; and 3) {\em module expressions}, a kind + of general structured program transformation which produces new + modules by modifying and combining existing modules. Although + these ideas are illustrated with some simple examples in the OBJ + programming language, they should also be taken as proposals for an + Ada library system, for adding modules to Prolog, and as + considerations for future language design efforts. OBJ is an + ultra-high level programming language, based upon rewrite rules, + that incorporates these ideas, and many others from modern + programming methodology. + } +} + +@inproceedings{c++:templates, + author = {Bjarne Stroustrup}, + contributer = {gjditchfield@plg}, + title = {Parameterized Types for {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + booktitle = {USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Conference}, + organization= {USENIX Association}, + year = 1988, pages = {1-18} +} + +@inproceedings{Boehm85, + keywords = {second-order unification}, + contributer = {gjditchfield@plg}, + author = {Hans-J. Boehm}, + title = {Partial Polymorphic Type Inference is Undecidable}, + booktitle = {26th Annual Symposium on Foundations of Computer Science}, + year = 1985, + pages = {339-345}, + organization= {IEEE Computer Society}, + publisher = {IEEE Computer Society Press}, + address = {1730 Massachusetts Avenue, N.W, Washington, D.C. 20036-1903}, + summary = { + Given a base typed lambda calculus with function types, type + abstractions, and a recursive expression \(\mbox{fix } x:t.e\), + then type inference for the partially typed language + \begin{eqnarray} + \lambda x:\tau.e &\Rightarrow& \lambda x.e \\ + \mbox{fix } x:\tau.e &\Rightarrow& \mbox{fix } x.e \\ + e \tau &\Rightarrow& e ? + \end{eqnarray} + is undecidable. + } +} + +@book{Pascal, + keywords = {Pascal}, + contributer = {pabuhr@plg}, + author = {Kathleen Jensen and Niklaus Wirth}, + title = {{P}ascal User Manual and Report}, + publisher = {Springer--Verlag}, + year = 1985, + edition = {third}, + note = {Revised by Andrew B. Mickel and James F. Miner, ISO Pascal Standard} +} + +@book{Pascal:old, + keywords = {Pascal}, + contributer = {pabuhr@plg}, + author = {Kathleen Jensen and Niklaus Wirth}, + title = {{P}ascal User Manual and Report}, + publisher = {Springer--Verlag}, + year = 1975, + edition = {first}, +} + +@article{Turba85, + keywords = {Pascal, exception handling, inheritance}, + contributer = {pabuhr@plg}, + author = {Thomas N. Turba}, + title = {The {P}ascal Exception Handling Proposal}, + journal = sigplan, + volume = 20, + number = 8, + month = aug, + year = 1985, + pages = {93-98}, +} + +@manual{Pascal/VS, + keywords = {PL/I}, + contributer = {pabuhr@plg}, + key = {IBM}, + title = {{P}ascal/{VS} Language Reference Manual}, + organization= {International Business Machines}, + edition = {first}, + year = 1981, + note = {Manual SH20-6168-1}, +} + +@article{Anderson90, + keywords = {spin locks, back off, performance}, + contributer = {pabuhr@plg}, + author = {Thomas E. Anderson}, + title = {The Performance of Spin Lock Alternatives for Shared-Memory Multiprocessors}, + journal = ieeepds, + month = jan, + year = 1990, + volume = 1, + number = 1, + pages = {6-16}, +} + +@article{poly, + keywords = {Poly, Standard ML, Russell, persistence}, + contributer = {gjditchfield@plg}, + author = {David C. J. Matthews}, + title = {Poly Manual}, + journal = sigplan, + month = sep, year = 1985, + volume = 20, number = 9, pages = {52-76} +} + +@techreport{Atkinson87b, + keywords = {naming, persistence}, + contributer = {pabuhr@plg}, + author = {M. P. Atkinson and R. Morrison}, + title = {Polymorphic Names and Iterations}, + institution = {Universities of Glasgow and St. Andrews, Scotland}, + number = {PPRR-53-87}, + month = nov, + year = 1987, +} + +@book{Harland, + keywords = {}, + author = {David M. Harland}, + title = {Polymorphic Programming Languages: Design and Implementation}, + publisher = {Ellis Horwood}, + year = 1984, + series = {Computers and their Applications}, + address = {Market Cross House, Cooper Street, Chichester, West Sussex, + PO19 1EB, England}, + summary = { + The principles of Procedural Abstraction, Data Type Completeness, + Declaration Correspondence, and Orthogonality are ruthlessly applied + to the design of a polymorphic language. + } +} + +@unpublished{poa, + keywords = {Force N, type inference, reusability, transcendance}, + contributer = {gjditchfield@plg}, + author = {G. V. Cormack and A. K. Wright}, + title = {Polymorphism, Overloading, and Abstraction}, + note = {personal communication} +} + +@inproceedings{forceone:impl, + keywords = {Parametric polymorphism, ForceOne}, + contributer = {gjditchfield@plg}, + author = {G. V. Cormack and A. K. Wright}, + title = {Polymorphism in the Compiled Language {ForceOne}}, + booktitle = {Proceedings of the 20th Hawaii International Conference on Systems Sciences}, + month = jan, + year = 1987, + pages = {284-292}, +} + +@incollection{POOL-T, + keywords = {objects, concurrency}, + contributer = {pabuhr@plg}, + author = {Pierre America}, + title = {POOL-T: A Parallel Object-Oriented Language}, + booktitle = {Object-Oriented Concurrent Programming}, + publisher = {The MIT Press}, + year = 1987, + pages = {199-220}, + editor = {Akinori Yonezawa and Mario Tokoro} +} + +@article{Hardgrave76, + keywords = {positional, keyword, parameters, arguments}, + contributer = {pabuhr@plg}, + author = {W. T. Hardgrave}, + title = {Positional versus Keyword Parameter Communication in Programming Languages}, + journal = sigplan, + volume = 11, + number = 5, + month = may, + year = 1976, + pages = {52-58}, +} + +@book{PowerPC, + key = {PowerPC processor}, + title = {Programming Environments Manual for 32-Bit Implementations of the PowerPC ArchitectureARM Architecture}, + publisher = {Freescale Semiconductor}, + volume = {MPCFPE32B}, + edition = {Rev. 3}, + month = 9, + year = 2005, +} + +@article{Ada:preliminary, + keywords = {Ada}, + contributer = {pabuhr@plg}, + author = {Jean D. Ichbiah and Bernd Krieg-Brueckner and Brian A. Wichmann + and Henry F. Ledgard and Jean-Claude Heliard and Jean-Raymond Abrial + and John G. P. Barnes and Olivier Roubine}, + title = {Preliminary {Ada} Reference Manual}, + journal = sigplan, + volume = 14, + number = 6, + month = jun, + year = 1979, + note = {Part A}, +} + +@techreport{Forsythe, + author = {John C. Reynolds}, + title = {Preliminary Design of the Programming Language {Forsythe}}, + institution = {Carnegie Mellon University}, + number = {CMU-CS-88-159}, + month = jun, + year = 1988, +} + +@article{PRESTO, + keywords = {concurrency, threads}, + contributer = {dgharriss@plg}, + author = {B. N. Bershad and E. D. Lazowska and H. M. Levy}, + title = {{PRESTO}: A System for Object-oriented Parallel Programming}, + journal = spe, + volume = 18, + number = 8, + month = aug, + year = 1988, + pages = {713-732} +} + +@book{Ben-Ari82, + keywords = {concurrency, parallel, programming languages}, + contributer = {pabuhr@plg}, + author = {Mordechai Ben-Ari}, + title = {Principles of Concurrent Programming}, + publisher = {Prentice-Hall International}, + year = 1982, +} + +@book{Tennent81, + author = {R. D. Tennent}, + title = {Principles of Programming Languages}, + publisher = {Prentice-Hall International}, + year = 1981, + series = {Series in Computer Science} +} + +@article{Lister77, + keywords = {monitors, nested monitor calls}, + contributer = {pabuhr@plg}, + author = {Andrew Lister}, + title = {The Problem of Nested Monitor Calls}, + journal = osr, + volume = 11, + number = 3, + month = jul, + year = 1977, + pages = {5-7}, +} + +@article{psa:persistence, + keywords = {persistence, first-class procedures, closure, PS-Algol, + Abstract Data Types}, + contributer = {gjditchfield@plg}, + author = {Malcolm P. Atkinson and Ronald Morrison}, + title = {Procedures as Persistent Data Objects}, + journal = toplas, + volume = {7}, number = {4}, + pages = {539-559}, + month = oct, year = 1985, + comment = { + PS-Algol has ``structures'', accessible only through ``pntrs''. + Pntrs can refer to any type of structure. Field references involve + a run-time check. This, plus first-class procedures, can simulate + abstract data types. Procedure variables operating on pntrs + simulate ADT operations. A block defines a structure to implement + the ADT, and assigns procedures to the variables. Functions + returning structures containing procedures simulate multiple + implementations and parameterized ADTs. + + An outer procedure that returns a procedure that contains + (non-local) references to the outer procedure's parameters + implements partial evaluation. + + Modules can be simulated like ADT's. The module itself is a + structure instance that is placed in persistent storage, and the + module is imported by fetching it from the persistent store. + Multiple instances of modules are easy. Installation of new + versions can be done by replacing the version in the database. + } +} + +@article{Procol89, + keywords = {active objects, object-oriented languages, + object-based languages, explicit per-object protocol}, + contributer = {akgoel@plg}, + author = {Jan van den Bos and Chris Laffra}, + title = {PROCOL: A Parallel Object Language with Protocols}, + journal = sigplan, + volume = 24, + number = 10, + month = oct, + year = 1989, + pages = {95-102}, + note = {Proceedings of the OOPSLA'89 Conference, Oct. 1--6, 1989, New Orleans, Lousiana}, + abstract = {}, +} + +@book{Butenhof97, + keywords = {PThreads, concurrency}, + contributer = {pabuhr@plg}, + author = {David R. Butenhof}, + title = {Programming with {POSIX} Threads}, + publisher = {Addison-Wesley}, + series = {Professional Computing}, + year = 1997, +} + +@book{SETL, + keywords = {SETL}, + contributer = {pabuhr@plg}, + author = {J. T. Schwartz and R. B. K. Dewar and E. Dubinsky and E. Schonberg}, + title = {Programming with Sets: An Introduction to {SETL}}, + publisher = {Springer-Verlag}, + year = 1986, +} + +@book{Genuys68, + keywords = {contains Dijkstra's Cooperating Sequential Processes}, + contributer = {pabuhr@plg}, + editor = {F. Genuys}, + title = {Programming Languages}, + publisher = {Academic Press}, + address = {London, New York}, + year = 1968, + note = {NATO Advanced Study Institute, Villard-de-Lans, 1966} +} + +@manual{ANSI99:C, + keywords = {ANSI C 99}, + contributer = {pabuhr@plg}, + title = {Programming Languages -- {C}}, + organization= {International Standard ISO/IEC 9899:1999 (E)}, + publisher = {American National Standards Institute}, + address = {www.ansi.org}, + year = 1999, +} + +@manual{ANSI98:C++, + keywords = {ANSI C++ 98}, + contributer = {pabuhr@plg}, + key = {C++98}, + title = {Programming Languages -- {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + organization= {International Standard ISO/IEC 14882:1998 (E)}, + publisher = {American National Standards Institute}, + address = {www.ansi.org}, + year = 1998, +} + +@manual{ANSI14:C++, + keywords = {ISO/IEC C++ 14}, + contributer = {pabuhr@plg}, + key = {C++14}, + title = {Programming Languages -- {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + edition = {fourth}, + organization= {International Standard ISO/IEC 14882:2014 (E)}, + publisher = {International Standard Organization}, + address = {http://www.iso.org}, + year = 2014, +} + +@manual{MS:VisualC++, + keywords = {Microsoft Visual C++}, + contributer = {pabuhr@plg}, + title = {Microsoft Visual {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} .NET Language Reference}, + organization= {Microsoft Corporation}, + year = 2002, + note = {Microsoft Press, Redmond, Washington, U.S.A.}, +} + +@article{HasselBring00, + keywords = {concurrency, prototyping}, + contributer = {pabuhr@plg}, + author = {Wilhelm Hasselbring}, + title = {Programming Languages and Systems for Prototyping Concurrent Applications}, + journal = acmcs, + volume = 32, + number = 1, + month = mar, + year = 2000, + pages = {43-79}, +} + +@article{LLgen, + keywords = {ll(1), parser generator, separate compilation}, + contributer = {gjditchfield@plg}, + author = {Dick Grune and Ceriel J. J. Jacobs}, + title = {A Programmer-friendly LL(1) Parser Generator}, + journal = spe, + month = jan, year = 1988, + volume = 18, number = 1, pages = {29-33}, + comment = { + LLgen generates C-language recursive-descent parsers. The input + contains procedure-like rules with alternation and repetition + constructs on the right, and (typed) parameters on the left. + C actions are specified between items in the right side. + Alternation and repetition (reduce and shift) conflicts can be + resolved statically or at run time. + + A grammar can be specified in several files. All files must be + submitted to LLgen at once, but if the C file generated is no + different from the old version, then the old version is not + replaced and hence need not be recompiled, which saves lots of + time. + + When an incorrect token is found, the automatic error recovery + algorithm discards tokens until an ``acceptable'' token is found; + if the acceptable token is not correct, a correct one is inserted. + } +} + +@techreport{russell, + keywords = {Russell}, + contributer = {gjditchfield@plg}, + author = {H. Boehm and A. Demers and J. Donahue}, + title = {A Programmer's Introduction to Russell}, + institution = {Rice University}, + year = 1985, + number = {85-16} +} + +@techreport{PDM89, + keywords = {existential types, universal types}, + contributer = {gjditchfield@plg}, + author = {Benjamin Pierce and Scott Dietzen and Spiro Michaylov}, + title = {Programming in Higher-Order Typed Lambda Calculi}, + institution = {School of Computer Science, Carnegie Mellon University}, + year = 1989, + address = {Pittsburg, PA 15213-3890}, + month = mar, number = {CMU-CS-89-111}, + abstract = { + This tutorial presents a hierarchy of increasingly powerful + languages, beginning with Church's simply typed + \(\lambda\)-calculus (\(F_1\)) and the second-order polymorphic + \(\lambda\)-calculus of Girard and Reynolds, and culminating in a + fragment of Girard's \(\omega\)-order polymorphic + \(\lambda\)-calculus (\(F_\omega\)). Our focus throughout is on + the unusual style of programming that arises in these languages, + where all functions are total and the primary control construct is + iteration rather than general recursion. + } +} + +@book{Modula-2, + keywords = {modules, coroutines}, + contributer = {pabuhr}, + author = {Niklaus Wirth}, + title = {Programming in Modula-2}, + publisher = {Springer-Verlag}, + year = 1988, + edition = {fourth}, + series = {Texts and Monographs in Computer Science}, +} + +@manual{Ada, + keywords = {Ada, packages, tasks, exceptions}, + contributer = {pabuhr@plg}, + title = {The Programming Language {Ada}: Reference Manual}, + organization= {United States Department of Defense}, + edition = {{ANSI/MIL-STD-1815A-1983}}, + month = feb, + year = 1983, + note = {Published by Springer-Verlag} +} + +@manual{ada:old, + keywords = {Ada, packages, tasks, exceptions}, + contributer = {gjditchfield@plg}, + title = {The Programming Language {Ada}: Reference Manual}, + organization= {United States Department of Defense}, + publisher = {Springer-Verlag}, + year = 1981 +} + +@book{Ghezzi, + keywords = {}, + author = {Carlo Ghezzi and Mehdi Jazayeri}, + title = {Programming Language Concepts}, + publisher = {Wiley}, + year = 1982 +} + +@article{ConcurrentPascal, + keywords = {Concurrent Pascal}, + contributer = {pabuhr@plg}, + author = {Per {Brinch Hansen}}, + title = {The Programming Language Concurrent Pascal}, + journal = ieeese, + volume = 2, + month = jun, + year = 1975, + pages = {199-206} +} + +@phdthesis{Buhr85:thesis, + keywords = {}, + contributer = {pabuhr@plg}, + author = {P. A. Buhr}, + title = {A Programming System}, + school = {University of Manitoba}, + year = {1985} +} + +@techreport{pierce91, + keywords = {typed lambda calculus}, + contributer = {gjditchfield@plg}, + author = {Benjamin C. Pierce}, + title = {Programming with Intersection Types, Union Types, and Polymorphism}, + institution = {Carnegie Mellon University}, + year = 1991, + month = feb, number = "CMU-CS-91-106", + annote = { + Discusses a typed lambda calculus with + \begin{itemize} + \item + Intersection types \(\tau = \tau_1\wedge\tau_2\) with \(\tau \le + \tau_i\) for all \(i\). + \item + Union types \(\tau = \tau_1\vee\tau_2\) with \(\tau_i \le \tau\), + and with implicit coercions from \(tau_i\) to \(\tau\). Only + operations valid for both element types can be applied to the + union; there are no projections. Union types are to variant + records as set union is to disjoint set union. + \item + Function types and universal quantification, with subtyping rules. + When functions and arguments intersections, the result of + application is the intersection of all valid combinations. + \item + Distribution rules for combinations of types. + \item + "Union elimination": "case \(x = e\) of \(e'\)", where \(e\) is a + union, has type \(\tau\) if \(e'\) has that type with \(x\) having + every element type of the union. + \item + "Finitary quantification": "for \(t\) in \(\tau_1,\ldots,\tau_n.e\)" + typechecks \(e\) with \(t\) bound to each choice, and intersects + the results. + \end{itemize} + + Examples include: type of "natural" numbers, treated as a union of + "zero" and "positive" types; default parameters, faked by using an + argument that is an intersection of a data type and a function + taking an explicit argument. + + Unions can be mostly faked, according to Mitchell: + \[\tau_1\vee\tau_2 \equiv + \forall\tau.(\tau_1\on\tau)\wedge(\tau_2\on\tau)\] + } +} + +@article{promises, + keywords = {futures, Argus, call streams, rpc}, + contributer = {gjditchfield@plg}, + author = {Barbara Liskov and Liuba Shrira}, + title = {Promises: Linguistic Support for Efficient Asynchronous + Procedure Calls in Distributed Systems}, + journal = sigplan, + year = 1988, + month = jul, volume = 23, number = 7, pages = {260-267}, + note = {Proceedings of the SIGPLAN '88 Conference on Programming Language + Design and Implementation}, + abstract = { + This paper deals with the integration of an efficient asynchronous + remote procedure call mechanism into a programming language. It + describes a new data type called a {\em promise} that was designed + to support asynchronous calls. Promises allow a caller to run in + parallel with a call and to pick up the results of the call, + including any exceptions it raises, in a convenient and type-safe + manner. The paper also discusses efficient composition of + sequences of asynchronous calls to different locations in a + network. + } +} + +@article{Cook89, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {W. R. Cook}, + title = {A Proposal for Making {Eiffel} Type-safe}, + journal = {The Computer Journal}, + year = 1989, + volume = 32, number = 4, pages = {305-311}, + abstract = { + + } +} + +@inproceedings{Foxall79, + keywords = {}, + contributer = {pabuhr@plg}, + author = {D. G. Foxall and M. L. Joliat and R. F. Kamel and J. J. Miceli}, + title = {{PROTEL}: A High Level Language for Telephony}, + booktitle = {Proceedings 3rd International Computer Software and Applications Conference}, + month = nov, + year = 1979, + pages = {193-197}, +} + +@techreport{PS-Algol, + keywords = {algol, persistence}, + contributer = {pabuhr@plg}, + key = {PS-Algol}, + title = {The {PS-Algol} Reference Manual, 4th Ed.}, + author = {}, + institution = {University of Glasgow and St. Andrews, Scotland}, + number = {PPRR 12}, + month = jun, + year = 1987, +} + +@manual{Python, + keywords = {Python}, + contributer = {pabuhr}, + title = {Python Reference Manual, Release 2.5}, + author = {Guido van Rossum}, + organization= {Python Software Foundation}, + month = sep, + year = 2006, + note = {Fred L. Drake, Jr., editor}, +} + +% Q + +@article{Hoare61, + keywords = {quick sort}, + contributer = {pabuhr@plg}, + author = {C. A. R. Hoare}, + title = {Algorithms 63/64: Partition/Quicksort}, + journal = cacm, + volume = 4, + number = 7, + month = jul, + year = 1961, + pages = {321}, +} + +% R + +@article{Ada:rationale:preliminary, + keywords = {Ada}, + contributer = {pabuhr@plg}, + author = {J. D. Ichbiah and J. C. Heliard and O. Roubine and + J. G. P. Barnes and B. Krieg-Brueckner and B. A. Wichmann}, + title = {Rationale for the Design of the {ADA} Programming Language}, + journal = sigplan, + volume = 14, + number = 6, + month = jun, + year = 1979, + note = {Part B}, +} + +@book{Ada:rationale, + keywords = {Ada}, + contributer = {pabuhr@plg}, + author = {Jean D. Ichbiah and John G. P. Barnes and Robert J. Firth and Mike Woodger}, + title = {Rationale for the Design of the {ADA} Programming Language}, + publisher = {Under Secretary of Defense, Research and Engineering}, + year = 1986, + address = {Ada Joint Program Office, OUSDRE(R\&AT), The Pentagon, Washington, D. C., 20301, U.S.A.}, +} + +@manual{Ada95, + keywords = {Ada}, + contributer = {pabuhr@plg}, + title = {{A}da Reference Manual}, + edition = {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}}, + organization = {Intermetrics, Inc.}, + month = dec, + year = 1995, + note = {Language and Standards Libraries} +} + +@manual{Ada12, + keywords = {Ada}, + contributer = {pabuhr@plg}, + title = {Programming languages -- {Ada}}, + edition = {third}, + organization= {International Standard ISO/IEC 1989:2014}, + publisher = {International Standard Organization}, + address = {http://www.iso.org}, + year = 2012, +} + +@manual{Ada95:annotated, + keywords = {Ada}, + contributer = {pabuhr@plg}, + title = {Annotated {A}da Reference Manual}, + edition = {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}}, + organization = {Intermetrics, Inc.}, + month = dec, + year = 1995, + note = {Language and Standards Libraries} +} + +@book{JavaRT00, + keywords = {real time, draft}, + contributer = {pabuhr@plg}, + author = {Greg Bollella and Ben Brosgol and Peter Dibble and Steve Furr and James Gosling and David Hardin and Mark Turnbull}, + title = {The Real-Time Specification for {J}ava}, + series = {The Real-Time for Java Expert Group, {\small\textsf{http://\-www.rtj.org}}}, + publisher = {Addison-Wesley}, + year = 2000, +} + +@manual{JavaRT99, + organization= {Real Time for Java Experts Group}, + address = {{\small\textsf{http://\-www.rtj.org}}}, + month = sep, + year = 1999, +} + +@article{Robinson48, + keywords = {recursion, Ackermann function}, + contributer = {pabuhr@plg}, + author = {Raphael Mitchel Robinson}, + title = {Recursion and Double Recursion}, + publisher = {American Mathematical Society}, + journal = {Bulletin of the American Mathematical Society}, + volume = 54, + pages = {987-993}, + year = 1948, +} + +@article{Dijkstra:red, + keywords = {ada}, + contributer = {gjditchfield@plg}, + author = {Edsger W. Dijkstra}, + title = {On the RED Language submitted to the DoD}, + journal = sigplan, + year = 1978, + month = oct, + volume = 13, + number = 10, + pages = {27-32}, +} + +@article{RemoteRendezvous, + keywords = {rendezvous, concurrency}, + contributer = {pabuhr@plg}, + author = {N. D. Gammage and R. F. Kamel and L. M. Casey}, + title = {Remote Rendezvous}, + journal = spe, + month = oct, + year = 1987, + volume = 17, + number = 10, + pages = {741-755} +} + +@article{Euclid, + keywords = {Euclid}, + contributer = {pabuhr@plg}, + author = {B. W. Lampson and J. J. Horning and R. L. London and J. G. Mitchell and G. L. Popek}, + title = {Report on the Programming Language Euclid}, + journal = sigplan, + volume = 12, + number = 2, + month = feb, + year = 1977, + pages = {1-79} +} + +@techreport{LOGLAN88, + keywords = {LOGLAN}, + contributer = {pabuhr@plg}, + author = {Boleslaw Ciesielski and Antoni Kreczmar and Marek Lao and Andrzej Litwiniuk and Teresa Przytycka and Andrzej Salwicki and Jolanta Warpechowska and Marek Warpechowski and Andrzej Szalas and Danuta Szczepanska--Wasersztrum}, + title = {Report on the Programming Language LOGLAN'88}, + institution = {Institute of Informatics, University of Warsaw}, + address = {Pkin 8th Floor, 00-901 Warsaw, Poland}, + number = {}, + month = dec, + year = 1988, +} + +@article{FH91, + keywords = {lcc}, + contributer = {gjditchfield@plg}, + author = {Christopher W. Fraser and David R. Hanson}, + title = {A Retargetable Compiler for {ANSI} {C}}, + journal = sigplan, + year = 1991, + month = oct, volume = 26, number = 10, pages = {29-43}, + abstract = { + {\tt lcc} is a new retargetable compiler for ANSI C. Versions for + the VAX, Motorola 68020, SPARC, and MIPS are in production use at + Princeton University and at AT\&T Bell Laboratories. With a few + exceptions, little about {\tt lcc} is unusual---it integrates + several well engineered, existing techniques---but it is smaller + and faster than most other C compilers, and it generates code of + comparable quality. {\tt lcc}'s target-independent front end + performs a few simple, but effective, optimizations that contribute + to good code; examples include simulating register declarations and + partitioning switch statements into dense tables. It also + implements target-independent function tracing and expression-level + profiling. + } +} + +@article{Algol68revised, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {A. van Wijngaarden and B. J. Mailloux and J. E. L. Peck and + C. H. A. Koster and M. Sintzoff and C. H. Lindsey and L. G. L. T. + Meertens and R. G. Fisher}, + title = {Revised Report on the Algorithmic Language {ALGOL} 68}, + journal = sigplan, + year = 1977, + month = may, + volume = 12, + number = 5, + pages = {1-70} +} + +@article{scheme, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Jonathan Rees and William Clinger}, + title = {Revised$^3$ Report on the Algorithmic Language {S}cheme}, + journal = sigplan, + year = 1986, + month = dec, + volume = 21, + number = 12, + pages = {37-79}, +} + +@article{scheme5, + keywords = {scheme}, + contributer = {pabuhr@plg}, + author = {H. Abelson and Adams, IV, N. I. and D. H. Bartley and G. Brooks and R. K. Dybvig and D. P. Friedman and + R. Halstead and C. Hanson and C. T. Haynes and E. Kohlbecker and D. Oxley and K. M. Pitman and G. J. Rozas and + G. L. Steele Jr. and G. J. Sussman and M. Wand and \emph{Ed. by} Richard Kelsey and William Clinger and Jonathan Rees}, + title = {Revised$^5$ Report on the Algorithmic Language {S}cheme}, + journal = sigplan, + year = 1998, + month = sep, + volume = 33, + number = 9, + pages = {26-76}, +} + +@manual{Rust, + keywords = {Rust programming language}, + contributer = {pabuhr@plg}, + title = {The {Rust} Programming Language}, + organization= {The Rust Project Developers}, + year = 2015, + note = {\href{https://doc.rust-lang.org/reference.html}{https://\-doc.rust-lang.org/\-reference.html}}, +} + +% S + +@inproceedings{Michael04, + keywords = {lock free, dynamic memory allocation}, + contributer = {pabuhr@plg}, + author = {Maged M. Michael}, + title = {Scalable Lock-free Dynamic Memory Allocation}, + booktitle = {PLDI '04: Proceedings of the ACM SIGPLAN 2004 Conference on Programming Language Design and Implementation}, + location = {Washington DC, USA}, + publisher = {ACM}, + address = {New York, NY, USA}, + volume = 39, + year = 2004, + month = jun, + pages = {35-46}, +} + +@article{Anderson92, + keywords = {light-weight tasks}, + contributer = {pabuhr@plg}, + author = {Thomas E. Anderson and Brian N. Bershad and Edward D. Lazowska and Henry M. Levy}, + title = {Scheduler Activations: Effective Kernel Support for the User-Level Management of Parallelism}, + journal = tocs, + volume = 10, + number = 1, + month = feb, + year = 1992, + pages = {53-79}, +} + +@manual{SELF, + keywords = {programming language, obect-oriented, polymorphism}, + contributer = {pabuhr@plg}, + author = {Ole Agesen and Lars Bak and Craig Chambers and Bay-Wei Chang and Urs H{\o}lzle + and John H. Maloney and Randall B. Smith and David Ungar and Mario Wolczko}, + title = {The {SELF} 3.0 Programmer's Reference Manual}, + organization= {Sun Microsystems, Inc., and Stanford University}, + year = 1993, +} + +@inproceedings{Cardelli84, + keywords = {subtypes, recursive types, records, variants, object oriented}, + contributer = {gjditchfield@plg}, + author = {Luca Cardelli}, + title = {A Semantics of Multiple Inheritance}, + booktitle = {Semantics of Data Types}, + year = 1984, + pages = {51-67}, + editor = {G. Kahn and D. B. MacQueen and G. D. Plotkin}, + publisher = {Springer-Verlag}, + note = {Lecture Notes in Computer Science v. 173}, +} + +@techreport{Adve95, + keywords = {shared memory, consistency models}, + contributer = {pabuhr@plg}, + author = {Sarita V. Adve and Kourosh Gharachorloo}, + title = {Shared Memory Consistency Models: A Tutorial}, + institution = {Western Research Laboratory}, + address = {250 University Avenue, Palo Alto, California, 94301, U.S.A.}, + number = {7}, + month = sep, + year = 1995, + note = {\href{http://www.hpl.hp.com/techreports/Compaq-DEC/WRL-95-7.pdf}{\textsf{http://www.hpl.hp.com/\-techreports/\-Compaq-DEC/\-WRL-95-7.pdf}}, Reprinted in \cite{Adve95reprint}.}, +} + +@article{Adve95reprint, + keywords = {shared memory, consistency models}, + contributer = {pabuhr@plg}, + author = {Sarita V. Adve and Kourosh Gharachorloo}, + journal = {Computer}, + title = {Shared Memory Consistency Models: A Tutorial}, + month = dec, + year = 1996, + volume = 29, + number = 12, + pages = {66-76}, +} + +@inproceedings{Howard76b, + keywords = {monitors}, + contributer = {pabuhr@plg}, + author = {J. H. Howard}, + title = {Signaling in Monitors}, + booktitle = {Proceedings Second International Conference Software Engineering}, + address = {San Francisco, U.S.A}, + publisher = {IEEE Computer Society}, + month = oct, + year = 1976, + pages = {47-52} +} + +@techreport{Schemenauer01, + keywords = {Phthon, generator, coroutine}, + contributer = {pabuhr@plg}, + author = {Neil Schemenauer and Tim Peters and Magnus Lie Hetland}, + title = {Simple Generators}, + month = may, + year = 2001, + note = {{\small\textsf{http://www.python.org/peps/pep-0255.html}}}, +} + +@inproceedings{Michael96, + keywords = {compare_and_swap, concurrent queue, lock-free, multiprogramming, non-blocking}, + contributer = {pabuhr@plg}, + author = {Maged M. Michael and Michael L. Scott}, + title = {Simple, Fast, and Practical Non-blocking and Blocking Concurrent Queue Algorithms}, + booktitle = {Proceedings of the Fifteenth Annual ACM Symposium on Principles of Distributed Computing}, + series = {PODC'96}, + year = 1996, + location = {Philadelphia, Pennsylvania, USA}, + pages = {267--275}, + numpages = {9}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@inproceedings{Dice10, + keywords = {hardware, synchronization, transactional memory}, + author = {Dave Dice and Yossi Lev and Virendra J. Marathe and Mark Moir and Dan Nussbaum and Marek Olszewski}, + title = {Simplifying Concurrent Algorithms by Exploiting Hardware Transactional Memory}, + booktitle = {Proceedings of the Twenty-second Annual ACM Symposium on Parallelism in Algorithms and Architectures}, + series = {SPAA'10}, + year = 2010, + location = {Thira, Santorini, Greece}, + pages = {325-334}, + numpages = {10}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@article{PDM:overload, + keywords = {compilation}, + contributer = {gjditchfield@plg}, + author = {Tom Pennello and Frank DeRemer and Richard Meyers}, + title = {A Simplified Operator Identification Scheme for {Ada}}, + journal = sigplan, + year = 1980, + month = {July--August}, + volume = 15, + number = {7/8}, + pages = {82-87}, + comment = { + The two-pass (bottom-up, top-down) overload resolution algorithm + for Ada, with a proof that two passes suffice and a claim that two + are necessary. See \cite{D:overload}. + } +} + +@book{SimulaBegin, + author = {Graham M. Birtwistle and Ole-Johan Dahl and Bj{\o}rn Myhrhaug and Kristen Nygaard}, + title = {{SIMULA} begin}, + publisher = {Studentlitteratur}, + year = {1980}, + address = {Lund, Sweden}, + edition = {second}, +} + +@book{Simula67, + author = "O-J Dahl and B. Myhrhaug and K. Nygaard", + address = "Oslo Norway", + month = oct, + year = 1970, + publisher = "Norwegian Computing Center", + title = "Simula67 Common Base Language" +} + +@book{smalltalk, + keywords = {Smalltalk, abstract class, protocol}, + contributer = {gjditchfield@plg}, + author = {A. Goldberg and D. Robson}, + title = {Smalltalk-80: The Language and its Implementation}, + publisher = {Addison-Wesley}, + year = 1983 +} + +@inproceedings{Edelson92, + keywords = {persistence, pointers}, + contributer = {pabuhr@plg}, + author = {Daniel R. Edelson}, + title = {Smart Pointers: They're Smart, but They're Not Pointers}, + booktitle = {USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Technical Conference Proceedings}, + organization= {USENIX Association}, + address = {Portland, Oregon, U.S.A.}, + month = aug, + year = 1992, + pages = {1-19}, +} + +@book{SNOBOL, + keywords = {SNOBOL4}, + contributer = {pabuhr@plg}, + author = {R. E. Griswold and J. F. Poage and I. P. Polonsky}, + title = {The SNOBOL4 Programming Language}, + edition = {second}, + publisher = {Prentice-Hall}, + year = 1971, +} + +@article{Sutter05b, + keywords = {concurrency}, + contributer = {pabuhr@plg}, + author = {Herb Sutter and James Larus}, + title = {Software and the Concurrency Revolution}, + journal = Queue, + year = 2005, + month = sep, + volume = 3, + number = 7, + pages = {54-62}, +} + +@inproceedings{raytheon, + keywords = {cobol}, + contributer = {gjditchfield@plg}, + author = {Robert G. Lanergan and Charles A. Grasso}, + title = {Software Engineering with Reusable Designs and Code}, + booktitle = {Workshop on Reusability in Programming}, + year = 1983, + month = sep, + pages = {224-234}, + organization= {{ITT} Programming}, + summary = { + 60\% of business application design and code are redundant. + Three standard program plans are used. Reuse doubles productivity + during development and greatly helps program comprehension during + maintenance. + } +} + +@article{Hecht86, + keywords = {exception handling, robustness}, + contributer = {pabuhr@plg}, + author = {H. Hecht and M. Hecht}, + title = {Software Reliability in the Systems Context}, + journal = ieeese, + year = 1986, + volume = 12, + number = 1, + pages = {51-58}, +} + +@inproceedings{Herlihy03, + author = {Maurice Herlihy and Victor Luchangco and Mark Moir and William N. {Scherer III}}, + title = {Software Transactional Memory for Dynamic-sized Data Structures}, + booktitle = {Proceedings of the Twenty-second Annual Symposium on Principles of Distributed Computing}, + series = {PODC '03}, + year = {2003}, + location = {Boston, Massachusetts}, + pages = {92-101}, + numpages = {10}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@article{Dijkstra65a, + keywords = {N-thread software-solution mutual exclusion}, + contributer = {pabuhr@plg}, + author = {Edsger W. Dijkstra}, + title = {Solution of a Problem in Concurrent Programming Control}, + journal = cacm, + volume = 8, + number = 9, + month = sep, + year = 1965, + pages = {569}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@inproceedings{Chen05, + keywords = {fixed-priority, preemption}, + contributer = {pabuhr@plg}, + author = {Jiongxiong Chen and Ashif Harji and Peter Buhr}, + title = {Solution Space for Fixed-Priority with Preemption Threshold}, + booktitle = {Proceedings of the 11th Real Time and Embedded Technology and Applications Symposium (RTAS'05)}, + organization= {IEEE}, + address = {San Francisco, CA, U.S.A}, + month = mar, + year = 2005, + pages = {385-394} +} + +@inproceedings{Tiemann88, + keywords = {wrappers}, + contributer = {pabuhr@plg}, + author = {Michael D. Tiemann}, + title = {Solving the RPC problem in GNU {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + booktitle = {Proceedings of the USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Conference}, + organization= {USENIX Association}, + address = {Denver, Colorado, U.S.A}, + month = oct, + year = 1988, + pages = {343-361} +} + +@book{Campbell74, + keywords = {path expressions}, + contributer = {pabuhr@plg}, + author = {R. H. Campbell and A. N. Habermann}, + title = {The Specification of Process Synchronization by Path Expressions}, + publisher = {Springer-Verlag}, + year = 1974, + volume = 16, + pages = {89-102}, + series = {Lecture Notes in Computer Science}, +} + +@article{Bentley85, + keywords = {CSP, concurrency}, + contributer = {pabuhr@plg}, + author = {J. Bentley}, + title = {A Spelling Checker}, + journal = cacm, + month = may, + year = 1985, + volume = 28, + number = 5, + pages = {456-462}, +} + +@manual{POSIX01, + keywords = {POSIX, Standard}, + contributer = {pabuhr@plg}, + key = {POSIX}, + title = {1003.1 Standard for Information Technology -- Portable Operating System Interface (POSIX), System Interface, Issue 6}, + organization= {IEEE and The Open Group}, + year = 2001, +} + +@manual{POSIX08, + keywords = {POSIX, Standard}, + contributer = {pabuhr@plg}, + key = {POSIX}, + title = {1003.1 Standard for Information Technology -- Portable Operating System Interface (POSIX), Base Specifications, Issue 7}, + organization= {IEEE and The Open Group}, + year = 2008, +} + +@inproceedings{ML:NJ, + keywords = {continuations, ML}, + contributer = {pabuhr@plg}, + author = {A. Appel and D. MacQueen}, + title = {A Standard {ML} Compiler}, + booktitle = {Functional Programming Languages and Computer Architecture}, + publisher = {Springer-Verlag}, + series = {Lecture Notes in Computer Science}, + volume = 274, + year = 1987, + pages = {301-324}, +} + +@techreport{MLreport, + keywords = {ML, polymorphism}, + contributer = {pabuhr@plg}, + author = {R. Milner}, + title = {The Standard {ML} Core Language}, + institution = {}, + number = {Polymorphism II.2}, + month = oct, + year = 1985 +} + +@inproceedings{Ghelli, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Giorgio Ghelli}, + title = {A Static Type System for Message Passing}, + crossref = "OOPSLA91", + pages = {129-145}, + summary = { + A strong, statically checked type system for object oriented + languages is defined by modelling methods as overloaded functions + with a "self" parameter, with dynamic overload resolution. This + allows covariant method redefinition. However, if equality is + covariantly redefined for Point and ColoredPoint classes, and a + ColoredPoint is compared to a Point, Point equality will be used, + even if self is the colored point! + } +} + +@article{Dijkstra68b, + keywords = {semaphore, P/V}, + contributer = {pabuhr@plg}, + author = {E. W. Dijkstra}, + title = {The Structure of the ``{THE}''--Multiprogramming System}, + journal = cacm, + month = may, + year = 1968, + volume = 11, + number = 5, + pages = {341-346} +} + +@book{Holt78, + keywords = {operating systems, concurrency}, + contributer = {pabuhr@plg}, + author = {R. C. Holt and G. S. Graham and E. D. Lazowska and M. A. Scott}, + title = {Structured Concurrent Programming with Operating System Applications}, + publisher = {Addison-Wesley}, + year = 1978, +} + +@article{Stevens74, + keywords = {coupling, cohesion}, + contributer = {pabuhr@plg}, + author = {W. P. Stevens and and G. J. Myers and L. L. Constantine}, + title = {Structured Design}, + journal = ibmsj, + year = 1974, + volume = 13, + number = 2, + pages = {115-139}, +} + +@article{Hansen72b, + keywords = {critical region}, + contributer = {pabuhr@plg}, + author = {Per {Brinch Hansen}}, + title = {Structured Multiprogramming}, + journal = cacm, + volume = 15, + number = 7, + month = jul, + year = 1972, + pages = {574-578}, +} + +@article{Knuth74, + keywords = {structured programming, goto statement}, + contributer = {pabuhr@plg}, + author = {Donald E. Knuth}, + title = {Structured Programming with go to Statements}, + journal = acmcs, + volume = 6, + number = 4, + month = dec, + year = 1974, + pages = {261-301}, + issn = {0360-0300}, + doi = {http://doi.acm.org/10.1145/356635.356640}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@article{Lang98, + keywords = {real-time, exception handling}, + contributer = {pabuhr@plg}, + author = {Jun Lang and David B. Stewart}, + title = {A Study of the Applicability of Existing Exception-Handling Techniques to Component-Based Real-Time Software Technology}, + journal = toplas, + month = mar, + year = 1998, + volume = 20, + number = 2, + pages = {274-301}, +} + +@mastersthesis{Fortier89, + keywords = {monitors}, + contributer = {pabuhr@plg}, + author = {Michel Fortier}, + title = {Study of Monitors}, + school = {Department of Computer Science, University of Waterloo}, + year = 1989, + address = {Waterloo, Ontario, Canada, N2L 3G1}, +} + +@techreport{AmadioCardelli, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Roberto M. Amadio and Luca Cardelli}, + title = {Subtyping Recursive Types}, + institution = {Digital Equipment Corporation Systems Research Center}, + year = 1990, + address = {130 Lytton Avenue, Palo Alto, California 94301}, + month = aug, + number = 62, + summary = { + \[ (s \leq t \Rightarrow \alpha \leq \beta) \Rightarrow + \mu s.\alpha leq \mu t.\beta \] + \[ \alpha = C[\alpha] \and \beta = C[\beta] \and C contractive + \Rightarrow \alpha = \beta \] + where a type \(\alpha\) is contractive in the type variable \(t\) + if either \(t\) does not occur free in \(\alpha\), or \(\alpha\) + can be rewritten via unfolding as a type of the shape + \(\alpha_1 \rightarrow \alpha_2\), and unfolding rewrites + \(\mu t.\alpha\) as \([t\leftarrow\mu t.\alpha]\alpha\). An + algorithm for finding type contexts \(C\) is given. + } +} + +@techreport{Dijkstra80, + keywords = {split binary semaphores, general to binary}, + contributer = {pabuhr@plg}, + author = {Edsger W. Dijkstra}, + title = {The Superfluity of the General Semaphore}, + institution = {Nuenen}, + address = {Netherlands}, + number = {EWD734}, + month = apr, + year = 1980, +} + +@inproceedings{Burns81, + keywords = {N-thread software-solution mutual exclusion}, + contributer = {pabuhr@plg}, + author = {James E. Burns}, + title = {Symmetry in Systems of Asynchronous Processes}, + booktitle = {22nd Annual Symposium on Foundations of Computer Science, Nashville, TN, USA}, + year = 1981, + month = oct, + organization= {IEEE Computer Society}, + address = {Los Angeles, CA, USA}, + pages = {169-174}, +} + +@article{Coffman71, + keywords = {deadlock}, + contributer = {pabuhr@plg}, + author = {E. G. {Coffman, Jr.} and M. J. Elphick and A. Shoshani}, + title = {System Deadlocks}, + journal = acmcs, + volume = 3, + number = 2, + month = jun, + year = 1971, + pages = {67-78}, + publisher = {ACM Press}, + address = {New York, NY, USA}, + doi = {http://doi.acm.org/10.1145/356586.356588}, +} + +@phdthesis{Holmes99, + keywords = {synchronization, inheritance anomaly}, + contributer = {pabuhr@plg}, + author = {David Holmes}, + title = {Synchronisation Rings: Composable Synchronisation for Object-Oriented Systems}, + school = {Department of Computing, Macquarie University}, + month = oct, + year = 1999, + address = {Sydney, Australia}, +} + +@book{Taubenfeld06, + keywords = {concurrency, synchronization}, + author = {Gadi Taubenfeld}, + title = {Synchronization Algorithms and Concurrent Programming}, + publisher = {Pearson/Prentice Hall}, + year = 2006, +} + +@article{Buhr92b, + keywords = {concurrency, exception handling, interventions}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr and Hamish I. Macdonald and C. Robert Zarnke}, + title = {Synchronous and Asynchronous Handling of Abnormal Events in the $\mu${S}ystem}, + journal = spe, + volume = 22, + number = 9, + month = sep, + year = 1992, + pages = {735-776}, +} + +@inproceedings{Greenwald96, + keywords = {compare and swap, hardware atomicity}, + contributer = {pabuhr@plg}, + author = {Michael Greenwald and David Cheriton}, + title = {The Synergy between Non-blocking Synchronization and Operating System Structure}, + booktitle = {Proceedings of the Second USENIX Symposium on Operating Systems Design and Implementation}, + organization= {USENIX Association}, + address = {Seattle, Washington, U.S.A.}, + month = oct, + year = 1996, + pages = {123-136}, +} + +@inbook{SunLWP, + keywords = {light-weight processes, threads}, + contributer = {pabuhr@plg}, + key = {Sun}, + title = {System Services Overview, Lightweight Processes}, + chapter = {6}, + pages = {71-111}, + publisher = {Sun Microsystems}, + month = may, + year = 1988, + note = {available as Part Number: 800-1753-10}, +} + +@article{Randell75, + contributer = {pabuhr@plg}, + author = {Brian Randell}, + title = {System Structure for Software Fault Tolerance}, + journal = ieeese, + volume = {SE-1}, + number = 2, + month = jun, + year = 1975, + pages = {220-232}, +} + +@book{Modula-3, + keywords = {language reference manual}, + contributer = {pabuhr@plg}, + author = {Andrew Birrell and Mark R. Brown and Luca Cardelli and Jim Donahue and Lucille Glassman and John Gutag and Jim Harning and Bill Kalsow and Roy Levin and Greg Nelson}, + title = {Systems Programming with Modula-3}, + publisher = {Prentice-Hall, Inc.}, + year = 1991, + series = {Prentice Hall Series in Innovative Technology} +} + +% T + +@article{Yeager91, + keywords = {teaching, concurrency}, + contributer = {pabuhr@plg}, + author = {Dorian P. Yeager}, + title = {Teaching Concurrency in the Programming Languages Course}, + journal = {SIGCSE BULLETIN}, + volume = 23, + number = 1, + month = mar, + year = 1991, + pages = {155-161}, + note = {The Papers of the Twenty-Second SIGCSE Technical Symposium on Computer Science Education, + March. 7--8, 1991, San Antonio, Texas, U.S.A.}, +} + +@article{ml, + keywords = {ML, polymorphism}, + contributer = {gjditchfield@plg}, + author = {Robin Milner}, + title = {A Theory of Type Polymorphism in Programming}, + journal = jcss, + year = 1978, + volume = 17, pages = {348-375} +} + +@book{Thoth, + keywords = {messages, concurrency}, + contributer = {pabuhr@plg}, + author = {D. R. Cheriton}, + title = {The Thoth System: Multi-Process Structuring and Portability}, + publisher = {American Elsevier}, + year = 1982 +} + +@article{Boehm05, + keywords = {concurrency, C++}, + contributer = {pabuhr@plg}, + author = {Hans-J. Boehm}, + title = {Threads Cannot be Implemented as a Library}, + journal = sigplan, + volume = 40, + number = 6, + month = jun, + year = 2005, + pages = {261-268}, +} + +@misc{Bumbulis90, + keywords = {parameter inference, ForceN}, + contributer = {gjditchfield@plg}, + author = {Peter Bumbulis}, + title = {Towards Making Signatures First-Class}, + howpublished= {personal communication}, + month = sep, year = 1990, + note = {} +} + +@techreport{alphard:preempt, + keywords = {}, + contributer = {gjditchfield@plg}, + author = {Mary Shaw and Wm. A. Wulf}, + title = {Toward Relaxing Assumptions in Languages and Their Implementations}, + institution = {Carnegie-Mellon University}, + year = 1980, + month = jan, + note = {Reprinted in \cite{alphard}.} +} + +@inproceedings{Reynolds74, + keywords = {universal quantification, typed lambda calculus}, + contributer = {gjditchfield@plg}, + author = {John C. Reynolds}, + title = {Towards a Theory of Type Structure}, + booktitle = {Colloque sur la Programmation}, + year = 1974, + pages = {408-423}, + editor = {B. Robinet}, + publisher = {Springer-Verlag}, + note = {Lecture Notes in Computer Science, v. 19}, + abstract = { + + } +} + +@incollection{Hoare72, + keywords = {critical region, concurrency}, + contributer = {pabuhr@plg}, + author = {C. A. R. Hoare}, + title = {Towards a Theory of Parallel Programming}, + booktitle = {Operating Systems Techniques}, + editor = {C. A. R. Hoare and R. H. Perott}, + publisher = {Academic Press, New York}, + year = 1972, + pages = {61-71}, +} + +@inproceedings{Mitchell90, + keywords = {polymorphism, lambda calculus, bounded quantification}, + contributer = {gjditchfield@plg}, + author = {John C. Mitchell}, + title = {Toward a Typed Foundation for Method Specialization and Inheritance}, + booktitle = {Conference Record of the Seventeenth Annual ACM Symposium + on Principles of Programming Languages}, + year = 1990, + month = jan, pages = {109-124}, + organization= {Association for Computing Machinery}, + abstract = { + This paper disucsses the phenomenon of {\em method specialization} + in object-oriented programming languages. A typed function + calculus of objects and classes is presented, featuring method + specialization when methods are added or redefined. The soundness + of the typing rules (without subtyping) is suggested by a + translation into a more traditional calculus with + recursively-defined record types. However, semantic questions + regarding the subtype relation on classes remain open. + } +} + +@article{EL1, + keywords = {polymorphism}, + contributer = {pabuhr@plg}, + author = {B. Wegbreit}, + title = {The Treatment of Data Types in {EL1}}, + journal = cacm, + volume = 17, + number = 5, + month = may, + year = 1974, + pages = {251-264}, +} + +@mastersthesis{Till89, + keywords = {C, multiple return values, tuples}, + contributer = {pabuhr@plg}, + author = {David W. Till}, + title = {Tuples In Imperative Programming Languages}, + school = {Department of Computer Science, University of Waterloo}, + year = 1989, + address = {Waterloo, Ontario, Canada, N2L 3G1}, +} + +@article{turing:old, + keywords = {verification, context conditions, faithful execution}, + contributer = {gjditchfield@plg}, + author = {R. C. Holt and J. R. Cordy}, + title = {The Turing Programming Language}, + journal = cacm, + year = 1988, + month = dec, + volume = 31, number = 12, pages = {1410-1423} +} + +@book{Turing, + keywords = {verification, context conditions, faithful execution}, + contributer = {pabuhr@plg}, + author = {R. C. Holt}, + title = {Turing Reference Manual}, + publisher = {Holt Software Associates Inc.}, + year = 1992, + edition = {third}, +} + +@techreport{Dijkstra79, + keywords = {split binary semaphores}, + contributer = {pabuhr@plg}, + author = {Edsger W. Dijkstra}, + title = {A Tutorial on the Split Binary Semaphore}, + institution = {Nuenen}, + address = {Netherlands}, + number = {EWD703}, + month = mar, + year = 1979, +} + +@book{pldesign, + keywords = {}, + editor = {Anthony I. Wasserman}, + title = {Tutorial: Programming Language Design}, + publisher = {Computer Society Press}, + year = 1980 +} + +@article{Leroy00, + keywords = {type-systems, exceptions}, + contributer = {pabuhr@plg}, + author = {Xavier Leroy and Fran\c{c}ois Pessaux}, + title = {Type-Based Analysis of Uncaught Exceptions}, + journal = toplas, + month = mar, + year = 2000, + volume = 22, + number = 2, + pages = {340-377}, + comment = { + Argues against declaring exceptions on routine definitions. + }, +} + +@article{Cormack90, + keywords = {polymorphism}, + contributer = {pabuhr@plg}, + author = {G. V. Cormack and A. K. Wright}, + title = {Type-dependent Parameter Inference}, + journal = sigplan, + volume = 25, + number = 6, + month = jun, + year = 1990, + pages = {127-136}, + note = {Proceedings of the ACM Sigplan'90 Conference on Programming Language Design and Implementation + June 20-22, 1990, White Plains, New York, U.S.A.}, +} + +@article{concatenation, + keywords = {record concatenation, isa}, + contributer = {gjditchfield@plg}, + author = {N. Wirth}, + title = {Type Extensions}, + journal = toplas, + volume = {10}, + number = {2}, + pages = {204-214}, + month = apr, year = 1988, + comment = { + Extended record types add fields to their base record. Assignment + truncations. Pointers can point at extended type instances. For + polymorphism, call by value is assignment, and call by reference is + pointer passing. Overloading isn't discussed. Type information + can be recovered through an ``is'' type test or through type guards + (casts). A version of the WITH statement could avoid repeated + checking. + + Private/public access to record fields can be provided by exporting + a base type, and using a private extension. Statically allocated + instances need a compiler hint specifying the maximum size of the + private type. + + Type checking is cheap (if the creation of pointer values is + controlled). Types have type descriptors. Extension descriptors + point at their direct base. Heap objects point at their + descriptor, and reference parameters are accompanied by type + descriptor parameters. ``v is t0'' loops along the chain of + descriptors. + } +} + +% U + +@unpublished{uC++book, + keywords = {control structure, concurrency}, + contributer = {pabuhr@plg}, + author = {Peter A. Buhr}, + title = {Understanding Control Flow with Concurrent Programming using $\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, + year = 1999, + note = {Textbook in preparation} +} + +@article{Cardelli85, + keywords = {polymorphism}, + contributer = {pabuhr@plg}, + author = {Luca Cardelli and Peter Wegner}, + title = {On Understanding Types, Data Abstractions, and Polymorphism}, + journal = acmcs, + month = dec, + year = 1985, + volume = 17, + number = 4, + pages = {471-522}, +} + +@inproceedings{Wilson92, + keywords = {garbage collection survey}, + contributer = {pabuhr@plg}, + author = {Paul R. Wilson}, + title = {Uniprocessor Garbage Collection Techniques}, + booktitle = {Proceedings of the International Workshop on Memory Management}, + location = {St. Malo, France}, + publisher = {Springer-Verlag}, + series = {Lecture Notes in Computer Science}, + volume = 637, + month = sep, + year = {1992}, + pages = {1-42}, +} + +@inproceedings{Hewitt73, + author = {Carl Hewitt and Peter Bishop and Richard Steiger}, + title = {A Universal Modular {ACTOR} Formalism for Artificial Intelligence}, + booktitle = {Proceedings of the 3rd International Joint Conference on Artificial Intelligence}, + address = {Standford, California, U.S.A.}, + pages = {235-245}, + month = aug, + year = 1973, +} + +@article{Bourne78, + keywords = {Shell}, + contributer = {pabuhr@plg}, + author = {S. R. Bourne}, + title = {The UNIX Shell}, + journal = {The Bell System Technical Journal}, + volume = {57, part 2}, + month = {July--August}, + year = 1978, + pages = {1971-1990}, +} + +@inproceedings{Krischer12, + keywords = {exception, usability, asynchronous, assertion, injection, logging}, + contributer = {pabuhr@plg}, + author = {Roy Krischer and Peter A. Buhr}, + title = {Usability Challenges in Exception Handling}, + booktitle = {5th International Workshop on Exception Handling (WEH)}, + organization= {16th International Symposium on the Foundations of Software Engineering (FSE 16)}, + address = {Zurich, Switzerland}, + month = jun, + year = 2012, + pages = {7-13}, +} + +@techreport{Harmony, + keywords = {messages, concurrency}, + contributer = {pabuhr@plg}, + author = {W. Morven Gentleman}, + title = {Using the Harmony Operating System}, + institution = {National Research Council of Canada, Ottawa, Canada}, + number = {24685}, + month = may, + year = 1985 +} + +@article{delegation, + keywords = {delegation, inheritance, actors}, + contributer = {gjditchfield@plg}, + author = {Henry Lieverman}, + title = {Using Prototypical Objects to Implement Shared Behavior in + Object Oriented Systems}, + journal = sigplan, + month = nov, year = 1986, + volume = 21, number = 11, pages = {214-223} +} + +% V + +@article{V-Kernel, + keywords = {messages, concurrency}, + contributer = {pabuhr@plg}, + author = {David R. Cheriton}, + title = {The {V} Distributed System}, + journal = cacm, + month = mar, + year = 1988, + volume = 31, + number = 3, + pages = {314-333} +} + +@inproceedings{Amdahl67, + author = {Gene M. Amdahl}, + title = {Validity of the Single Processor Approach to Achieving Large Scale Computing Capabilities}, + booktitle = {Proceedings of the April 18-20, 1967, Spring Joint Computer Conference}, + series = {AFIPS '67 (Spring)}, + year = 1967, + location = {Atlantic City, New Jersey}, + pages = {483--485}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@article{Mayer81, + keywords = {}, + contributer = {pabuhr@plg}, + author = {A. J. W. Mayer}, + title = {Value Receiving Procedures}, + journal = sigplan, + volume = 16, + number = 11, + month = nov, + year = 1981, + pages = {30-34}, +} + +@article{Doran80, + keywords = {concurrency, Dekker's Algorithm}, + contributer = {pabuhr@plg}, + author = {R. W. Doran and L. K. Thomas}, + title = {Variants of the Software Solution to Mutual Exclusion}, + journal = ipl, + month = jul, + year = 1980, + volume = 10, + number = {4/5}, + pages = {206-208}, +} + +@book{VAX, + keywords = {VAX, DEC}, + contributer = {pabuhr@plg}, + key = {VAX}, + title = {VAX-11 Architecture Reference Manual}, + publisher = {Digital Press}, + month = may, + year = 1982, +} + +@book{Kenah88, + author = {Lawrence J. Kenah and Ruth E. Goldenberg and Simon F. Bate}, + title = {{VAX/VMS} Internals and Data Structures Version 4.4}, + publisher = {Digital Press}, + year = 1988, +} + +@article{Hesselink13, + keywords = {software solutions, N-thread, mutual exclusions}, + contributer = {pabuhr@plg}, + author = {Wim H. Hesselink}, + title = {Verifying a Simplification of Mutual Exclusion by {L}ycklama--{H}adzilacos}, + journal = {Acta Informatica}, + publisher = {Springer-Verlag}, + year = {2013}, + volume = {50}, + number = {3}, + pages = {199-228}, +} + +% W + +@article{Herlihy91, + keywords = {linearization, wait-free synchronization}, + contributer = {pabuhr@plg}, + author = {Maurice Herlihy}, + title = {Wait-free Synchronization}, + journal = toplas, + volume = {13}, + number = {1}, + month = jan, + year = 1991, + pages = {124--149}, + numpages = {26}, + publisher = {ACM}, + address = {New York, NY, USA}, +} + +@techreport{Moss90, + keywords = {Swizzling, database}, + contributer = {akgoel@plg}, + author = {J. Moss}, + title = {Working with Persistent Objects: To Swizzle or Not to Swizzle}, + institution = {CS Department, University of Massachusetts}, + address = {}, + number = {CS 90-38}, + month = may, + year = 1990, +} + +@inproceedings{Str:oop, + keywords = { }, + contributer = {pabuhr@plg}, + author = {Bjarne Stroustrup}, + title = {What is ``Object-Oriented Programming''?}, + booktitle = {Proceedings of the First European Conference on Object Oriented Programming}, + month = jun, + year = 1987 +} + +@misc{Stroustrup:overloading, + keywords = {operator overloading}, + contributer = {pabuhr@plg}, + author = {Bjarne Stroustrup}, + title = {Why can't I overload dot, ::, sizeof, etc.?}, + month = oct, + year = 2007, + howpublished= {{\small\textsf{http://\-www.research.att.com/\-bs/\-bs\_faq2.html\-\#overload-dot}}}, +} + +@techreport{Gray85, + keywords = {fault-tolerant system}, + contributer = {pabuhr@plg}, + author = {Jim Gray}, + title = {Why Do Computers Stop and What Can Be Done About It?}, + institution = {Tandem Computers}, + number = {85.7 PN87614}, + month = jun, + year = 1985, + note = {\textsf{http://www.hpl.hp.com/\-techreports/\-tandem/\-TR-85.7.pdf}}, +} + +% X + +% Y + +% Z + +% Cross-referenced entries: + +% O + +% The SIGPLAN Notices issue should be in a note field, but notes are +% inherited by all refering entries, instead of being held in the +% cross-referenced entry. Putting it in "publisher" is a kludge, but it +% works. +@proceedings{OOPSLA86, + contributer = {gjditchfield@plg}, + title = {{OOPSLA} '86 Conference Proceedings}, + booktitle = {{OOPSLA} '86 Conference Proceedings}, + year = 1986, + editor = {Norman Meyrowitz}, + publisher = sigplan # " 21(11)", + organization= {Association for Computing Machinery}, + address = {Portland, Oregon}, + month = sep # { 29} +} + +@proceedings{OOPSLA87, + contributer = {gjditchfield@plg}, + title = {{OOPSLA} '87 Conference Proceedings}, + booktitle = {{OOPSLA} '87 Conference Proceedings}, + year = 1987, + editor = {Norman Meyrowitz}, + publisher = sigplan # " 22(12)", + organization= {Association for Computing Machinery}, + address = {Orlando, Florida}, + month = oct # { 4--8} +} + +@proceedings{OOPSLA88, + contributer = {gjditchfield@plg}, + title = {{OOPSLA} '88 Conference Proceedings}, + booktitle = {{OOPSLA} '88 Conference Proceedings}, + year = 1988, + editor = {Norman Meyrowitz}, + publisher = sigplan # " 23(11)", + organization= {Association for Computing Machinery}, + address = {San Diego, California}, + month = sep # { 25--30} +} + +@proceedings{OOPSLA89, + contributer = {gjditchfield@plg}, + title = {{OOPSLA} '89 Conference Proceedings}, + booktitle = {{OOPSLA} '89 Conference Proceedings}, + year = 1989, + editor = {Norman Meyrowitz}, + publisher = sigplan # " 24(10)", + organization= {Association for Computing Machinery}, + address = {New Orleans, Louisiana}, + month = oct # { 1--6} +} + +@proceedings{OOPSLA90, + contributer = {gjditchfield@plg}, + title = {{OOPSLA/ECOOP} '90 Conference Proceedings}, + booktitle = {{OOPSLA} '90 Conference Proceedings}, + year = 1990, + editor = {Norman Meyrowitz}, + publisher = sigplan # " 25(10)", + organization= {Association for Computing Machinery}, + address = {Ottawa, Canada}, + month = oct # { 21--25} +} + +@proceedings{OOPSLA91, + contributer = {gjditchfield@plg}, + title = {{OOPSLA} '91 Conference Proceedings}, + booktitle = {{OOPSLA} '91 Conference Proceedings}, + year = 1991, + editor = {Andreas Paepcke}, + publisher = sigplan # " 26(11)", + organization= {Association for Computing Machinery}, + address = {Phoenix, Arizona}, + month = oct # { 6--11} +}