source: doc/bibliography/pl.bib @ 80a9898

% 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
@string{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{ieeepds="IEEE Trans. Parallel Distrib. Syst."}
string{ieeese="IEEE Transactions on Software Engineering"}
@string{ieeese="IEEE Trans. Softw. Eng."}
string{spe="Software---\-Practice and Experience"}
@string{spe="Softw. Pract. Exper."}
string{ccpe="Concurrency and Computation: Practice and Experience"}
@string{ccpe="Concurrency Comput.: Pract. Exper."}
string{sigplan="SIGPLAN Notices"}
@string{sigplan="SIGPLAN Not."}
string{joop="Journal of Object-Oriented Programming"}
@string{joop="J. of Object-Oriented Program."}
@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"}
@string{toplas="Transactions on Programming Languages and Systems"}
string{mathann="Mathematische Annalen"}
@string{mathann="Math. Ann."}

% 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},
    address     = {New York},
    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},
    address     = {Boston},
}

@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},
    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     = {3rd},
}

@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},
}

@manual{Akka,
    keywords    = {Akka actor model},
    contributer = {pabuhr@plg},
    title       = {{A}kka {S}cala Documentation, Release 2.4.11},
    organization= {Lightbend Inc.},
    month       = sep,
    year        = 2016,
    note        = {\href{http://doc.akka.io/docs/akka/2.4/AkkaScala.pdf}{http://\-doc.akka.io/\-docs/\-akka/\-2.4/\-AkkaScala.pdf}},
}

@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{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},
}

@article{Cormack81,
    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   = {MIT Press},
    address     = {Cambridge},
    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},
    address     = {New York},
    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, Burlington},
    year        = 1992,
}

@book{alphard,
    keywords    = {Parametric polymorphism, alphard, iterators, nested types},
    contributer = {gjditchfield@plg},
    key         = {Alphard},
    editor      = {Mary Shaw},
    title       = {{ALPHARD}: Form and Content},
    publisher   = {Springer},
    address     = {New York},
    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},
    address     = {New York},
    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},
    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},
    address     = {Boston},
    year        = 1990,
    edition     = {1st},
}

@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},
}

@inproceedings {Qin18,
    author      = {Henry Qin and Qian Li and Jacqueline Speiser and Peter Kraft and John Ousterhout},
    title       = {Arachne: Core-Aware Thread Management},
    booktitle   = {13th {USENIX} Symp. on Oper. Sys. Design and Impl. ({OSDI} 18)},
    year        = {2018},
    address     = {Carlsbad, CA},
    pages       = {145-160},
    publisher   = {{USENIX} Association},
    note        = {\href{https://www.usenix.org/conference/osdi18/presentation/qin}{https://\-www.usenix.org/\-conference/\-osdi18/\-presentation/\-qin}},
}

@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},
    address     = {San Francisco},
}

@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{Joung00,
    author      = {Joung, Yuh-Jzer},
    title       = {Asynchronous group mutual exclusion},
    journal     = {Dist. Comput.},
    optjournal  = {Distributed Computing},
    year        = {2000},
    month       = {Nov},
    volume      = {13},
    number      = {4},
    pages       = {189--206},
}

@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

@article{Michael13,
    contributer = {pabuhr@plg},
    author      = {Maged M. Michael},
    title       = {The Balancing Act of Choosing Nonblocking Features},
    journal     = cacm,
    volume      = 56,
    number      = 9,
    month       = sep,
    year        = 2013,
    pages       = {46--53},
    publisher   = {ACM},
    address     = {New York, NY, USA},
}

@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.
    }
}

@misc{BoostCoroutines15,
    keywords    = {Boost Coroutine Library},
    contributer = {pabuhr@plg},
    author      = {Oliver Kowalke},
    title       = {Boost Coroutine Library},
    year        = 2015,
    howpublished= {\href{http://www.boost.org/doc/libs/1_61_0/libs/coroutine/doc/html/index.html}
                  {{http://www.boost.org/\-doc/\-libs/1\_61\_0/\-libs/\-coroutine/\-doc/\-html/\-index.html}}},
    optnote     = {Accessed: 2016-09},
}

@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        = {\href{https://plg.uwaterloo.ca/~usystem/theses/KrischerThesis.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-theses/\-KrischerThesis.pdf}},
}

@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},
    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},
    address     = {Englewood Cliffs},
    year        = 1988,
    edition     = {2nd},
    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},
    address     = {Englewood Cliffs},
    year        = 1978,
    edition     = {1st},
}

@manual{ANSI89:C,
    keywords    = {ANSI C 89},
    contributer = {gjditchfield@plg},
    author      = {C90},
    title       = {Programming Languages -- {C}},
    organization= {American National Standards Institute},
    address     = {New York, NY, U.S.A.},
    year        = 1990,
    note        = {ANSI/ISO 9899-1990}
}

@manual{C11,
    keywords    = {ISO/IEC C 11},
    contributer = {pabuhr@plg},
    key         = {C11},
    title       = {C Programming Language {ISO/IEC} 9889:2011-12},
    edition     = {3rd},
    publisher   = {International Standard Organization},
    address     = {\href{https://www.iso.org/standard/57853.html}{https://\-www.iso.org/\-standard/\-57853.html}},
    year        = 2012,
}

@manual{C++Concepts,
    keywords    = {ISO/IEC TS 19217:2015},
    contributer = {a3moss@uwaterloo.ca},
    key         = {Concepts},
    title       = {{C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Programming language -- Extensions for concepts {ISO/IEC} {TS} 19217:2015},
    publisher   = {International Standard Organization},
    address     = {\href{https://www.iso.org/standard/64031.html}{https://\-www.iso.org/\-standard/\-64031.html}},
    year        = 2015,
}

@misc{Cforall,
    contributer = {pabuhr@plg},
    key         = {Cforall},
    author      = {{\textsf{C}{$\mathbf{\forall}$} Features}},
    howpublished= {\href{https://plg.uwaterloo.ca/~cforall/features}{https://\-plg.uwaterloo.ca/\-$\sim$cforall/\-features}},
    optnote     = {Accessed: 2018-01-01},
}

@mastersthesis{Esteves04,
    keywords    = {Cforall, parametric polymorphism, overloading},
    contributer = {pabuhr@plg},
    author      = {Rodolfo Gabriel Esteves},
    title       = {\textsf{C}$\mathbf{\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}},
}

@misc{CFAStackEvaluation,
    contributer = {a3moss@plg},
    author      = {Aaron Moss},
    title       = {\textsf{C}$\mathbf{\forall}$ Stack Evaluation Programs},
    year        = 2018,
    howpublished= {\href{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}{https://cforall.uwaterloo.ca/\-CFAStackEvaluation.zip}},
    optnote     = {[Accessed May 2018]},
}

@article{Moss18,
    keywords    = {type systems, polymorphism, tuples, Cforall},
    contributer = {pabuhr@plg},
    author      = {Aaron Moss and Robert Schluntz and Peter A. Buhr},
    title       = {\textsf{C}$\mathbf{\forall}$ : Adding Modern Programming Language Features to C},
    journal     = spe,
    volume      = 48,
    number      = 12,
    month       = dec,
    year        = 2018,
    pages       = {2111-2146},
    note        = {\href{http://dx.doi.org/10.1002/spe.2624}{http://\-dx.doi.org/\-10.1002/\-spe.2624}},
}

@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},
    address     = {Boston},
    year        = 1991,
    edition     = {2nd},
    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},
    address     = {Boston},
    year        = 1986,
    edition     = {1st},
    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},
    address     = {Boston},
    year        = 1991,
    edition     = {2nd},
}

@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 Longman},
    year        = 1997,
    edition     = {3rd},
}

@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}
}

@inproceedings{Necula02,
    author      = {Necula, George C. and McPeak, Scott and Weimer, Westley},
    title       = {{CCured}: Type-safe Retrofitting of Legacy Code},
    booktitle   = {Proceedings of the 29th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
    series      = {POPL '02},
    year        = {2002},
    location    = {Portland, Oregon},
    pages       = {128-139},
    publisher   = {ACM},
    address     = {New York, NY, USA},
}

@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       = {\textsf{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/\-$\sim$cforall/\-cfa.ps}},
}

@manual{cforall-refrat,
    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},
    address     = {New York},
    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},
    address     = {New York},
    year        = 1981,
    volume      = 114,
    series      = {Lecture Notes in Computer Science}
}

@manual{Cobol14,
    keywords    = {ISO/IEC Cobol 14},
    contributer = {pabuhr@plg},
    author      = {Cobol14},
    title       = {Programming Languages -- {Cobol} ISO/IEC 1989:2014},
    edition     = {2nd},
    institution = {International Standard Organization},
    address     = {\href{https://www.iso.org/standard/51416.html}{https://\-www.iso.org/\-standard/\-51416.html}},
    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''.
    },
}

@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},
    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}
}

@book{CommonLisp,
    keywords    = {common lisp},
    contributer = {pabuhr@plg},
    author      = {Guy Steele},
    title       = {COMMON LISP: The Language},
    publisher   = {Digital Press},
    address     = {New York},
    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},
    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     = {2nd},
    year        = {2006},
    publisher   = {Addison-Wesley Longman Publishing},
    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 Com\-puting},
    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        = {\href{http://plg.uwaterloo.ca/theses/MokThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-MokThesis.pdf}},
}

@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.
    }
}

