Changeset e229c22 for doc/bibliography

Timestamp:

Jun 4, 2016, 12:34:24 PM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

57aa6f5, b8387fc

Parents:

31eed869

Message:

change gitignore with respect to latex-generated files, small updates to manuals, replace bibtex link with actual file

File:

• doc/bibliography/cfa.bib (modified) (1 diff, 1 prop)

doc/bibliography/cfa.bib

@@ -1 @@
-/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 ``<language name>:'' 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},