@misc{NThreadCode13,
    keywords    = {N-thread software-solution mutual exclusion},
    contributer = {pabuhr@plg},
    key         = {concurrent locking},
    author      = {Peter A. Buhr and David Dice and Wim H. Hesselink},
    title       = {concurrent-locking},
    howpublished= {\href{https://github.com/pabuhr/concurrent-locking}{https://\-github.com/\-pabuhr/\-concurrent-locking}},
    optnote     = {[Accessed April 2017]},
}

@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},
    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},
}

@manual{uC++,
    keywords    = {C++, concurrency, light-weight process, shared memory},
    contributer = {pabuhr@plg},
    key         = {uC++},
    author      = {Peter A. Buhr},
    title       = {$\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Annotated Reference Manual, Version 7.0.0},
    organization= {University of Waterloo},
    month       = sep,
    year        = 2018,
    note        = {\href{https://plg.uwaterloo.ca/~usystem/pub/uSystem/uC++.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-pub/\-uSystem/uC++.pdf}},
}

@book{Burns93,
    keywords    = {concurrency, Pascal},
    contributer = {pabuhr@plg},
    author      = {Alan Burns and Geoff Davies},
    title       = {Concurrent Programming},
    publisher   = {Addison Wesley Longman},
    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},
    address     = {Boston},
    year        = 1997,
    edition     = {1st},
}

@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     = {1st},
}

@book{Lea00,
    keywords    = {concurrency, Java},
    contributer = {pabuhr@plg},
    author      = {Doug Lea},
    title       = {Concurrent Programming in {J}ava: Design Principles and Patterns},
    publisher   = {Addison-Wesley},
    address     = {Boston},
    year        = 2000,
    edition     = {2nd},
}

@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},
    address     = {Summit},
    year        = 1989,
}

@mastersthesis{Sun15,
    author      = {Sun, Xianda},
    title       = {Concurrent High-performance Persistent Hash Table In {J}ava},
    school      = {School of Computer Sc., University of Waterloo},
    year        = 2015,
    optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
    note        = {\href{https://uwspace.uwaterloo.ca/handle/10012/10013}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-10013}},
}

@book{Andrews91:book,
    keywords    = {concurrency},
    contributer = {pabuhr@plg},
    author      = {Gregory R. Andrews},
    title       = {Concurrent Programming: Principles and Practice},
    publisher   = {Benjamin/Cummings Publish\-ing},
    address     = {Redwood City},
    year        = 1991,
}

@article{Buhr05a,
    keywords    = {concurrency, myths},
    contributer = {pabuhr@plg},
    author      = {Peter A. Buhr and Ashif S. Harji},
    title       = {Concurrent Urban Legends},
    journal     = ccpe,
    month       = aug,
    year        = 2005,
    volume      = 17,
    number      = 9,
    pages       = {1133-1172},
}

@mastersthesis{Delisle18,
    keywords    = {concurrency, Cforall},
    contributer = {pabuhr@plg},
    author      = {Thierry Delisle},
    title       = {Concurrency in \textsf{C}$\mathbf{\forall}$},
    school      = {School of Computer Science, University of Waterloo},
    year        = 2018,
    optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
    note        = {\href{https://uwspace.uwaterloo.ca/handle/10012/12888}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-12888}},
}

@article{Delisle18b,
    keywords    = {concurrency, Cforall},
    contributer = {pabuhr@plg},
    author      = {Thierry Delisle and Peter A. Buhr},
    title       = {Concurrency in \textsf{C}$\mathbf{\forall}$},
    year        = 2018,
    journal     = spe,
    pages       = {1-32},
    note        = {submitted},
}

@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     = {2nd},
}

@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},
    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},
    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.
    }
}

@misc{Taylor10,
    keywords    = {const, poisoning},
    contributer = {pabuhr@plg},
    author      = {Ian Lance Taylor},
    title       = {const},
    month       = oct,
    year        = 2010,
    howpublished= {\href{https://www.airs.com/blog/archives/428}
                  {https://www.airs.com/\-blog/\-archives/\-428}},
    optnote     = {Accessed: 2018-05},
}

@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,
}

@unpublished{Ditchfield:conversions,
    contributer = {a3moss@uwaterloo.ca},
    author      = {Glen Ditchfield},
    title       = {Conversions for \textsf{C}$\mathbf{\forall}$},
    note        = {\href{http://plg.uwaterloo.ca/~cforall/Conversions/index.html}{http://\-plg.uwaterloo.ca/\-$\sim$cforall/\-Conversions/\-index.html}},
    month       = {Nov},
    year        = {2002},
    urldate     = {28 July 2016},
}

@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},
    address     = {New York},
    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,
}

@misc{CS343,
    keywords    = {uC++ teaching},
    contributer = {pabuhr@plg},
    key         = {Peter Buhr},
    title       = {CS343},
    year        = 2018,
    howpublished= {\href{https://www.student.cs.uwaterloo.ca/~cs343}{https://\-www.student.cs.uwaterloo.ca/\-$\sim$cs343}},
}

@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{Galil91,
    keywords    = {union-find},
    contributer = {a3moss@uwaterloo.ca},
    title       = {Data structures and algorithms for disjoint set union problems},
    author      = {Galil, Zvi and Italiano, Giuseppe F},
    journal     = {ACM Computing Surveys (CSUR)},
    volume      = 23,
    number      = 3,
    pages       = {319--344},
    year        = 1991,
    publisher   = {ACM},
}

@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},
    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     = ccpe,
    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},
}

@book{Aho74,
    keywords    = {algorithms, textbook, union-find},
    contributer = {a3moss@uwaterloo.ca},
    title       = {The Design and Analysis of Computer Algorithms},
    author      = {Aho, Alfred V and Hopcroft, John E and Ullman, Jeffrey D},
    year        = {1974},
    publisher   = {Addison-Wesley},
    address     = {Reading, MA, USA}
}

@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},
    address     = {Boston},
    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},
    address     = {Englewood Cliffs},
    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},
    address     = {Boston},
    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     = joop,
    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},
    address     = {Englewood Cliffs},
    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},
    address     = {Englewood Cliffs},
    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@plg},
    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},
    address     = {Englewood Cliffs},
    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@plg},
    key         = {Erlang},
    title       = {Erlang/OTP System Documentation 8.1},
    organization= {Erlang AB},
    month       = sep,
    year        = 2016,
    note        = {\href{http://erlang.org/doc/pdf/otp-system-documentation.pdf}{http://\-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}
}

@inproceedings{XaaS,
    keywords    = {Everything as a Service, Anything as a Service, Cloud computing, SOA},
    contributer = {pabuhr@plg},
    author      = {Duan, Yucong and Fu, Guohua and Zhou, Nianjun and Sun, Xiaobing and Narendra, Nanjangud C. and Hu, Bo},
    title       = {Everything As a Service (XaaS) on the Cloud: Origins, Current and Future Trends},
    booktitle   = {Proceedings of the 2015 IEEE 8th International Conference on Cloud Computing},
    series      = {CLOUD'15},
    year        = {2015},
    pages       = {621--628},
    publisher   = {IEEE Computer Society},
    address     = {Washington, DC, USA},
}

@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},
    address     = {London},
    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,
    publisher   = {ACM},
    address     = {New York, NY, USA},
    volume      = 20,
    number      = 10,
    month       = oct,
    year        = 1985,
    pages       = {95-104},
}

@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.
    }
}

@misc{GCCExtensions,
    contributer = {a3moss@uwaterloo.ca},
    key         = {C Extensions},
    author      = {{C Extensions}},
    title       = {Extensions to the {C} Language Family},
    year        = 2014,
    howpublished= {\href{https://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/C-Extensions.html}{https://\-gcc.gnu.org/\-onlinedocs/\-gcc-4.7.2/\-gcc/\-C\-Extensions.html}},
    optnote     = {Accessed: 2017-04-02},
}

@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}
}

@inproceedings{Patwary10,
    keywords    = {union-find},
    contributer = {a3moss@uwaterloo.ca},
    author      = {Patwary, Md. Mostofa Ali and Blair, Jean and Manne, Fredrik},
    editor      = {Festa, Paola},
    title       = {Experiments on Union-Find Algorithms for the Disjoint-Set Data Structure},
    booktitle   = {Experimental Algorithms},
    year        = 2010,
    publisher   = {Springer Berlin Heidelberg},
    address     = {Berlin, Heidelberg},
    pages       = {411--423},
    isbn        = {978-3-642-13193-6}
}

% 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},
    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},
}

@article{Hesselink17,
    keywords    = {concurrency, mutual exclusion, performance experiment, software solutions},
    title       = {Fast mutual exclusion by the {T}riangle algorithm},
    author      = {Wim H. Hesselink and Peter A. Buhr and David Dice},
    journal     = ccpe,
    volume      = 30,
    number      = 4,
    year        = 2018,
    month       = feb,
    publisher   = {John Wiley \& Sons},
    note        = {\href{https://doi.org/10.1002/cpe.4183}{https://\-doi.org/\-10.1002/\-cpe.4183}}
}

@article{Yang95,
    keywords    = {software solutions, N-thread, mutual exclusions},
    contributer = {pabuhr@plg},
    author      = {Jae-Heon Yang and James H. Anderson},
    title       = {A Fast, Scalable Mutual Exclusion Algorithm},
    journal     = {Distributed Computing},
    publisher   = {Springer-Verlag},
    volume      = {9},
    number      = {1},
    year        = {1995},
    pages       = {51-60},
}

@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},
    author      = {Fortran08},
    title       = {Programming Languages -- {Fortran} Part 1:Base Language ISO/IEC 1539-1:2010},
    edition     = {3rd},
    publisher   = {International Standard Organization},
    address     = {\href{https://www.iso.org/standard/50459.html}{https://\-www.iso.org/\-standard/\-50459.html}},
    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}
}

@misc{Sutter05c,
    contributer = {pabuhr@plg},
    title       = {The Free Lunch Is Over: A Fundamental Turn Toward Concurrency in Software},
    author      = {Herb Sutter},
    howpublished= {\url{http://www.gotw.ca/publications/concurrency-ddj.htm}},
    year        = {2005},
    note        = {originally Dr. Dobb's Journal 30(3)},
}

@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},
    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},
    address     = {Boston},
    year        = 1973,
    volume      = 1,
    edition     = {2nd},
}

@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}
}

@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.
    }
}

@unpublished{Bilson,
    keywords    = {generic programming, generics, polymorphism},
    contributor = {a3moss@plg},
    author      = {Richard C. Bilson and Glen Ditchfield and Peter A. Buhr},
    title       = {Generic Programming with Inferred Models},
}

@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{GMP,
    keywords    = {GMP arbitrary-precision library},
    contributer = {pabuhr@plg},
    key         = {GMP},
    title       = {{GNU} Multiple Precision Arithmetic Library},
    address     = {GNU},
    year        = 2016,
    note        = {\href{https://gmplib.org}{https://\-gmplib.org}},
}

@manual{Go,
    keywords    = {Go programming language},
    contributer = {pabuhr@plg},
    author      = {Robert Griesemer and Rob Pike and Ken Thompson},
    title       = {{Go} Programming Language},
    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.},
}

@misc{GObject,
    keywords    = {GObject},
    contributor = {a3moss@uwaterloo.ca},
    key         = {GObject},
    organization= {The {GNOME} Project},
    title       = {{GO}bject Reference Manual},
    year        = 2014,
    howpublished= {https://developer.gnome.org/gobject/stable/},
    optnote     = {Accessed: 2017-04},
}

@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

@manual{Haskell10,
    keywords    = {Haskell},
    contributer = {pabuhr@plg},
    author      = {Haskell},
    title       = {Haskell 2010 Language Report},
    edition     = {{S}imon {M}arlow},
    year        = 2010,
    note        = {\href{https://haskell.org/definition/haskell2010.pdf}{https://\-haskell.org/\-definition/\-haskell2010.pdf}},
}

@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},
    address     = {Englewood Cliffs},
    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{Hesselink17b,
    keywords    = {concurrency, mutual exclusion, performance experiment, software solutions},
    title       = {High-Contention Mutual Exclusion by Elevator Algorithms},
    author      = {Peter A. Buhr and David Dice and Wim H. Hesselink},
    journal     = ccpe,
    volume      = 30,
    number      = 18,
    year        = 2018,
    month       = sep,
    publisher   = {John Wiley \& Sons},
    note        = {\href{https://doi.org/10.1002/cpe.4475}{https://\-doi.org/\-10.1002/\-cpe.4475}},
}

@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     = ccpe,
    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     = mathann,
    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},
    address     = {Englewood Cliffs},
    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 \textsf{C}$\mathbf{\forall}$},
    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},
    publisher   = {ACM Press},
    address     = {New York, NY, USA},
}

@article{Galler64,
    keywords    = {union-find, original},
    contributer = {a3moss@uwaterloo.ca},
    title       = {An improved equivalence algorithm},
    author      = {Galler, Bernard A and Fisher, Michael J},
    journal     = {Communications of the ACM},
    volume      = {7},
    number      = {5},
    pages       = {301--303},
    year        = {1964},
    publisher   = {ACM}
}

@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},
}

@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},
    address     = {Boston},
    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},
    address     = {Cambridge},
    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},
    address     = {Boston},
    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},
    address     = {Boston},
    year        = 1990,
    edition     = {2nd},
}

@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{Pharr12,
    title       = {ispc: A {SPMD} compiler for high-performance CPU programming},
    author      = {Pharr, Matt and Mark, William R},
    booktitle   = {Innovative Parallel Computing (InPar), 2012},
    pages       = {1--13},
    year        = {2012},
    month       = may,
    address     = {San Jose, CA, USA},
    publisher   = {IEEE},
}

@inproceedings{DeLozier13,
    keywords    = {C++, local pointers, memory safety, type-safety},
    author      = {DeLozier, Christian and Eisenberg, Richard and Nagarakatte, Santosh and Osera, Peter-Michael and Martin, Milo M.K. and Zdancewic, Steve},
    title       = {{I}ronclad {C++}: A Library-augmented Type-safe Subset of {C++}},
    booktitle   = {Proceedings of the 2013 ACM SIGPLAN International Conference on Object Oriented Programming Systems Languages \& Applications},
    series      = {OOPSLA'13},
    year        = {2013},
    address     = {Indianapolis, Indiana, USA},
    pages       = {287-304},
    publisher   = {ACM},
}

@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},
    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},
    address     = {Reading},
    year        = 2000,
    edition     = {2nd},
}

@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       = {{Java} Language Specification},
    publisher   = {Oracle},
    year        = 2015,
    edition     = {{J}ava {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}{http://docs.oracle.com/\-javase/7/\-docs/\-api/\-java/\-util/\-concurrent/\-package-summary.html}},
}

% K

@inproceedings{Buhr96b,
    author      = {Peter A. Buhr and Martin Karsten and Jun Shih},
    title       = {{\small\textsf{KDB}}: A Multi-threaded Debugger for Multi-threaded Applications},
    booktitle   = {Proc. of SPDT'96: SIGMETRICS Symp. on Parallel and Distributed Tools},
    publisher   = {ACM Press},
    address     = {Philadelphia, Pennsylvania, U.S.A.},
    month       = may,
    year        = 1996,
    pages       = {80-87},
}

@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     = mathann,
    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},
    address     = {Belmont},
    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/\-$\sim$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        = {\href{https://plg.uwaterloo.ca/~usystem/pub/uSystem/uSystem.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-pub/\-uSystem/\-uSystem.pdf}},
}

@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},
    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},
    address     = {Boston},
    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},
    address     = {Englewood Cliffs},
    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}{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}{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

@techreport{Drepper03,
    keywords    = {NPTL, threading, 1:1 model},
    contributer = {pabuhr@plg},
    author      = {Ulrich Drepper and Ingo Molnar},
    title       = {The Native POSIX Thread Library for Linux},
    institution = {Red Hat},
    year        = 2003,
    note        = {\href{http://www.cs.utexas.edu/~witchel/372/lectures/POSIX_Linux_Threading.pdf}{http://www.cs.utexas.edu/\-$\sim$witchel/\-372/\-lectures/\-POSIX\_Linux\_Threading.pdf}},
}

@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},
    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},
    note        = {\href{http://doc.cat-v.org/bell_labs/new_c_compilers/new_c_compiler.pdf}{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{Anderson01,
    keywords    = {software solutions, fast path},
    contributer = {pabuhr@plg},
    author      = {James H. Anderson and Yong-Jik Kim},
    title       = {A New Fast-Path Mechanism For Mutual Exclusion},
    journal     = {Distributed Computing},
    month       = jan,
    year        = 2001,
    volume      = 14,
    number      = 1,
    pages       = {17-29},
}

@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},
}

@book{NeWS,
    AUTHOR      = {James Gosling and David S. H. Rosenthal and Richelle J. Arden},
    TITLE       = {The {NeWS} Book},
    PUBLISHER   = {Springer-Verlag},
    YEAR        = {1989}
}

@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},
}

@misc{nginx,
    key         = {nginx},
    author      = {{NGINX}},
    howpublished= {\href{https://www.nginx.com}{https://\-www.nginx.com}},
}

@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/\-$\sim$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},
    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},
    address     = {Boston},
    year        = 1986
}

@misc{obj-c-book,
    keywords    = {objective-c},
    contributor = {pabuhr@plg},
    key         = {Objective-C},
    author      = {Objective-C},
    publisher   = {Apple Inc.},
    year        = 2014,
    howpublished= {\href{https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC}{https://\-developer.apple.com/\-library/archive/\-documentation/\-Cocoa/\-Conceptual/\-ProgrammingWithObjectiveC}},
    optnote     = {Accessed: 2018-03}
}

@misc{xcode7,
    keywords    = {objective-c},
    contributor = {a3moss@uwaterloo.ca},
    key         = {Xcode},
    title       = {{X}code 7 Release Notes},
    year        = 2015,
    howpublished= {\href{https://developer.apple.com/library/content/documentation/Xcode/Conceptual/RN-Xcode-Archive/Chapters/xc7_release_notes.html}{https://\-developer.apple.com/\-library/\-content/\-documentation/\-Xcode/\-Conceptual/\-RN-Xcode-Archive/\-Chapters/\-xc7\_release\_notes.html}},
    optnote     = {Accessed: 2017-04}
}

@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},
    address     = {Boston},
    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},
    address     = {Englewood Cliffs},
    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},
    address     = {London},
    edition     = {2nd},
    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{Baker82,
    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}.
        }
}

@manual{OpenMP,
    keywords    = {concurrency, openmp, spmd},
    contributer = {pabuhr@plg},
    key         = {OpenMP},
    title       = {OpenMP Application Program Interface, Version 4.5},
    month       = nov,
    year        = 2015,
    note        = {\href{https://www.openmp.org/wp-content/uploads/openmp-4.5.pdf}{https://\-www.openmp.org/\-wp-content/\-uploads/\-openmp-4.5.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},
    address     = {Englewood Cliffs},
    year        = 2004,
    edition     = {3rd},
}

@book{Stalling98,
    keywords    = {concurrency, operating systems},
    contributer = {pabuhr@plg},
    author      = {William Stallings},
    title       = {Operating Systems: Internals and Design Principles},
    publisher   = {Prentice-Hall},
    address     = {Englewood Cliffs},
    year        = 1998,
    edition     = {3rd},
}

@book{Stalling01,
    keywords    = {concurrency, operating systems},
    contributer = {pabuhr@plg},
    author      = {William Stallings},
    title       = {Operating Systems: Internals and Design Principles},
    publisher   = {Prentice-Hall},
    address     = {Englewood Cliffs},
    year        = 2001,
    edition     = {4th},
}

@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},
    address     = {Boston},
    year        = 1991,
    edition     = {3rd},
}

@book{Tanenbaum87,
    keywords    = {concurrency, operating systems},
    contributer = {pabuhr@plg},
    author      = {Andrew S. Tanenbaum},
    title       = {Operating Systems : Design and Implementation},
    publisher   = {Prentice-Hall},
    address     = {Englewood Cliffs},
    series      = {Software Series},
    year        = 1987,
}

@book{Hansen73,
    keywords    = {monitors},
    contributer = {pabuhr@plg},
    author      = {Per {Brinch Hansen}},
    title       = {Operating System Principles},
    publisher   = {Prentice-Hall},
    address     = {Englewood Cliffs},
    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},
    address     = {Englewood Cliffs},
    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{Ganzinger80,
    contributer = {a3moss@uwaterloo.ca},
    author      = {Ganzinger, Harald and Ripken, Knut},
    title       = {Operator Identification in {ADA}: Formal Specification, Complexity, and Concrete Implementation},
    journal     = {SIGPLAN Notices},
    issue_date  = {February 1980},
    volume      = {15},
    number      = {2},
    month       = feb,
    year        = {1980},
    issn        = {0362-1340},
    pages       = {30--42},
    numpages    = {13},
    url         = {http://doi.acm.org/10.1145/947586.947589},
    doi         = {10.1145/947586.947589},
    publisher   = {ACM},
    address     = {New York, NY, USA}
}

@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     = {1st},
    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},
    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, ISO Pascal Standard},
    publisher   = {Springer--Verlag},
    year        = 1991,
    edition     = {4th},
    note        = {Revised by Andrew B. Mickel and James F. Miner}
}

@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     = {1st},
}

@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     = {1st},
    year        = 1981,
    note        = {Manual SH20-6168-1},
}

@misc{perf,
    contributer = {pabuhr@plg},
    key         = {perf},
    author      = {perf},
    howpublished= {\href{https://perf.wiki.kernel.org/index.php/Tutorial}{https://\-perf.wiki.kernel.org/\-index.php/\-Tutorial}},
}

@misc{Verch12,
    contributer = {pabuhr@plg},
    author      = {Shaun Verch},
    title       = {Performance Analysis of 64-Bit Capriccio},
    month       = may,
    year        = 2012,
    howpublished= {\href{http://cs.brown.edu/research/pubs/theses/masters/2012/verch.pdf}{http://cs.brown.edu/\-research/\-pubs/\-theses/\-masters/\-2012/\-verch.pdf}},
    optnote     = {Accessed: 2013-10-4}
}

@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},
}

@inproceedings{Conchon07,
    keywords    = {persistent array, union-find},
    contributer = {a3moss@uwaterloo.ca},
    title       = {A persistent union-find data structure},
    author      = {Conchon, Sylvain and Filli{\^a}tre, Jean-Christophe},
    booktitle   = {Proceedings of the 2007 workshop on Workshop on ML},
    pages       = {37--46},
    year        = {2007},
    organization= {ACM}
}

@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},
}

@inproceedings{Rafkind09,
    keywords    = {accurate, C programming language, conservative, garbage collection, precise},
    contributer = {pabuhr@plg},
    author      = {Rafkind, Jon and Wick, Adam and Regehr, John and Flatt, Matthew},
    title       = {Precise Garbage Collection for C},
    booktitle   = {Proceedings of the 2009 International Symposium on Memory Management},
    series      = {ISMM '09},
    year        = {2009},
    location    = {Dublin, Ireland},
    pages       = {39-48},
    publisher   = {ACM},
    address     = {New York, NY, USA},
}

@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},
    address     = {Englewood Cliffs},
    year        = 1982,
}

@book{Tennent81,
    author      = {R. D. Tennent},
    title       = {Principles of Programming Languages},
    publisher   = {Prentice-Hall International},
    address     = {Englewood Cliffs},
    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    = {},
}

@inproceedings{Buhr98,
    keywords    = {profiling, monitoring, visualization},
    contributer = {pabuhr@plg},
    author      = {Peter A. Buhr and Robert Denda},
    title       = {{$\mu$Profiler} : Profiling User-Level Threads in a Shared-Memory Programming Environment},
    booktitle   = {Proc. of 2nd Inter. Symp. on Computing in Object-Oriented Parallel Environments},
    series      = {Lecture Notes in Computer Science},
    publisher   = {Springer-Verlag},
    volume      = 1505,
    opteditor   = {Dennis Caromel and Rodney R. Oldehoeft and Marydell Tholburn},
    address     = {Santa Fe, New Mexico, U.S.A.},
    month       = dec,
    year        = 1998,
    pages       = {159-166},
}

@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,
}

@book{Butenhof97,
    keywords    = {PThreads, concurrency},
    contributer = {pabuhr@plg},
    author      = {David R. Butenhof},
    title       = {Programming with {POSIX} Threads},
    publisher   = {Addison-Wesley},
    address     = {Boston},
    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},
    address     = {New York, NY, USA},
    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       = {{C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Programming Language ISO/IEC 14882:1998},
    edition     = {1st},
    publisher   = {International Standard Organization},
    address     = {\href{https://www.iso.org/standard/25845.html}{https://\-www.iso.org/\-standard/\-25845.html}},
    year        = 1998,
}

@manual{C++14,
    keywords    = {ISO/IEC C++ 14},
    contributer = {pabuhr@plg},
    key         = {C++14},
    title       = {{C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Programming Language ISO/IEC 14882:2014},
    edition     = {4th},
    publisher   = {International Standard Organization},
    address     = {\href{https://www.iso.org/standard/64029.html}{https://\-www.iso.org/\-standard/\-64029.html}},
    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},
    address     = {New York},
    year        = 1988,
    edition     = {4th},
    series      = {Texts and Monographs in Computer Science},
}

@manual{Ada,
    keywords    = {Ada, packages, tasks, exceptions},
    contributer = {pabuhr@plg},
    title       = {The Programming Language {Ada}: Reference Manual},
    author      = {Ada},
    organization= {United States Department of Defense},
    edition     = {{ANSI/MIL-STD-1815A-1983}},
    month       = feb,
    year        = 1983,
    note        = {Springer, New York},
}

@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},
    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{Moore75,
    keywords    = {approximation methods, integrated circuits},
    contributer = {pabuhr@plg},
    author      = {Gordon E. Moore},
    title       = {Progress in Digital Integrated Electronics},
    journal     = {Technical Digest, International Electron Devices Meeting, IEEE},
    year        = 1975,
    pages       = {11-13},
}

@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@plg},
    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{Grossman06,
    keywords    = {Cyclone, existential types, polymorphism, type variables},
    contributer = {a3moss@plg},
    author      = {Dan Grossman},
    title       = {Quantified Types in an Imperative Language},
    journal     = toplas,
    issue_date  = {May 2006},
    volume      = {28},
    number      = {3},
    month       = may,
    year        = 2006,
    issn        = {0164-0925},
    pages       = {429-475},
    url         = {http://doi.acm.org/10.1145/1133651.1133653},
    doi         = {10.1145/1133651.1133653},
    acmid       = {1133653},
    publisher   = {ACM},
    address     = {New York, NY, USA},
}

@article{Nakaike15,
    keywords    = {hardware transactional memory},
    contributer = {pabuhr@plg},
    author      = {Nakaike, Takuya and Odaira, Rei and Gaudet, Matthew and Michael, Maged M. and Tomari, Hisanobu},
    title       = {Quantitative Comparison of Hardware Transactional Memory for Blue Gene/Q, zEnterprise {EC12}, {I}ntel Core, and {POWER8}},
    journal     = {SIGARCH Comput. Archit. News},
    volume      = {43},
    number      = {3},
    month       = jun,
    year        = {2015},
    pages       = {144--157},
    publisher   = {ACM},
    address     = {New York, NY, USA},
}

% 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    = {ISO/IEC Ada},
    contributer = {pabuhr@plg},
    author      = {Ada12},
    title       = {Programming languages -- {Ada} ISO/IEC 8652:2012},
    edition     = {3rd},
    publisher   = {International Standard Organization},
    address     = {\href{https://www.iso.org/standard/61507.html}{https://\-www.iso.org/\-standard/\-61507.html}},
    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},
    address     = {Boston},
    year        = 2000,
}

@manual{JavaRT99,
    organization= {Real Time for Java Experts Group},
    address     = {{\small\textsf{http://\-www.rtj.org}}},
    month       = sep,
    year        = 1999,
}

@article{Ronsse03,
    keywords    = {profiling, replay},
    contributer = {pabuhr@plg},
    author      = {Michiel Ronsse and De Bosschere, Koen and Mark Christiaens and Jacques Chassin de Kergommeaux and Dieter Kranzlm\"{u}ller},
    title       = {Record/Replay for Nondeterministic Program Executions},
    journal     = cacm,
    month       = sep,
    year        = 2003,
    volume      = 46,
    number      = 9,
    pages       = {62-67},
}

@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}
}

@mastersthesis{Schuster99,
    author      = {Oliver Schuster},
    title       = {Replay of Concurrent Shared-Memory Programs},
    school      = {Universit\"at Mannheim},
    address     = {Mannheim, Deutschland},
    year        = 1999,
    month       = apr,
    type        = {Diplomarbeit},
    note        = {\href{https://plg.uwaterloo.ca/~usystem/theses/SchusterThesis.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-theses/\-SchusterThesis.pdf}},
}

@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,
}

@mastersthesis{Schluntz17,
    keywords    = {constructors, destructors, tuples},
    author      = {Robert Schluntz},
    title       = {Resource Management and Tuples in \textsf{C}$\mathbf{\forall}$},
    school      = {School of Computer Science, University of Waterloo},
    year        = 2017,
    optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
    note        = {\href{https://uwspace.uwaterloo.ca/handle/10012/11830}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-11830}},
}

@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},
    key         = {Rust},
    title       = {{R}ust Programming Language},
    optaddress  = {Rust Project Developers},
    year        = 2015,
    note        = {\href{https://doc.rust-lang.org/reference.html}{https://\-doc.rust-lang\-.org/\-reference.html}},
}

% S

@manual{Scala,
    keywords    = {Scala programming language},
    contributer = {pabuhr@plg},
    key         = {Scala},
    title       = {{S}cala Language Specification, Version 2.11},
    address     = {\'{E}cole Polytechnique F\'{e}d\'{e}rale de Lausanne},
    year        = 2016,
    note        = {\href{http://www.scala-lang.org/files/archive/spec/2.11}{http://\-www.scala-lang.org/\-files/\-archive/\-spec/\-2.11}},
}

@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},
    note        = {Lecture Notes in Computer Science v. 173},
}

@article{Baker78,
    keywords    = {Algol display, FUNARG's, Lisp 1.5, deep binding, environment trees, multiprogramming, shallow binding},
    contributer = {a3moss@uwaterloo.ca},
    author      = {Baker,Jr., Henry G.},
    title       = {Shallow Binding in Lisp 1.5},
    journal     = {Commun. ACM},
    issue_date  = {July 1978},
    volume      = 21,
    number      = 7,
    month       = jul,
    year        = 1978,
    issn        = {0001-0782},
    pages       = {565--569},
    numpages    = {5},
    url         = {http://doi.acm.org/10.1145/359545.359566},
    doi         = {10.1145/359545.359566},
    acmid       = {359566},
    publisher   = {ACM},
    address     = {New York, NY, USA}
}

@article{Baker91,
    keywords    = {shallow binding, functional arrays},
    contributer = {a3moss@uwaterloo.ca},
    author      = {Baker, Henry G.},
    title       = {Shallow Binding Makes Functional Arrays Fast},
    journal     = {SIGPLAN Not.},
    issue_date  = {Aug. 1991},
    volume      = 26,
    number      = 8,
    month       = aug,
    year        = 1991,
    issn        = {0362-1340},
    pages       = {145--147},
    numpages    = {3},
    url         = {http://doi.acm.org/10.1145/122598.122614},
    doi         = {10.1145/122598.122614},
    acmid       = {122614},
    publisher   = {ACM},
    address     = {New York, NY, USA},
}

@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}{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},
}

@article{Nickolls08,
    author      = {Nickolls, John and Buck, Ian and Garland, Michael and Skadron, Kevin},
    title       = {Scalable Parallel Programming with CUDA},
    journal     = {Queue},
    volume      = {6},
    number      = {2},
    month       = mar,
    year        = 2008,
    pages       = {40-53},
    publisher   = {ACM},
    address     = {New York, NY, USA},
} 

@inproceedings{Leissa14,
    title       = {{S}ierra: a {SIMD} extension for {C}++},
    author      = {Lei{\ss}a, Roland and Haffner, Immanuel and Hack, Sebastian},
    booktitle   = {Proceedings of the 2014 Workshop on Workshop on programming models for SIMD/Vector processing},
    pages       = {17-24},
    year        = {2014},
    organization= {ACM}
}

@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        = {\href{http://www.python.org/peps/pep-0255.html}{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},
}

@article{Pennello80,
    contributer = {a3moss@uwaterloo.ca},
    author      = {Pennello, Tom and DeRemer, Frank and Meyers, Richard},
    title       = {A Simplified Operator Identification Scheme for {Ada}},
    journal     = {SIGPLAN Notices},
    issue_date  = {July-August 1980},
    volume      = {15},
    number      = {7 and 8},
    month       = jul,
    year        = {1980},
    issn        = {0362-1340},
    pages       = {82--87},
    numpages    = {6},
    url         = {http://doi.acm.org/10.1145/947680.947688},
    doi         = {10.1145/947680.947688},
    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     = {2nd},
}

@book{Simula67,
    author      = {O-J Dahl and B. Myhrhaug and K. Nygaard},
    title       = {Simula67 Common Base Language},
    month       = oct,
    year        = 1970,
    publisher   = {Norwegian Com\-puting Center},
    address     = {Oslo Norway},
}

@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},
    address     = {Reading},
    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     = {2nd},
    publisher   = {Prentice-Hall},
    address     = {Englewood Cliffs},
    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}
}

@article{Smith98,
    keywords    = {Polymorphic C},
    contributor = {a3moss@uwaterloo.ca},
    title       = {A sound polymorphic type system for a dialect of {C}},
    author      = {Smith, Geoffrey and Volpano, Dennis},
    journal     = {Science of computer programming},
    volume      = 32,
    number      = {1-3},
    pages       = {49-72},
    year        = {1998},
    publisher   = {Elsevier}
}

@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},
    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},
    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}
}

@misc{Sutter15,
    contributer = {pabuhr@plg},
    author      = {Herb Sutter and Bjarne Stroustrup and Gabriel Dos Reis},
    title       = {Structured bindings},
    issue_date  = {2015-10-14},
    month       = oct,
    year        = 2015,
    pages       = {1-6},
    numpages    = {6},
    howpublished= {\href{http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0144r0.pdf}{http://\-www.open-std.org/\-jtc1/\-sc22/\-wg21/\-docs/\-papers/\-2015/\-p0144r0.pdf}},
}

@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},
    address     = {Boston},
    year        = 1978,
}

@article{Stevens74,
    keywords    = {coupling, cohesion},
    contributer = {pabuhr@plg},
    author      = {W. P. Stevens and and G. J. Myers and L. L. Constantine},
    title       = {Structured Design},
    journal     = ibmsj,
    year        = 1974,
    volume      = 13,
    number      = 2,
    pages       = {115-139},
}

@article{Hansen72b,
    keywords    = {critical region},
    contributer = {pabuhr@plg},
    author      = {Per {Brinch Hansen}},
    title       = {Structured Multiprogramming},
    journal     = cacm,
    volume      = 15,
    number      = 7,
    month       = jul,
    year        = 1972,
    pages       = {574-578},
}

@article{Knuth74,
    keywords    = {structured programming, goto statement},
    contributer = {pabuhr@plg},
    author      = {Donald E. Knuth},
    title       = {Structured Programming with go to Statements},
    journal     = acmcs,
    volume      = 6,
    number      = 4,
    month       = dec,
    year        = 1974,
    pages       = {261-301},
    issn        = {0360-0300},
    doi         = {http://doi.acm.org/10.1145/356635.356640},
    publisher   = {ACM},
    address     = {New York, NY, USA},
}

@article{Lang98,
    keywords    = {real-time, exception handling},
    contributer = {pabuhr@plg},
    author      = {Jun Lang and David B. Stewart},
    title       = {A Study of the Applicability of Existing Exception-Handling Techniques to Component-Based Real-Time Software Technology},
    journal     = toplas,
    month       = mar,
    year        = 1998,
    volume      = 20,
    number      = 2,
    pages       = {274-301},
}

@mastersthesis{Fortier89,
    keywords    = {monitors},
    contributer = {pabuhr@plg},
    author      = {Michel Fortier},
    title       = {Study of Monitors},
    school      = {Department of Computer Science, University of Waterloo},
    year        = 1989,
    address     = {Waterloo, Ontario, Canada, N2L 3G1},
}

@techreport{AmadioCardelli,
    keywords    = {},
    contributer = {gjditchfield@plg},
    author      = {Roberto M. Amadio and Luca Cardelli},
    title       = {Subtyping Recursive Types},
    institution = {Digital Equipment Corporation Systems Research Center},
    year        = 1990,
    address     = {130 Lytton Avenue, Palo Alto, California 94301},
    month       = aug,
    number      = 62,
    summary     = {
        \[ (s \leq t \Rightarrow \alpha \leq \beta) \Rightarrow
               \mu s.\alpha leq \mu t.\beta  \]
        \[ \alpha = C[\alpha] \and \beta = C[\beta] \and C contractive
               \Rightarrow \alpha = \beta \]
        where a type \(\alpha\) is contractive in the type variable \(t\)
        if either \(t\) does not occur free in \(\alpha\), or \(\alpha\)
        can be rewritten via unfolding as a type of the shape
        \(\alpha_1 \rightarrow \alpha_2\), and unfolding rewrites
        \(\mu t.\alpha\) as \([t\leftarrow\mu t.\alpha]\alpha\).  An
        algorithm for finding type contexts \(C\) is given.
    }
}

@techreport{Dijkstra80,
    keywords    = {split binary semaphores, general to binary},
    contributer = {pabuhr@plg},
    author      = {Edsger W. Dijkstra},
    title       = {The Superfluity of the General Semaphore},
    institution = {Nuenen},
    address     = {Netherlands},
    number      = {EWD734},
    month       = apr,
    year        = 1980,
}

@inproceedings{Burns81,
    keywords    = {N-thread software-solution mutual exclusion},
    contributer = {pabuhr@plg},
    author      = {James E. Burns},
    title       = {Symmetry in Systems of Asynchronous Processes},
    booktitle   = {22nd Annual Symposium on Foundations of Computer Science, Nashville, TN, USA},
    year        = 1981,
    month       = oct,
    organization= {IEEE Computer Society},
    address     = {Los Angeles, CA, USA},
    pages       = {169-174},
}

@article{Coffman71,
    keywords    = {deadlock},
    contributer = {pabuhr@plg},
    author      = {E. G. {Coffman, Jr.} and M. J. Elphick and A. Shoshani},
    title       = {System Deadlocks},
    journal     = acmcs,
    volume      = 3,
    number      = 2,
    month       = jun,
    year        = 1971,
    pages       = {67-78},
    publisher   = {ACM Press},
    address     = {New York, NY, USA},
    doi         = {http://doi.acm.org/10.1145/356586.356588},
}

@phdthesis{Holmes99,
    keywords    = {synchronization, inheritance anomaly},
    contributer = {pabuhr@plg},
    author      = {David Holmes},
    title       = {Synchronisation Rings: Composable Synchronisation for Object-Oriented Systems},
    school      = {Department of Computing, Macquarie University},
    month       = oct,
    year        = 1999,
    address     = {Sydney, Australia},
}

@book{Taubenfeld06,
    keywords    = {concurrency, synchronization},
    author      = {Gadi Taubenfeld},
    title       = {Synchronization Algorithms and Concurrent Programming},
    publisher   = {Pearson/Prentice-Hall},
    address     = {Harlow, England},
    year        = 2006,
}

@article{Buhr92b,
    keywords    = {concurrency, exception handling, interventions},
    contributer = {pabuhr@plg},
    author      = {Peter A. Buhr and Hamish I. Macdonald and C. Robert Zarnke},
    title       = {Synchronous and Asynchronous Handling of Abnormal Events in the $\mu${S}ystem},
    journal     = spe,
    volume      = 22,
    number      = 9,
    month       = sep,
    year        = 1992,
    pages       = {735-776},
}

@inproceedings{Greenwald96,
    keywords    = {compare and swap, hardware atomicity},
    contributer = {pabuhr@plg},
    author      = {Michael Greenwald and David Cheriton},
    title       = {The Synergy between Non-blocking Synchronization and Operating System Structure},
    booktitle   = {Proceedings of the Second USENIX Symposium on Operating Systems Design and Implementation},
    organization= {USENIX Association},
    address     = {Seattle, Washington, U.S.A.},
    month       = oct,
    year        = 1996,
    pages       = {123-136},
}

@inbook{SunLWP,
    keywords    = {light-weight processes, threads},
    contributer = {pabuhr@plg},
    key         = {Sun},
    title       = {System Services Overview, Lightweight Processes},
    chapter     = {6},
    pages       = {71-111},
    publisher   = {Sun Microsystems},
    month       = may,
    year        = 1988,
    note        = {available as Part Number: 800-1753-10},
}

@article{Randell75,
    contributer = {pabuhr@plg},
    author      = {Brian Randell},
    title       = {System Structure for Software Fault Tolerance},
    journal     = ieeese,
    volume      = {SE-1},
    number      = 2,
    month       = jun,
    year        = 1975,
    pages       = {220-232},
}

@book{Modula-3,
    keywords    = {language reference manual},
    contributer = {pabuhr@plg},
    author      = {Andrew Birrell and Mark R. Brown and Luca Cardelli and Jim Donahue and Lucille Glassman and John Gutag and Jim Harning and Bill Kalsow and Roy Levin and Greg Nelson},
    title       = {Systems Programming with Modula-3},
    publisher   = {Prentice-Hall},
    address     = {Englewood Cliffs},
    year        = 1991,
    series      = {Prentice-Hall Series in Innovative Technology}
}

% T

@article{Yeager91,
    keywords    = {teaching, concurrency},
    contributer = {pabuhr@plg},
    author      = {Dorian P. Yeager},
    title       = {Teaching Concurrency in the Programming Languages Course},
    journal     = {SIGCSE BULLETIN},
    volume      = 23,
    number      = 1,
    month       = mar,
    year        = 1991,
    pages       = {155-161},
    note        = {The Papers of the Twenty-Second SIGCSE Technical Symposium on Computer Science Education,
                   March. 7--8, 1991, San Antonio, Texas, U.S.A.},
}

@article{ml,
    keywords    = {ML, polymorphism},
    contributer = {gjditchfield@plg},
    author      = {Robin Milner},
    title       = {A Theory of Type Polymorphism in Programming},
    journal     = jcss,
    year        = 1978,
    volume      = 17, pages = {348-375}
}

@book{Thoth,
    keywords    = {messages, concurrency},
    contributer = {pabuhr@plg},
    author      = {D. R. Cheriton},
    title       = {The Thoth System: Multi-Process Structuring and Portability},
    publisher   = {American Elsevier},
    year        = 1982
}

@article{Boehm05,
    keywords    = {concurrency, C++},
    contributer = {pabuhr@plg},
    author      = {Hans-J. Boehm},
    title       = {Threads Cannot be Implemented as a Library},
    journal     = sigplan,
    volume      = 40,
    number      = 6,
    month       = jun,
    year        = 2005,
    pages       = {261-268},
}

@misc{TIOBE,
    contributer = {pabuhr@plg},
    key         = {TIOBE Index},
    author      = {{TIOBE Index}},
    howpublished= {\href{http://www.tiobe.com/tiobe_index}{http://\-www.tiobe.com/\-tiobe\_index}},
    optnote     = {Accessed: 2018-09},
}

@misc{Bumbulis90,
    keywords    = {parameter inference, ForceN},
    contributer = {gjditchfield@plg},
    author      = {Peter Bumbulis},
    title       = {Towards Making Signatures First-Class},
    howpublished= {personal communication},
    month       = sep,
    year        = 1990,
}

@techreport{alphard:preempt,
    keywords    = {},
    contributer = {gjditchfield@plg},
    author      = {Mary Shaw and Wm. A. Wulf},
    title       = {Toward Relaxing Assumptions in Languages and Their Implementations},
    institution = {Carnegie-Mellon University},
    year        = 1980,
    month       = jan,
    note        = {Reprinted in \cite{alphard}.}
}

@inproceedings{Reynolds74,
    keywords    = {universal quantification, typed lambda calculus},
    contributer = {gjditchfield@plg},
    author      = {John C. Reynolds},
    title       = {Towards a Theory of Type Structure},
    booktitle   = {Colloque sur la Programmation},
    year        = 1974,
    pages       = {408-423},
    editor      = {B. Robinet},
    publisher   = {Springer},
    note        = {Lecture Notes in Computer Science, v. 19},
    abstract    = {
        
    }
}

@incollection{Hoare72,
    keywords    = {critical region, concurrency},
    contributer = {pabuhr@plg},
    author      = {C. A. R. Hoare},
    title       = {Towards a Theory of Parallel Programming},
    booktitle   = {Operating Systems Techniques},
    editor      = {C. A. R. Hoare and R. H. Perott},
    publisher   = {Academic Press, New York},
    year        = 1972,
    pages       = {61-71},
}

@inproceedings{Mitchell90,
    keywords    = {polymorphism, lambda calculus, bounded quantification},
    contributer = {gjditchfield@plg},
    author      = {John C. Mitchell},
    title       = {Toward a Typed Foundation for Method Specialization and Inheritance},
    booktitle   = {Conference Record of the Seventeenth Annual ACM Symposium
        on Principles of Programming Languages},
    year        = 1990,
    month       = jan, pages = {109-124},
    organization= {Association for Computing Machinery},
    abstract    = {
        This paper disucsses the phenomenon of {\em method specialization}
        in object-oriented programming languages.  A typed function
        calculus of objects and classes is presented, featuring method
        specialization when methods are added or redefined.  The soundness
        of the typing rules (without subtyping) is suggested by a
        translation into a more traditional calculus with
        recursively-defined record types.  However, semantic questions
        regarding the subtype relation on classes remain open.
    }
}

@article{EL1,
    keywords    = {polymorphism},
    contributer = {pabuhr@plg},
    author      = {B. Wegbreit},
    title       = {The Treatment of Data Types in {EL1}},
    journal     = cacm,
    volume      = 17,
    number      = 5,
    month       = may,
    year        = 1974,
    pages       = {251-264},
}

@mastersthesis{Till89,
    keywords    = {C, multiple return values, tuples},
    contributer = {pabuhr@plg},
    author      = {David W. Till},
    title       = {Tuples In Imperative Programming Languages},
    school      = {Department of Computer Science, University of Waterloo},
    year        = 1989,
    address     = {Waterloo, Ontario, Canada, N2L 3G1},
}

@article{turing:old,
    keywords    = {verification, context conditions, faithful execution},
    contributer = {gjditchfield@plg},
    author      = {R. C. Holt and J. R. Cordy},
    title       = {The Turing Programming Language},
    journal     = cacm,
    year        = 1988,
    month       = dec,
    volume      = 31, number = 12, pages = {1410-1423}
}

@book{Turing,
    keywords    = {verification, context conditions, faithful execution},
    contributer = {pabuhr@plg},
    author      = {R. C. Holt},
    title       = {Turing Reference Manual},
    publisher   = {Holt Software Associates Inc.},
    year        = 1992,
    edition     = {3rd},
}

@techreport{Dijkstra79,
    keywords    = {split binary semaphores},
    contributer = {pabuhr@plg},
    author      = {Edsger W. Dijkstra},
    title       = {A Tutorial on the Split Binary Semaphore},
    institution = {Nuenen},
    address     = {Netherlands},
    number      = {EWD703},
    month       = mar,
    year        = 1979,
}

@book{pldesign,
    keywords    = {},
    editor      = {Anthony I. Wasserman},
    title       = {Tutorial: Programming Language Design},
    publisher   = {Computer Society Press},
    address     = {Los Alamitos},
    year        = 1980
}

@misc{TraceCompass,
    contributer = {pabuhr@plg},
    key         = {Trace Compass},
    author      = {{T}race {C}ompass},
    howpublished= {\href{https://projects.eclipse.org/proposals/trace-compass}{https://\-projects.eclipse.org/\-proposals/\-trace-compass}},
}
 
@article{Leroy00,
    keywords    = {type-systems, exceptions},
    contributer = {pabuhr@plg},
    author      = {Xavier Leroy and Fran\c{c}ois Pessaux},
    title       = {Type-Based Analysis of Uncaught Exceptions},
    journal     = toplas,
    month       = mar,
    year        = 2000,
    volume      = 22,
    number      = 2,
    pages       = {340-377},
    comment     = {
        Argues against declaring exceptions on routine definitions.
    },
}

@article{Cormack90,
    keywords    = {polymorphism},
    contributer = {pabuhr@plg},
    author      = {G. V. Cormack and A. K. Wright},
    title       = {Type-dependent Parameter Inference},
    journal     = sigplan,
    volume      = 25,
    number      = 6,
    month       = jun,
    publisher   = {ACM},
    address     = {New York, NY, USA},
    year        = 1990,
    pages       = {127-136},
    note        = {Proceedings of the ACM Sigplan'90 Conference on Programming Language Design and Implementation
                   June 20-22, 1990, White Plains, New York, U.S.A.},
}

@article{concatenation,
    keywords    = {record concatenation, isa},
    contributer = {gjditchfield@plg},
    author      = {N. Wirth},
    title       = {Type Extensions},
    journal     = toplas,
    volume      = {10},
    number      = {2},
    pages       = {204-214},
    month       = apr, year = 1988,
    comment     = {
        Extended record types add fields to their base record.  Assignment
        truncations.  Pointers can point at extended type instances.  For
        polymorphism, call by value is assignment, and call by reference is
        pointer passing.  Overloading isn't discussed.  Type information
        can be recovered through an ``is'' type test or through type guards
        (casts).  A version of the WITH statement could avoid repeated
        checking.

        Private/public access to record fields can be provided by exporting
        a base type, and using a private extension. Statically allocated
        instances need a compiler hint specifying the maximum size of the
        private type.

        Type checking is cheap (if the creation of pointer values is
        controlled).  Types have type descriptors.  Extension descriptors
        point at their direct base.  Heap objects point at their
        descriptor, and reference parameters are accompanied by type
        descriptor parameters.  ``v is t0'' loops along the chain of
        descriptors.
    }
}

% U

@book{uC++book,
    keywords    = {control structure, concurrency, uC++},
    contributer = {pabuhr@plg},
    author      = {Peter A. Buhr},
    title       = {Understanding Control Flow: Concurrent Programming using $\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    publisher   = {Springer},
    address     = {Switzerland},
    year        = 2016,
}

@article{Cardelli85,
    keywords    = {polymorphism},
    contributer = {pabuhr@plg},
    author      = {Luca Cardelli and Peter Wegner},
    title       = {On Understanding Types, Data Abstractions, and Polymorphism},
    journal     = acmcs,
    month       = dec,
    year        = 1985,
    volume      = 17,
    number      = 4,
    pages       = {471-522},
}

@inproceedings{Wilson92,
    keywords    = {garbage collection survey},
    contributer = {pabuhr@plg},
    author      = {Paul R. Wilson},
    title       = {Uniprocessor Garbage Collection Techniques},
    booktitle   = {Proceedings of the International Workshop on Memory Management},
    location    = {St. Malo, France},
    publisher   = {Springer},
    series      = {Lecture Notes in Computer Science},
    volume      = 637,
    month       = sep,
    year        = {1992},
    pages       = {1-42},
}

@inproceedings{Hewitt73,
    author      = {Carl Hewitt and Peter Bishop and Richard Steiger},
    title       = {A Universal Modular {ACTOR} Formalism for Artificial Intelligence},
    booktitle   = {Proceedings of the 3rd International Joint Conference on Artificial Intelligence},
    address     = {Standford, California, U.S.A.},
    pages       = {235-245},
    month       = aug,
    year        = 1973,
}

@article{Bourne78,
    keywords    = {Shell},
    contributer = {pabuhr@plg},
    author      = {S. R. Bourne},
    title       = {The UNIX Shell},
    journal     = {The Bell System Technical Journal},
    volume      = {57, part 2},
    month       = {July--August},
    year        = 1978,
    pages       = {1971-1990},
}

@inproceedings{Krischer12,
    keywords    = {exception, usability, asynchronous, assertion, injection, logging},
    contributer = {pabuhr@plg},
    author      = {Roy Krischer and Peter A. Buhr},
    title       = {Usability Challenges in Exception Handling},
    booktitle   = {5th International Workshop on Exception Handling (WEH)},
    optorganization= {16th International Symposium on the Foundations of Software Engineering (FSE 16)},
    address     = {Zurich, Switzerland},
    month       = jun,
    year        = 2012,
    pages       = {7-13},
}

@techreport{Harmony,
    keywords    = {messages, concurrency},
    contributer = {pabuhr@plg},
    author      = {W. Morven Gentleman},
    title       = {Using the Harmony Operating System},
    institution = {National Research Council of Canada, Ottawa, Canada},
    number      = {24685},
    month       = may,
    year        = 1985
}

@article{delegation,
    keywords    = {delegation, inheritance, actors},
    contributer = {gjditchfield@plg},
    author      = {Henry Lieverman},
    title       = {Using Prototypical Objects to Implement Shared Behavior in
                  Object Oriented Systems},
    journal     = sigplan,
    month       = nov, year = 1986,
    volume      = 21, number = 11, pages = {214-223}
}

% V

@article{V-Kernel,
    keywords    = {messages, concurrency},
    contributer = {pabuhr@plg},
    author      = {David R. Cheriton},
    title       = {The {V} Distributed System},
    journal     = cacm,
    month       = mar,
    year        = 1988,
    volume      = 31,
    number      = 3,
    pages       = {314-333}
}

@misc{Vala,
    keywords    = {GObject, Vala},
    contributor = {a3moss@uwaterloo.ca},
    key         = {Vala},
    organization= {The {GNOME} Project},
    title       = {{V}ala Reference Manual},
    year        = 2017,
    howpublished= {\url{https://wiki.gnome.org/Projects/Vala/Manual}},
    optnote     = {Accessed: 2017-04}
}

@inproceedings{Amdahl67,
    author      = {Gene M. Amdahl},
    title       = {Validity of the Single Processor Approach to Achieving Large Scale Computing Capabilities},
    booktitle   = {Proceedings of the April 18-20, 1967, Spring Joint Computer Conference},
    series      = {AFIPS '67 (Spring)},
    year        = 1967,
    location    = {Atlantic City, New Jersey},
    pages       = {483--485},
    publisher   = {ACM},
    address     = {New York, NY, USA},
}

@article{Mayer81,
    keywords    = {},
    contributer = {pabuhr@plg},
    author      = {A. J. W. Mayer},
    title       = {Value Receiving Procedures},
    journal     = sigplan,
    volume      = 16,
    number      = 11,
    month       = nov,
    year        = 1981,
    pages       = {30-34},
}

@article{Doran80,
    keywords    = {concurrency, Dekker's Algorithm},
    contributer = {pabuhr@plg},
    author      = {R. W. Doran and L. K. Thomas},
    title       = {Variants of the Software Solution to Mutual Exclusion},
    journal     = ipl,
    month       = jul,
    year        = 1980,
    volume      = 10,
    number      = {4/5},
    pages       = {206-208},
}

@book{VAX,
    keywords    = {VAX, DEC},
    contributer = {pabuhr@plg},
    key         = {VAX},
    title       = {VAX-11 Architecture Reference Manual},
    publisher   = {Digital Press},
    address     = {Bedford},
    month       = may,
    year        = 1982,
}

@book{Kenah88,
    author      = {Lawrence J. Kenah and Ruth E. Goldenberg and Simon F. Bate},
    title       = {{VAX/VMS} Internals and Data Structures Version 4.4},
    publisher   = {Digital Press},
    address     = {Bedford},
    year        = 1988,
}

@article{Hesselink13,
    keywords    = {software solutions, N-thread, mutual exclusions},
    contributer = {pabuhr@plg},
    author      = {Wim H. Hesselink},
    title       = {Verifying a Simplification of Mutual Exclusion by {L}ycklama--{H}adzilacos},
    journal     = {Acta Informatica},
    publisher   = {Springer},
    address     = {New York},
    year        = {2013},
    volume      = {50},
    number      = {3},
    pages       = {199-228},
}

% W

@article{Herlihy91,
    keywords    = {linearization, wait-free synchronization},
    contributer = {pabuhr@plg},
    author      = {Maurice Herlihy},
    title       = {Wait-free Synchronization},
    journal     = toplas,
    volume      = {13},
    number      = {1},
    month       = jan,
    year        = 1991,
    pages       = {124--149},
    numpages    = {26},
    publisher   = {ACM},
    address     = {New York, NY, USA},
}

@inproceedings{vonBehren03,
    keywords    = {threads, events, web server},
    contributer = {pabuhr@plg},
    author      = {Rob von Behren and Jeremy Condit and Eric Brewer},
    title       = {Why Events Are a Bad Idea (for high-concurrency servers)},
    booktitle   = {HotOS IX: The 9th Workshop on Hot Topics in Operating Systems},
    publisher   = {USENIX Association},
    address     = {Lihue, Hawaii, U.S.A.},
    month       = may,
    year        = 2003,
    pages       = {19-24},
}

@techreport{Moss90,
    keywords    = {Swizzling, database},
    contributer = {akgoel@plg},
    author      = {J. Moss},
    title       = {Working with Persistent Objects: To Swizzle or Not to Swizzle},
    institution = {CS Department, University of Massachusetts},
    address     = {},
    number      = {CS 90-38},
    month       = may,
    year        = 1990,
}

@inproceedings{Str:oop,
    keywords    = { },
    contributer = {pabuhr@plg},
    author      = {Bjarne Stroustrup},
    title       = {What is ``Object-Oriented Programming''?},
    booktitle   = {Proceedings of the First European Conference on Object Oriented Programming}, 
    month       = jun,
    year        = 1987
}

@misc{Stroustrup:overloading,
    keywords    = {operator overloading},
    contributer = {pabuhr@plg},
    author      = {Bjarne Stroustrup},
    title       = {Why can't I overload dot, ::, sizeof, etc.?},
    month       = oct,
    year        = 2007,
    howpublished= {{\small\textsf{http://\-www.research.att.com/\-bs/\-bs\_faq2.html\-\#overload-dot}}},
}

@techreport{Gray85,
    keywords    = {fault-tolerant system},
    contributer = {pabuhr@plg},
    author      = {Jim Gray},
    title       = {Why Do Computers Stop and What Can Be Done About It?},
    institution = {Tandem Computers},
    number      = {85.7 PN87614},
    month       = jun,
    year        = 1985,
    note        = {\href{http://www.hpl.hp.com/techreports/tandem/TR-85.7.pdf}{http://www.hpl.hp.com/\-techreports/\-tandem/\-TR-85.7.pdf}},
}

@article{Tarjan84,
    keywords    = {union-find},
    contributer = {a3moss@uwaterloo.ca},
    author      = {Tarjan, Robert E. and van Leeuwen, Jan},
    title       = {Worst-case Analysis of Set Union Algorithms},
    journal     = {J. ACM},
    issue_date  = {April 1984},
    volume      = 31,
    number      = 2,
    month       = mar,
    year        = 1984,
    issn        = {0004-5411},
    pages       = {245--281},
    numpages    = {37},
    url         = {http://doi.acm.org/10.1145/62.2160},
    doi         = {10.1145/62.2160},
    acmid       = {2160},
    publisher   = {ACM},
    address     = {New York, NY, USA},
} 

% X

% Y

% Z

% Cross-referenced entries:

% O

% The SIGPLAN Notices issue should be in a note field, but notes are
% inherited by all refering entries, instead of being held in the
% cross-referenced entry.  Putting it in "publisher" is a kludge, but it
% works.
@proceedings{OOPSLA86,
    contributer = {gjditchfield@plg},
    title       = {{OOPSLA} '86 Conference Proceedings},
    booktitle   = {{OOPSLA} '86 Conference Proceedings},
    year        = 1986,
    editor      = {Norman Meyrowitz},
    publisher   = sigplan,
    organization= {Association for Computing Machinery},
    address     = {Portland, Oregon},
    month       = sep,
}

@proceedings{OOPSLA87,
    contributer = {gjditchfield@plg},
    title       = {{OOPSLA} '87 Conference Proceedings},
    booktitle   = {{OOPSLA} '87 Conference Proceedings},
    year        = 1987,
    editor      = {Norman Meyrowitz},
    publisher   = sigplan,
    organization= {Association for Computing Machinery},
    address     = {Orlando, Florida},
    month       = oct,
}

@proceedings{OOPSLA88,
    contributer = {gjditchfield@plg},
    title       = {{OOPSLA} '88 Conference Proceedings},
    booktitle   = {{OOPSLA} '88 Conference Proceedings},
    year        = 1988,
    editor      = {Norman Meyrowitz},
    publisher   = sigplan,
    organization= {Association for Computing Machinery},
    address     = {San Diego, California},
    month       = sep,
}

@proceedings{OOPSLA89,
    contributer = {gjditchfield@plg},
    title       = {{OOPSLA} '89 Conference Proceedings},
    booktitle   = {{OOPSLA} '89 Conference Proceedings},
    year        = 1989,
    editor      = {Norman Meyrowitz},
    publisher   = sigplan,
    organization= {Association for Computing Machinery},
    address     = {New Orleans, Louisiana},
    month       = oct,
}

@proceedings{OOPSLA90,
    contributer = {gjditchfield@plg},
    title       = {{OOPSLA/ECOOP} '90 Conference Proceedings},
    booktitle   = {{OOPSLA} '90 Conference Proceedings},
    year        = 1990,
    editor      = {Norman Meyrowitz},
    publisher   = sigplan,
    organization= {Association for Computing Machinery},
    address     = {Ottawa, Canada},
    month       = oct,
}

@proceedings{OOPSLA91,
    contributer = {gjditchfield@plg},
    title       = {{OOPSLA} '91 Conference Proceedings},
    booktitle   = {{OOPSLA} '91 Conference Proceedings},
    year        = 1991,
    editor      = {Andreas Paepcke},
    publisher   = sigplan,
    organization= {Association for Computing Machinery},
    address     = {Phoenix, Arizona},
    month       = oct,
}