% Conventions: uncross-referenced entries appear first, then
%    cross-referenced entries.  In both groups, entries are sorted by their
%    title field.  Lines like "% A" exist to speed searches.  The main
%    paper on a language uses the language name as the citation key.  Other
%    papers use ``<language name>:'' as a prefix.  Please consider leaving
%    keyword lists and an abstract or comment for future generations, and
%    put some identification in a contributer field.

%    Predefined journal names:
%  acmcs: Computing Surveys		acta: Acta Infomatica
%  cacm: Communications of the ACM
%  ibmjrd: IBM J. Research & Development ibmsj: IBM Systems Journal
%  ieeese: IEEE Trans. on Soft. Eng.	ieeetc: IEEE Trans. on Computers
%  ieeetcad: IEEE Trans. on Computer-Aided Design of Integrated Circuits
%  ipl: Information Processing Letters	jacm: Journal of the ACM
%  jcss: J. Computer & System Sciences	scp: Science of Comp. Programming
%  sicomp: SIAM J. on Computing		tocs: ACM Trans. on Comp. Systems
%  tods: ACM Trans. on Database Sys.	tog: ACM Trans. on Graphics
%  toms: ACM Trans. on Math. Software	toois: ACM Trans. on Office Info. Sys.
%  toplas: ACM Trans. on Prog. Lang. & Sys.
%  tcs: Theoretical Computer Science
@string{ieeepds="IEEE Transactions on Parallel and Distributed Systems"}
@string{ieeese="IEEE Transactions on Software Engineering"}
@string{spe="Software---\-Practice and Experience"}
@string{sigplan="SIGPLAN Notices"}
@string{joop="Journal of Object-Oriented Programming"}
@string{popl="Conference Record of the ACM Symposium on Principles of Programming Languages"}
@string{osr="Operating Systems Review"}
@string{pldi="Programming Language Design and Implementation"}

% A

@incollection{ABC++,
    keywords	= {concurrency, parallel, distributed, C++},
    contributer	= {pabuhr@plg},
    author	= {William G. O'Farrell and Frank Ch. Eigler and S. David Pullara and Gregory V. Wilson },
    title	= {{ABC}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    editor	= {Gregory V. Wilson and Paul Lu},
    booktitle	= {Parallel Programming in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    publisher	= {MIT Press},
    series	= {Scientific and Engineering Computation Series},
    year	= 1996,
    pages	= {1-42},
}

@techreport{CL90abstract,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {Luca Cardelli and Xavier Leroy},
    title	= {Abstract Types and the Dot Notation},
    institution	= {Systems Research Center},
    year	= 1990,
    address	= {130 Lytton Avenue, Palo Alto, CA  94301},
    number	= 56,
    summary	= {
	The existential types of Mitchell and Plotkin \cite{atet} model
	abstract types, but their ``open'' notation is unlike the usual dot
	notation used in programming languages.  This paper gives
	translations between the ``open'' and ``dot'' forms, and suggests
	extensions for nested and for parameterized abstractions.
    }
}

@article{atet,
    keywords	= {lambda calculus, polymorphism},
    contributer	= {gjditchfield@plg},
    author	= {John C. Mitchell and Gordon D. Plotkin},
    title	= {Abstract Types have Existential Type},
    journal	= toplas,
    year	= 1988,
    month	= jul, volume = 10, number = 3, pages = {470-502},
    abstract	= {
	Abstract data type declarations appear in typed programming
	languages like Ada, Alphard, CLU and ML.  This form of declaration
	binds a list of identifiers to a type with associated operations, a
	composite ``value'' we call a {\em data algebra}.  We use a
	second-order typed lambda calculus SOL to show how data algebras
	may be given types, passed as parameters, and returned as results of
	function calls.  In the process, we discuss the semantics of
	abstract data type declarations and review a connection between
	typed programming languages and constructive logic.
    }
}

@article{alphard:intro,
    keywords	= {encapsulation, data abstraction},
    contributer	= {gjditchfield@plg},
    author	= {Wm. A. Wulf and Ralph L. London and Mary Shaw},
    title	= {Abstraction and Verification in Alphard: Introduction to Language and Methodology},
    journal	= ieeese,
    year	= 1976,
    month	= dec, volume = {SE-2}, number = 4, pages = {253-265},
    note	= {Reprinted in \cite{alphard}.},
    abstract	= {
        Alphard is a programming language whose goals include supporting
	both the development of well-structured programs and the formal
	verification of these programs.  This paper attempts to capture the
	symbiotic influence of these two goals on the design of the
	language.  To that end the language description is interleaved with
	the presentation of a proof technique and discudssion of
	programming methodology.  Examples to illustrate both the language
	and the verification technique are included.
    }
}

@book{Hilfinger83,
    keywords	= {ada},
    author	= {Paul N. Hilfinger},
    title	= {Abstraction Mechanisms and Language Design},
    publisher	= {MIT Press},
    series	= {ACM Distinguished Dissertations},
    year	= 1983,
}

@incollection{Lavender96,
    author	= {R. Greg Lavender and Douglas C. Schmidt},
    chapter	= {Active Object: An Object Behavioral Pattern for Concurrent Programming},
    title	= {Pattern Languages of Program Design 2},
    editor	= {John M. Vlissides and James O. Coplien and Norman L. Kerth},
    year	= 1996,
    pages	= {483-499},
    publisher	= {Addison-Wesley Longman Publishing Co., Inc.},
    address	= {Boston, MA, USA},
}

@article{Nierstrasz87,
    keywords	= {Hybrid, active objects, object-oriented languages,
		  object-based languages, delegation, concurrency},
    contributer	= {pabuhr@plg},
    author	= {O. M. Nierstrasz},
    title	= {Active Objects in {Hybrid}},
    journal	= sigplan,
    volume	= 22,
    number	= 12,
    month	= dec,
    year	= 1987,
    pages	= {243-253},
    note	= {Proceedings of the OOPSLA'87 Conference, Oct. 4--8, 1987, Orlando, Florida},
    abstract	= {
	Most object-oriented languages are strong on reusability or on
	strong-typing, but weak on concurrency.  In response to this gap,
	we are developing {\it Hybrid}, an object-oriented language in which
	objects are the active entities.  Objects in Hybrid are organized
	into {\it domains}, and concurrent executions into {\it activities}.
	All object communications are based on remote procedure calls.
	Unstructured {\it sends\/} and {\it accepts\/} are forbidden.  To
	this the mechanisms of {\it delegation\/} and {\it delay queues\/}
	are added to enable switching and triggering of activities. 
	Concurrent subactivities and atomic actions are provided for 
	compactness and simplicity.  We show how solutions to many important
	concurrent problems [sic], such as pipelining, constraint management
	and ``administration'' can be compactly expressed using these 
	mechanisms.
   },
   comment	= {Mentions Thoth in reference to delegation}
}

@book{Actors,
    keywords	= {actors, concurrency},
    contributer	= {pabuhr@plg},
    author	= {Gul A. Agha},
    title	= {Actors: A Model of Concurrent Computation in Distributed Systems},
    publisher	= {MIT Press, Cambridge, Mass.},
    year	= 1986
}

@article{polymorphImpl,
    keywords	= {Napier88},
    contributer	= {gjditchfield@plg},
    author	= {R. Morrison and A. Dearle and R. C. H. Connor and A. L. Brown},
    title	= {An Ad Hoc Approach to the Implementation of Polymorphism},
    journal	= toplas,
    year	= 1991,
    month	= jul,
    volume	= 13,
    number	= 3,
    pages	= {342-371},
    abstract	= {
	Polymorphic abstraction provides the ability to write programs that
	are independent of the form of the data over which they operate.
	There are a number of different categories of polymorphic
	expression---ad hoc and universal, which includes parametric and
	inclusion---all of which have many advantages in terms of code
	reuse and software economics.  It has proved difficult to provide
	efficient implementations of polymorphism.  Here, we address this
	problem and describe a new technique that can implement all forms
	of polymorphism, use a conventional machine architecture, and
	support nonuniform data representations.  Furthermore, the method
	ensures that any extra cost of implementation applies to
	polymorphic forms only, and allows such polymorphic forms to
	persist over program invocations.
    },
    summary	= {
        They give three ways to implement polymorphism: {\em textual
	polymorphism}, which seems to be template instantiation, {\em
	uniform polymorphism}, which they explain badly, and {\em tagged
	polymorphism}, where object code performs type tests.

	They use first-class procedures to implement polymorphism: routines
	with type parameters are implemented as curried routines that
	return a nested routine that refers to the type parameter.
    }
}

@article{dim:ada,
    keywords	= {Dimensional Analysis, Ada},
    contributer	= {gjditchfield@plg},
    author	= {Paul N. Hilfinger},
    title	= {An {Ada} Package for Dimensional Analysis},
    journal	= toplas,
    month	= apr,
    year	= 1988,
    volume	= 10,
    number	= 2,
    pages	= {189-203},
}

@mastersthesis{Younger91,
    keywords	= {concurrency, C++, postponing requests},
    contributer	= {pabuhr@plg},
    author	= {Brian M. Younger},
    title	= {Adding Concurrency to {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    school	= {University of Waterloo},
    year	= 1991,
    address	= {Waterloo, Ontario, Canada, N2L 3G1},
}

@inproceedings{Buhr92c,
    keywords	= {concurrency},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr and Glen Ditchfield},
    title	= {Adding Concurrency to a Programming Language},
    booktitle	= {USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Technical Conference Proceedings},
    organization= {USENIX Association},
    address	= {Portland, Oregon, U.S.A.},
    month	= aug,
    year	= 1992,
    pages	= {207-224},
}

@article{Buhr89b,
    keywords	= {concurrency, C++},
    contributer	= {pabuhr@plg},
    author	= {P. A. Buhr and Glen Ditchfield and C. R. Zarnke},
    title	= {Adding Concurrency to a Statically Type-Safe Object-Oriented Programming Language},
    journal	= sigplan,
    volume	= 24,
    number	= 4,
    month	= apr,
    year	= 1989,
    pages	= {18-21},
    note	= {Proceedings of the ACM SIGPLAN Workshop on Object-Based Concurrent Programming, Sept. 26--27, 1988, San Diego, California, U.S.A.},
}

@article{Knuth66,
    keywords	= {N-thread software-solution mutual exclusion},
    contributer	= {pabuhr@plg},
    author	= {Donald E. Knuth},
    title	= {Additional Comments on a Problem in Concurrent Programming Control},
    journal	= cacm,
    month	= may,
    year	= 1966,
    volume	= 9,
    number	= 5,
    pages	= {321-322},
    note	= {Letter to the Editor}
}

@article{DeBruijn67,
    keywords	= {N-thread software-solution mutual exclusion},
    contributer	= {pabuhr@plg},
    author	= {Nicolaas Govert de Bruijn},
    title	= {Additional Comments on a Problem in Concurrent Programming Control},
    journal	= cacm,
    month	= mar,
    year	= 1967,
    volume	= 10,
    number	= 3,
    pages	= {137-138},
    note	= {letter to the Editor}
}

@phdthesis{Krischer10,
    author	= {Roy Krischer},
    title	= {Advanced Concepts in Asynchronous Exception Handling},
    school	= {University of Waterloo},
    year	= 2010,
    month	= dec,
    address	= {Waterloo, Ontario, Canada, N2L 3G1},
    optnote	= {\textsf{http://uwspace.uwaterloo.ca/\-bitstream/10012/\-5751\-/1/Krischer\_Roy.pdf}},
    note	= {\href{http://uwspace.uwaterloo.ca/bitstream/10012/5751/1/Krischer_Roy.pdf}{http://uwspace.uwaterloo.ca/\-bitstream/10012/\-5751\-/1/Krischer\_Roy.pdf}},
}

@article{Buhr00a,
    keywords	= {exception handling},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr and W. Y. Russell Mok},
    title	= {Advanced Exception Handling Mechanisms},
    journal	= ieeese,
    volume	= 26,
    number	= 9,
    month	= sep,
    year	= 2000,
    pages	= {820-836},
}

@book{Richter97,
    keywords	= {Win32, threads},
    author	= {Jeffrey M. Richter},
    title	= {Advanced Windows},
    publisher	= {Microsoft Press},
    year	= 1997,
    edition	= {third},
}

@article{Francez77,
    keywords	= {parameter passing, named/positional arguments},
    contributer	= {pabuhr@plg},
    author	= {Nissim Francez},
    title	= {Another Advantage of Key word Notation for Parameter Communication with Subprograms},
    journal	= cacm,
    volume	= 20,
    number	= 8,
    month	= aug,
    year	= 1977,
    pages	= {604-605},
}

@article{Algol60,
    keywords	= {Algol60},
    contributer	= {pabuhr@plg},
    author	= {J. W. Backus and F. L. Bauer and J. Green and C. Katz and
		   J. McCarthy and P. Naur and A. J. Perlis and H. Rutishauser and K. Samuelson
		   and B. Vauquois and J.H. Wegstein and A. van Wijngaarden and M. Woodger},
    title	= {Revised Report on the Algorithmic Language Algol 60},
    editor	= {Peter Nauer},
    journal	= cacm,
    volume	= 6,
    number	= 1,
    month	= jan,
    year	= 1963,
    pages	= {1-17},
}

@article{Mellor-Crummey91,
    keywords	= {spin locks, compare-and-swap, barriers},
    contributer	= {pabuhr@plg},
    author	= {John M. Mellor-Crummey and Michael L. Scott},
    title	= {Algorithm for Scalable Synchronization on Shared-Memory Multiprocessors},
    journal	= tocs,
    volume	= 9,
    number	= 1,
    month	= feb,
    year	= 1991,
    pages	= {21-65},
}

@article{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	= {The MIT Press},
    address	= {Cambridge, Massachusetts},
    series	= {Scientific Computation Series},
    year	= 1986,
    note	= {Translated by D. Beeson},
}

@incollection{Gidenstam05,
    keywords	= {lock free, dynamic memory allocation},
    contributer	= {pabuhr@plg},
    author	= {Anders Gidenstam and Marina Papatriantafilou and Philippas Tsigas},
    title	= {Allocating Memory in a Lock-free Manner},
    editor	= {Gerth St{\o}lting Brodal and Stefano Leonardi},
    booktitle	= {Algorithms -- ESA 2005},
    pages	= {329-342},
    publisher	= {Springer},
    year	= 2005,
    volume	= 3669,
    series	= {Lecture Notes in Computer Science},
}

@book{Sites92,
    keywords	= {computers, Alpha},
    contributer	= {pabuhr@plg},
    editor	= {Richard L. Sites},
    title	= {Alpha Architecture Reference Manual},
    publisher	= {Digital Press, One Burlington Woods Drive, Burlington, MA, U. S. A., 01803},
    year	= 1992,
}

@book{alphard,
    keywords	= {Parametric polymorphism, alphard, iterators, nested types},
    contributer	= {gjditchfield@plg},
    editor	= {Mary Shaw},
    title	= {{ALPHARD}: Form and Content},
    publisher	= {Springer-Verlag},
    year	= 1981,
    comment	= {Collection of papers about Alphard.}
}

@article{Kessels77,
    keywords	= {monitors},
    contributer	= {pabuhr@plg},
    author	= {Joep L. W. Kessels},
    title	= {An Alternative to Event Queues for Synchronization in Monitors},
    journal	= cacm,
    volume	= 20,
    number	= 7,
    month	= jul,
    year	= 1977,
    pages	= {500-503},
    annote	= {
    }
}

@article{descr,
    keywords	= {X2, subclasses, inheritance, parameterized classes},
    contributer	= {gjditchfield@plg},
    author	= {David Sandberg},
    title	= {An Alternative to Subclassing},
    journal	= sigplan,
    volume	= {21},    number = {11},
    pages	= {424-428},
    month	= nov, year = 1986,
    comment	= {
    	The Smalltalk class hierarchy has three uses: factoring out code;
	``Abstraction superclasses'' such as Collection; rapid construction
	of new classes by incremental change.

	``A descriptive class specifies a partial behavior by specifying a
	set of procedure headings that describe what can be done with
	instances of classes that belong to the descriptive class.''  An
	``instance'' statement declares a class to be an instance of a
	descriptive class and defines the correspondence between
	operations.  Procedures with descriptive class parameters take any
	instance as arguments.  Descriptive classes can describe relations
	like ``c is a collection with element type e'', but how such things
	are used isn't explained.
	
	For each descriptive class used in a parameter list, an implicit
	parameter is created that is passed a vector of procedures.
    }
}

@incollection{Matsuoka93,
    keywords	= {inheritance anomaly},
    contributer	= {pabuhr@plg},
    author	= {Satoshi Matsuoka and Akinori Yonezawa},
    title	= {Analysis of Inheritance Anomaly in Object-Oriented Concurrent Programming Languages},
    booktitle	= {Research Directions in Concurrent Object-Oriented Programming},
    editor	= {Gul Agha and Peter Wegner and Akinori Yonezawa},
    publisher	= {MIT Press},
    year	= 1993,
    pages	= {107-150},
}

@article{Sinha00,
    author	= {Saurabh Sinha and Mary Jean Harrold},
    title	= {Analysis and Testing of Programs with Exception-Handling Constructs},
    journal	= ieeese,
    year	= 2000,
    month	= sep,
    volume	= 26,
    number	= 9,
    pages	= {849--871},
}

@inproceedings{Robillard99,
    author	= {Martin P. Robillard and Gail C. Murphy},
    title	= {Analyzing Exception Flow in {J}ava Programs},
    booktitle	= {ESEC/FSE-7: Proceedings of the 7th European Software Engineering Conference held jointly
                   with the 7th ACM SIGSOFT International Symposium on Foundations of Software Engineering},
    year	= 1999,
    pages	= {322--337},
    isbn	= {3-540-66538-2},
    location	= {Toulouse, France},
    doi		= {http://doi.acm.org/10.1145/318773.319251},
    publisher	= {Springer-Verlag},
    address	= {London, UK},
}

@book{C++,
    keywords	= {C++, ANSI},
    author	= {Margaret A. Ellis and Bjarne Stroustrup},
    title	= {The Annotated {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Reference Manual},
    publisher	= {Addison-Wesley},
    year	= 1990,
    edition	= {first},
}

@book{APL,
    keywords	= {APL},
    contributer	= {pabuhr@plg},
    author	= {K. E. Iverson},
    title	= {A Programming Language},
    publisher	= {Wiley, New York},
    year	= 1962
}

@article{PS-Algol:old,
    author	= {M. Atkinson and P. Bailey and K. Chisholm and P. Cockshott and R. Morrison},
    title	= {An Approach to Persistent Programming},
    journal	= {The Computer Journal},
    year	= 1983,
    volume	= 26,
    number	= 4,
    pages	= {360-365},
}

@article{Kessels82,
    keywords	= {concurrency, critical section},
    contributer	= {pabuhr@plg},
    author	= {Joep L. W. Kessels},
    title	= {Arbitration Without Common Modifiable Variables},
    journal	= acta,
    volume	= 17,
    number	= 2,
    month	= jun,
    year	= 1982,
    pages	= {135-141},
}

@article{Buhr95a,
    keywords	= {concurrency, library approach},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr},
    title	= {Are Safe Concurrency Libraries Possible?},
    journal	= cacm,
    month	= feb,
    year	= 1995,
    volume	= 38,
    number	= 2,
    pages	= {117-120},
}

@book{ARMv7,
    key		= {ARM processor},
    title	= {ARM Architecture Reference Manual},
    publisher	= {ARM},
    volume	= {ARM DDI 0406C.b (ID072512)},
    year	= 2012,
}

@book{Herlihy08,
    contributer	= {pabuhr@plg},
    author	= {Herlihy, Maurice and Shavit, Nir},
    title	= {The Art of Multiprocessor Programming},
    year	= 2008,
    isbn	= {0123705916, 9780123705914},
    publisher	= {Morgan Kaufmann Publishers Inc.},
    address	= {San Francisco, CA, USA},
}

@inproceedings{Chung10,
    keywords	= {transactional memory, lock-free programming, x86 architecture},
    contributer	= {pabuhr@plg},
    author	= {Jaewoong Chung and Luke Yen and Stephan Diestelhorst and Martin Pohlack and Michael Hohmuth and David Christie and Dan Grossman},
    title	= {ASF: AMD64 Extension for Lock-Free Data Structures and Transactional Memory},
    booktitle	= {Proceedings of the 2010 43rd Annual IEEE/ACM International Symposium on Microarchitecture},
    series	= {MICRO '43},
    year	= 2010,
    pages	= {39--50},
    numpages	= {12},
    publisher	= {IEEE Computer Society},
    address	= {Washington, DC, USA},
}

@article{Buhr94a,
    keywords	= {assignment, parameter passing, multiple assignment},
    contributer	= {pabuhr@plg},
    author	= {P. A. Buhr and David Till and C. R. Zarnke},
    title	= {Assignment as the Sole Means of Updating Objects},
    journal	= spe,
    month	= sep,
    year	= 1994,
    volume	= 24,
    number	= 9,
    pages	= {835-870},
}

@inproceedings{Krischer08,
    keywords	= {exception handling, asynchronous, blocked tasks},
    contributer	= {pabuhr@plg},
    author	= {Roy Krischer and Peter A. Buhr},
    title	= {Asynchronous Exception Propagation in Blocked Tasks},
    booktitle	= {4th International Workshop on Exception Handling (WEH.08)},
    organization= {16th International Symposium on the Foundations of Software Engineering (FSE 16)},
    address	= {Atlanta, U.S.A},
    month	= nov,
    year	= 2008,
    pages	= {8-15},
}

@article{oop:modpascal,
    keywords	= {ModPascal},
    contributer	= {gjditchfield@plg},
    author	= {Walter G. Olthoff},
    title	= {Augmentation of Object-Oriented Programming by Concepts of Abstract Data Type Theory: The ModPascal Experience},
    journal	= sigplan,
    volume	= 21,
    number	= 11,
    pages	= {429-443},
    month	= nov,
    year	= 1986
}

@inproceedings{Shen91,
    keywords	= {Ada, polymorphism},
    contributer	= {pabuhr@plg},
    author	= {Jun Shen and Gordon V. Cormack},
    title	= {Automatic instantiation in Ada},
    booktitle	= {Proceedings of the ACM Tri-Ada Conference},
    organization= {ACM},
    address	= {San Jose, California, U.S.A},
    month	= oct,
    year	= 1991,
    pages	= {338-346},
}

@article{Havender68,
    keywords	= {deadlock},
    contributer	= {pabuhr@plg},
    author	= {J. W. Havender},
    title	= {Avoiding Deadlock in Multitasking Systems},
    journal	= ibmsj,
    volume	= 7,
    number	= 2,
    year	= 1968,
    pages	= {74-84},
}

% B

@incollection{beta:old,
    keywords	= {beta, patterns, virtual types},
    contributer	= {gjditchfield@plg},
    author	= {Bent Bruun Kristensen and Ole Lehrmann Madsen and Birger M{\o}ller-Pedersen and Kristen Nygaard},
    title	= {The BETA Programming Language},
    booktitle	= {Research Directions in Object-Oriented Programming},
    publisher	= {MIT Press},
    series	= {Computer Systems Series},
    year	= 1987,
    pages	= {7-48},
    editor	= {Bruce Shriver and Peter Wegner}
}

@article{Knudsen87,
    keyword	= {static exception handling mechanism, BETA, sequel},
    contributor	= {wyrmok@plg},
    author	= {J{\o}rgen Lindskov Knudsen},
    title	= {Better Exception Handling in Block Structured Systems},
    journal	= {IEEE Software},
    year	= 1987,
    month	= may,
    volume	= 4,
    number	= 3,
    pages	= {40-49},
    comments	= {
	Going up the call hierarchy to look for a handler does not fit an
        otherwise statically scoped language. Also, not knowing which handler
        to be used when raising an abnormal event is seen as a weakness of the
        (dynamic) exception handling mechanism. Knudsen believed that raising
        an exception should specify the handler for the exception -- the
        handler is chosen when the exception is raised.  However, I don't think
        his scheme can solve the problem, especially with all the callback
        routines commonly found in OO programming.

	BETA exception handling mechanism uses his work as a foundation.
        However, I don't see any benefits BETA has over other language that is
        a direct consequence of Knudsen's work. On the other hand, my knowledge
        on BETA is very limited.
	}
}

@book{BCPL,
    keywords	= {BCPL},
    contributer	= {pabuhr@plg},
    author	= {M. Richards and C. Whitby-Strevens},
    title	= {{BCPL} -- The Language and Its Compiler},
    publisher	= {Cambridge University Press, Cambridge},
    year	= 1979,
}

@incollection{Madsen87,
    keywords 	= {nested classes},
    contributer	= {pabuhr@watmsg},
    author	= {Ole Lehrmann Madsen},
    title	= {Block Structure and Object Oriented Languages},
    booktitle	= {Research Directions in Object-Oriented Programming},
    editor	= {Bruce Shriver and Peter Wegner},
    publisher	= {MIT Press},
    series	= {Computer Systems Series},
    year	= 1987,
    pages	= {113-128}
}

@inproceedings{booleanClasses,
    keywords	= {specifications},
    contributer	= {gjditchfield@plg},
    author	= {David McAllester and Ramin Zabih},
    title	= {Boolean Classes},
    crossref	= "OOPSLA86",
    pages	= {417-423},
    abstract	= {
        We extend the notion of class so that any Boolean combination of
	classes is also a class.  Boolean classes allow greater precision
	and conciseness in naming the class of objects governed a
	particular method [sic].  A class can be viewed as a predicate
	which is either true or false of any given object.  Unlike
	predicates however classes have an inheritance hierarchy which is
	known at compile time.  Boolean classes extend the notion of class,
	making classes more like predicates, while preserving the compile
	time computable inheritance hierarchy.
    },
    comment = {
        Classes are predicates; if object {\tt o} is in class {\tt C}, then
	{\tt C} is true of {\tt o}.  Classes are combined with {\tt :AND},
	{\tt :OR}, and {\tt :NOT}.  Inheritance is treated as implication:
	{\tt (:implies C E)} means that if class {\tt C} is true of {\tt
	o}, class expression {\tt E} is true of {\tt o}, so if {\tt E} is a
	class, it is a superclass of {\tt C}.  Some class expressions, i.e.
	{\tt (:OR c1 c2)}, can't be instantiated.  Others, i.e. {\tt (:NOT
	c)}, can't be given methods or members because almost all classes
	would inherit them, violating modularity.  The rules for spotting
	these problems are complex.  Determining if one class inherits from
	another needs an exponential algorithm.
    }
}

@mastersthesis{Krischer02,
    author	= {Roy Krischer },
    title	= {Bound Exceptions in Object-Oriented Programming Languages},
    school	= {Universit\"at Mannheim},
    address	= {Mannheim, Deutschland},
    year	= 2002,
    month	= oct,
    type	= {Diplomarbeit},
    note	= {{\small\textsf{ftp://\-plg.uwaterloo.ca/\-pub/\-theses/\-KrischerThesis.ps.gz}}},
}

@inproceedings{Buhr03,
    keywords	= {exception handling, bound handler},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr and Roy Krischer},
    title	= {Bound Exceptions in Object Programming},
    booktitle	= {Proceedings of the ECOOP 2003 Workshop on Exception Handling in Object Oriented Systems:
		  Towards Emerging Application Areas and New Programming Paradigms},
    organization= {ECOOP},
    address	= {Darmstadt, Germany},
    month	= jul,
    year	= 2003,
    pages	= {20-26},
}
%    note	= {http://www.cs.umn.edu/research/technical_reports.php/listing/technical_reports.php?page=report&report_id=03-028}

@inproceedings{Buhr06b,
    keywords	= {exception handling, bound exceptions},
    author	= {Peter A. Buhr and Roy Krischer},
    title	= {Bound Exceptions in Object-Oriented Programming},
    editor	= {C. Dony and J. L. Knudsen and A. Romanovsky and A. Tripathi},
    booktitle	= {Advanced Topics in Exception Handling Techniques},
    publisher	= {Springer-Verlag},
    series	= {Lecture Notes in Computer Science},
    volume	= 4119,
    year	= 2006,
    pages	= {1-21}
}

% C

@book{C,
    keywords	= {C},
    contributer	= {pabuhr@plg},
    author	= {Brian W. Kernighan and Dennis M. Ritchie},
    title	= {The {C} Programming Language},
    publisher	= {Prentice Hall},
    year	= 1988,
    edition	= {second},
    series	= {Prentice Hall Software Series},
    comment	= {
	 based on draft-proposed ANSI C
    }
}

@book{C:old,
    keywords	= {C},
    contributer	= {pabuhr@plg},
    author	= {Brian W. Kernighan and Dennis M. Ritchie},
    title	= {The {C} Programming Language},
    publisher	= {Prentice Hall},
    year	= 1978,
    edition	= {first},
}

@manual{ANSI89:C,
    keywords	= {ANSI C 89},
    contributer	= {gjditchfield@plg},
    title	= {American National Standard for Information Systems -- Programming Language -- {C}},
    organization= {American National Standards Institute},
    address	= {1430 Broadway, New York, New York  10018},
    month	= dec,
    year	= 1989,
    note	= {X3.159-1989}
}

@manual{C11,
    keywords	= {ISO/IEC C 11},
    contributer	= {pabuhr@plg},
    key		= {C11},
    title	= {American National Standard Information technology -- Programming Languages -- {C}},
    organization= {International Standard ISO/IEC 9899-2011[2012]},
    publisher   = {International Standard Organization},
    address	= {http://www.iso.org},
    year	= 2012,
}

@mastersthesis{Esteves04,
    keywords	= {Cforall, parametric polymorphism, overloading},
    contributer	= {pabuhr@plg},
    author	= {Rodolfo Gabriel Esteves},
    title	= {C$\forall$, a Study in Evolutionary Design in Programming Languages},
    school	= {School of Computer Science, University of Waterloo},
    year	= 2004,
    address	= {Waterloo, Ontario, Canada, N2L 3G1},
    note	= {\href{http://plg.uwaterloo.ca/theses/EstevesThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-EstevesThesis.pdf}},
}

@inproceedings{c++scheme,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {Vincent F. Russo and Simon M. Kaplan},
    title	= {A {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Interpreter for {S}cheme},
    booktitle	= {Usenix {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Conference},
    year	= 1988,
    pages	= {95-108},
    summary	= {
	The SIOD interpreter for a Scheme subset, written in C, has a
        tagged union representing data objects, and read(), eval(), and
        print() functions that are basically large switch statements that
        switch based on the tag.  The authors rewrote it to use a class
        with virtual read(), eval(), and print() members, without changing
        any algorithms.  The result was more modular, more easily
        extensible, more reliable, and slightly faster.
    },
    comment	= {
        The evidence given is thin.
	}
}

@article{doskernel,
    keywords	= {light weight processes},
    contributer	= {gjditchfield@plg},
    author	= {Tom Green},
    title	= {A {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Multitasking Kernel},
    journal	= {Dr. Dobb's Journal of Software Tools},
    year	= 1989,
    month	= feb, volume = 14, number = 2, pages = {45-51},
    comment	= {
       A light-weight multitasking kernel for MS-DOS.  A task\_control
       object holds task objects, which may block themselves on signal
       objects.  Task switching is normally preemptive, but tasks can turn
       off preemption before calling non-reentrant routines.  Source code
       is given.
    }
}

@inproceedings{Doeppner87,
    keywords	= {concurrency},
    contributer	= {pabuhr@plg},
    author	= {Thomas W. Doeppner and Alan J. Gebele},
    title	= {{C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} on a Parallel Machine},
    booktitle	= {Proceedings and Additional Papers {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Workshop},
    organization= {USENIX Association},
    address	= {Santa Fe, New Mexico, U.S.A},
    month	= nov,
    year	= 1987,
    pages	= {94-107},
}

@book{Lippman91,
    keywords	= {C++},
    contributer	= {pabuhr@plg},
    author	= {Stanley B. Lippman},
    title	= {{C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Primer},
    publisher	= {Addison-Wesley},
    year	= 1991,
    edition	= {second},
    note	= {QA76.73.C15L57},
}

@book{c++:v1,
    keywords	= {C++},
    contributer	= {gjditchfield@plg},
    author	= {Bjarne Stroustrup},
    title	= {The {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Programming Language},
    publisher	= {Addison-Wesley},
    year	= 1986,
    edition	= {first},
    series	= {Addison-Wesley Series in Computer Science}
}

@book{c++:v2,
    keywords	= {C++},
    contributer	= {pabuhr@plg},
    author	= {Bjarne Stroustrup},
    title	= {The {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Programming Language},
    publisher	= {Addison-Wesley},
    year	= 1991,
    edition	= {second},
}

@book{c++:v3,
    keywords	= {C++},
    contributer	= {pabuhr@plg},
    author	= {Bjarne Stroustrup},
    title	= {The {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Programming Language},
    publisher	= {Addison-Wesley},
    year	= 1997,
    edition	= {third},
}

@manual{Csharp,
    keywords	= {C#},
    contributer	= {pabuhr@plg},
    title	= {C\# Language Specification, Standard ECMA-334},
    organization= {ECMA International Standardizing Information and Communication Systems},
    month	= jun,
    year	= 2006,
    edition	= {4th},
}

@article{Buhr85,
    keywords	= {goto, multi-exit loop},
    contributer	= {pabuhr@plg},
    author	= {P. A. Buhr},
    title	= {A Case for Teaching Multi-exit Loops to Beginning Programmers},
    journal	= sigplan,
    volume	= 20,
    number	= 11,
    month	= nov,
    year	= 1985,
    pages	= {14-22}
}

@techreport{cforall-ug,
    keywords	= {cforall, user guide},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr and Glen Ditchfield and David Till and Charles R. Zarnke},
    title	= {\mbox{\mdseries\sffamily C{$\mathbf{\forall}$}}\ Users Guide, Version 0.1},
    institution	= {Department of Computer Science, University of Waterloo},
    address	= {Waterloo, Ontario, Canada, N2L 3G1},
    month	= oct,
    year	= 2001,
    note	= {\href{http://plg.uwaterloo.ca/~cforall/cfa.ps}{http://\-plg.uwaterloo.ca/\-\char`\~cforall/\-cfa.ps}},
}

@manual{cforall,
    keywords	= {polymorphism},
    contributer	= {gjditchfield@plg},
    author	= {Glen Ditchfield},
    title	= {Cforall Reference Manual and Rationale},
    edition	= {Revision 1.82},
    month	= jan,
    year	= 1998,
    note	= {{\small\textsf{ftp://\-plg.uwaterloo.ca/\-pub/\-Cforall/\-refrat.ps.gz}}},
}

@book{Yourdon79,
    keywords	= {software engineering},
    contributer	= {pabuhr@plg},
    editor	= {Edward Nash Yourdon},
    title	= {Classics in Software Engineering},
    publisher	= {Yourdon Press},
    year	= 1979,
}

@inproceedings{Crnogorac98,
    keywords	= {inheritance anomaly},
    contributer	= {pabuhr@plg},
    author	= {Lobel Crnogorac and Anand S. Rao and Kotagiri Ramamohanarao},
    title	= {Classifying Inheritance Mechanisms in Concurrent Object-Oriented Programming},
    editor	= {Eric Jul},
    booktitle	= {{ECOOP}~'98---Object-Oriented Programming},
    series	= {Lecture Notes in Computer Science},
    publisher	= {Springer},
    volume	= 1445,
    year	= 1998,
    pages	= {571-601},
    ISBN	= {3-540-64737-6},
    ISSN	= {0302-9743},
    abstract	= {
	Inheritance is one of the key concepts in object-oriented rogramming. However, the
	usefulness of inheritance in concurrent object-oriented programming is greatly
	reduced by the problem of inheritance anomaly. Inheritance anomaly is manifested
	by undesirable re-definitions of inherited code. The problem is aggravated by the
	lack of a formal analysis, with a multitude of differing proposals and conflicting
	opinions causing the current state of research, and further directions, to be
	unclear. In this paper we present a formal analysis of inheritance anomaly in
	concurrent object-oriented programming. Starting from a formal definition of the
	problem we develop a taxonomy of the anomaly, and use it to classify the various
	proposals. As a result, the major ideas, trends and limitations of the various
	proposals are clearly exposed. Formal analysis of the anomaly and a thorough
	exposition of its causes and implications are the pre-requisites for a successful
	integration of inheritance and concurrency.
    },
}

@book{CLU,
    keywords	= {CLU},
    contributer	= {gjditchfield@plg},
    author	= {Barbara Liskov and Russell Atkinson and Toby Bloom and Eliot
		Moss and J. Craig Schaffert and Robert Scheifler and Alan Snyder},
    title	= {CLU Reference Manual},
    publisher	= {Springer-Verlag},
    year	= 1981,
    volume	= 114,
    series	= {Lecture Notes in Computer Science}
}

@manual{Cobol14,
    keywords	= {ISO/IEC Cobol 14},
    contributer	= {pabuhr@plg},
    key		= {Cobol14},
    title	= {Programming Languages -- {Cobol}},
    edition	= {second},
    organization= {International Standard ISO/IEC 1989:2014},
    publisher   = {International Standard Organization},
    address	= {http://www.iso.org},
    year	= 2014,
}

@article{coagulation,
    keywords	= {register allocation, instruction selection, jello},
    contributer	= {gjditchfield@plg},
    author	= {Michael Karr},
    title	= {Code Generation by Coagulation},
    journal	= sigplan,
    year	= 1984,
    month	= jun, volume = 19, number = 6, pages = {1-12},
    note	= {Proceedings of the ACM SIGPLAN '84 Symposium on Compiler Construction},
    abstract	= {
        This paper describes a new approach to code-generation.  The
	central tenet is that there must be a more intimate coupling
	between register allocation and instruction selection than exists
	in present-day technology.  This is achieved by generating code in
	very small regions and gradually coalescing the part of the program
	that is ``compiled''.
    },
    comment	= {
        Imagine the program, including the subroutines, spread out over a
	table, with the compiler dropping Jello on the parts as they are
	compiled.  At first little drops appear in seemingly random places.
	These get bigger and combine with other drops to form growing
	globs.  When two globs meet, ripples will go out through each as
	they adjust to each other's presence, although the parts of the
	globs that formed first are less affected by the ripples.  When
	compilation is complete, there is one congealed mass.
    }
}

@article{Soloway83,
    keywords	= {goto, structure programming},
    contributer	= {pabuhr@plg},
    author	= {E. Soloway and J. Bonar and K. Ehrlich},
    title	= {Cognitive Strategies and Looping Constructs: An Empirical Study},
    journal	= cacm,
    month	= nov,
    year	= 1983,
    volume	= 26,
    number	= 11,
    pages	= {853-860},
}

@book{sml:commentary,
    author	= {Robin Milner and Mads Tofte},
    title	= {Commentary on Standard {ML}},
    publisher	= {MIT Press},
    address	= {Cambridge, Massachusetts, U.S.A.},
    year	= 1991
}

@article{Hyman66,
    keywords	= {mutual exclusion, software solution, incorrect},
    contributer	= {pabuhr@plg},
    author	= {Harris Hyman},
    title	= {Comments on a Problem in Concurrent Programming Control},
    journal	= cacm,
    month	= jan,
    year	= 1966,
    volume	= 9,
    number	= 1,
    pages	= {45},
    note	= {Letter to the Editor}
}

@inproceedings{clos,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {Linda G. DeMichiel and Richard P. Gabriel},
    title	= {The Common Lisp Object System: An Overview},
    booktitle	= {ECOOP '87. European Conference on Object-Oriented Programming},
    year	= 1987,
    pages	= {151-170},
    publisher	= {Springer-Verlag}
}

@book{CommonLisp,
    keywords	= {common lisp},
    contributer	= {pabuhr@plg},
    author	= {G. Steele},
    title	= {COMMON LISP: The Language},
    publisher	= {Digital Press},
    year	= 1984
}

@article{CommonLoops,
    author	= {D. Bobrow and K. Kahn and G. Kiczales and L. Masinter and M. Stefik and F. Zdybel},
    title	= {CommonLoops: Merging Common Lisp and Object-Oriented Programming},
    address	= {Portland, Oregon, U.S.A.},
    journal	= {Proc. ACM Conf. on Object-Oriented Systems, Languages and Applications},
    year	= 1986,
    month	= sep,
    pages	= {17-29},
}

@article{co-overview,
    keywords	= {CommonObjects, implementation, encapsulation},
    contributer	= {gjditchfield@plg},
    author	= {Alan Snyder},
    title	= {CommonObjects: An Overview},
    journal	= sigplan,
    year	= 1986,
    month	= oct, volume = 21, number = 10, pages = {19-28},
    note	= {Object Oriented Programming Workshop}
}

@article{CSP,
    keywords	= {CSP, concurrency},
    contributer	= {pabuhr@plg},
    author	= {C. A. R. Hoare},
    title	= {Communicating Sequential Processes},
    journal	= cacm,
    month	= aug,
    year	= 1978,
    volume	= 21,
    number	= 8,
    pages	= {666-677}
}

@book{Hoare85,
    author	= {C. A. R. Hoare},
    title	= {Communicating Sequential Processes},
    year	= 1985,
    isbn	= {0-13-153271-5},
    publisher	= {Prentice-Hall, Inc.},
    address	= {Upper Saddle River, NJ, USA},
    note	= {\href{http://www.usingcsp.com/cspbook.pdf}{http://\-www.usingcsp.com/\-cspbook.pdf}},
}

@article{Hansen72a,
    keywords	= {monitors, automatic signal},
    contributer	= {pabuhr@plg},
    author	= {Per {Brinch Hansen}},
    title	= {A Comparison of Two Synchronizing Concepts},
    journal	= acta,
    volume	= 1,
    year	= 1972,
    pages	= {190-199},
}

@book{Aho06,
    author	= {Alfred V. Aho and Monica S. Lam and Ravi Sethi and Jeffrey D. Ullman},
    title	= {Compilers: Principles, Techniques, and Tools},
    edition	= {second},
    year	= {2006},
    publisher	= {Addison-Wesley Longman Publishing Co., Inc.},
    address	= {Boston, MA, USA},
}

@article{Bacon94,
    keywords	= {parallelizing compiler},
    contributer	= {pabuhr@plg},
    author	= {David F. Bacon and Susan L. Graham and Oliver J. Sharp},
    title	= {Compiler Transformations for High-Performance Computing},
    journal	= acmcs,
    volume	= 26,
    number	= 4,
    month	= dec,
    year	= 1994,
    pages	= {345-420},
}

@inproceedings{Berger01,
    author	= {Emery D. Berger and Benjamin G. Zorn and Kathryn S. McKinley},
    title	= {Composing High-Performance Memory Allocators},
    booktitle	= {{SIGPLAN} Conference on Programming Language Design and Implementation},
    pages	= {114-124},
    year	= 2001,
    url		= {http://citeseer.ist.psu.edu/berger01composing.html}
} 

@article{Andrews83,
    keywords	= {general concurrency},
    contributer	= {pabuhr@plg},
    author	= {Gregory R. Andrews and Fred B. Schneider},
    title	= {Concepts and Notations for Concurrent Programming},
    journal	= acmcs,
    volume	= 15,
    number	= 1,
    month	= mar,
    year	= 1983,
    pages	= {3-43},
}

@mastersthesis{Mok97,
    author	= {Wing Yeung Russell Mok},
    title	= {Concurrent Abnormal Event Handling Mechanisms},
    school	= {University of Waterloo},
    year	= 1997,
    month	= sep,
    address	= {Waterloo, Ontario, Canada, N2L 3G1},
    note	= {{\small\textsf{ftp://\-plg.uwaterloo.ca/\-pub/\-theses/\-MokThesis.ps.gz}}},
}

@article{Gehani86,
    keywords	= {Concurrent programming, C, Distributed systems, rendezvous},
    contributer	= {dgharriss@plg},
    author	= {N. H. Gehani and W. D. Roome},
    title	= {{Concurrent C}},
    journal	= spe,
    volume	= 16,
    number	= 9,
    month	= sep,
    year	= 1986,
    pages	= {821-844},
    abstract	= {
	Our objective is to enhance C so that it can be used to write
	concurrent programs that can run efficiently on both single computers
	and multicomputers.  Our concurrent programming extensions to C are
	based on the {\it rendezvous\/} concept.  These extensions include
	mechanisms for the declaration and creation of processes, for process
	synchronization and interaction, for process termination and abortion.
	We give a rationale for our decisions and compare Concurrent C
	extensions with the concurrent programming facilities in Ada.
	Concurrent C has been implemented on the UNIX system running on a 
	single processor.  A distributed version of Concurrent C is being
	implemented.
   },
   comment	= {
	Select with guarded and screened accepts.  Typed processes.
	Process-valued expressions and process variables.  Processes have
	execution priority: Create {\em process-type-name}(args) [with
	priority(p)], 
	and the priority can be changed on the fly.  Complicated guard/
	screen structure on accept: accept {\em transaction}(param names)
	[suchthat (exp)] [by (exp)] [compoundstatement].  Accepts cannot
	appear in functions!  Can specify timeouts on transaction calls.
	Code examples: buffer process, dining philosophers, lock manager.
	Section on diffs between Concurrent C and Ada.
   }
}

@article{ConcurrentC++,
    keywords	= {concurrency, C++},
    contributer	= {pabuhr@plg},
    author	= {N. H. Gehani and W. D. Roome},
    title	= {Concurrent {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}: Concurrent Programming with Class(es)},
    journal	= spe,
    month	= dec,
    year	= 1988,
    volume	= 18,
    number	= 12,
    pages	= {1157-1177}
}

@article{Courtois71,
    keywords	= {reader and writer, p and v},
    contributer	= {pabuhr@plg},
    author	= {P. J. Courtois and F. Heymans and D. L. Parnas},
    title	= {Concurrent Control with Readers and Writers},
    journal	= cacm,
    volume	= 14,
    number	= 10,
    month	= oct,
    year	= 1971,
    pages	= {667-668},
    annote	= {
		Many errors in the two solutions.
    }
}

@incollection{Reppy93,
    keywords	= {ML, concurrency, continuation passing},
    contributer	= {pabuhr@plg},
    author	= {John H. Reppy},
    title	= {Concurrent {ML}: Design, Application and Semantics},
    booktitle	= {Functional Programming, Concurrency, Simulation and Automated Reasoning},
    editor	= {P. E. Lauer},
    pages	= {165-198},
    publisher	= {Springer-Verlag},
    address	= {Berlin, DE},
    year	= 1993,
    ISBN	= {3-540-56883-2},
    abstract	= {
	Concurrent ML (CML) is a high-level language for concurrent
	programming. It is an extension of Standard ML (SML) and is implemented
	on top of Standard ML of New Jersey (SML/NJ). CML is a practical
	language and is being used to build real systems. It demonstrates that
	one need not sacrifice high-level notation in order to have good
	performance. CML is also a well-defined language. In the tradition of
	SML, it has a formal semantics and its type-soundness has been
	proven.},
    note	= {
	Proceedings of International Lecture Series 1991-92, McMaster
	UniversityLecture Notes in Computer Science 693.},
}

@article{BLASE-2,
    keywords	= {concurrency, BLASE-2},
    contributer	= {pabuhr@plg},
    author	= {Piyush Mehrotra and John Van Rosendale},
    title	= {Concurrent Object Access in BLASE~2},
    journal	= sigplan,
    volume	= 24,
    number	= 4,
    month	= apr,
    year	= 1989,
    pages	= {40-42},
    note	= {Proceedings of the ACM SIGPLAN Workshop on Object-Based Concurrent Programming,
		   Sept. 26--27, 1988, San Diego, California, U.S.A},
}

@techreport{Kafura88,
    keywords	= {objects, concurrency},
    contributer	= {pabuhr@plg},
    author	= {Dennis Kafura},
    title	= {Concurrent Object-Oriented Real-Time Systems Research},
    institution	= {Department of Computer Science, Virginia Polytechnic},
    number	= {TR 88-47},
    year	= 1988
}

@article{Buhr92a,
    keywords	= {C++, concurrency, light-weight process, shared memory},
    contributer	= {pabuhr@plg},
    author	= {P. A. Buhr and Glen Ditchfield and R. A. Stroobosscher and B. M. Younger and C. R. Zarnke},
    title	= {$\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}: Concurrency in the Object-Oriented Language {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    journal	= spe,
    volume	= 22,
    number	= 2,
    month	= feb,
    year	= 1992,
    pages	= {137-172},
}

@techreport{uC++,
    keywords	= {C++, concurrency, light-weight process, shared memory},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr},
    title	= {$\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Annotated Reference Manual, Version 6.1.0},
    institution	= {School of Computer Science, University of Waterloo},
    address	= {Waterloo, Ontario, Canada, N2L 3G1},
    month	= jul,
    year	= 2015,
    note	= {\href{http://plg.uwaterloo.ca/~usystem/pub/uSystem/u++-6.1.0.sh}{\textsf{http://plg.uwaterloo.ca/\-$\sim$usystem/\-pub/\-uSystem/\-u++-6.1.0.sh}}},
}

@book{Burns93,
    keywords	= {concurrency, Pascal},
    contributer	= {pabuhr@plg},
    author	= {Alan Burns and Geoff Davies},
    title	= {Concurrent Programming},
    publisher	= {Addison-Wesley},
    year	= 1993,
}

@article{Hansen73a,
    keywords	= {monitors},
    contributer	= {pabuhr@plg},
    author	= {Per {Brinch Hansen}},
    title	= {Concurrent Programming Concepts},
    journal	= spe,
    month	= dec,
    year	= 1973,
    volume	= 5,
    number	= 4,
    pages	= {223-245},
}

@book{Lea97,
    keywords	= {concurrency, Java},
    contributer	= {pabuhr@plg},
    author	= {Doug Lea},
    title	= {Concurrent Programming in {J}ava: Design Principles and Patterns},
    publisher	= {Addison-Wesley},
    year	= 1997,
    edition	= {first},
}

@book{Hartley98,
    keywords	= {concurrency, Java},
    contributer	= {pabuhr@plg},
    author	= {Stephen J. Hartley},
    title	= {Concurrent Programming: The {J}ava Programming Language},
    publisher	= {Oxford University Press},
    year	= 1998,
    edition	= {first},
}

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

@book{ConcurrentC,
    keywords	= {concurrency, C},
    contributer	= {pabuhr@plg},
    author	= {N. H. Gehani and W. D. Roome},
    title	= {The {Concurrent C} Programming Language},
    publisher	= {Silicon Press, NJ},
    year	= 1989,
}

@book{Andrews91:book,
    keywords	= {concurrency},
    contributer	= {pabuhr@plg},
    author	= {Gregory R. Andrews},
    title	= {Concurrent Programming: Principles and Practice},
    publisher	= {Benjamin/Cummings Publishing Company, Inc., Redwood City, California},
    year	= 1991,
}

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

@techreport{Buhr90,
    keywords	= {objects, concurrency},
    contributer	= {gjditchfield@plg},
    author	= {P. A. Buhr and G. J. Ditchfield and B. M. Younger and C. R. Zarnke}, 
    title	= {Concurrency in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    institution	= {Department of Computer Science, University of Waterloo},
    address	= {Waterloo, Ontario, Canada, N2L 3G1},
    number	= {CS-90-18},
    month	= may,
    year	= 1990
}

@book{Burns98,
    keywords	= {concurrency, Ada},
    author	= {Alan Burns and Andy Wellings},
    title	= {Concurrency in {Ada}},
    publisher	= {Cambridge University Press},
    year	= 1998,
    edition	= {second},
}

@book{Bernstein93,
    keywords	= {concurrency},
    author	= {Arthur J. Bernstein and Philip M. Lewis},
    title	= {Concurrency in Programming and Database Systems},
    publisher	= {Jones and Bartlett},
    year	= 1993,
}

@inproceedings{Pitman01,
    keywords	= {LISP, exception handling},
    contributer	= {pabuhr@plg},
    author	= {Kent M. Pitman},
    title	= {Condition Handling in the Lisp Language Family},
    booktitle	= {Exception Handling},
    publisher	= {Springer-Verlag},
    volume	= 2022,
    series	= {LNCS},
    year	= 2001,
    pages	= {39-59}
}

@inbook{enhancement,
    keywords	= {bounded polymorphism, Comandos},
    contributer	= {gjditchfield@plg},
    author	= {Chris Horn},
    title	= {Conformace, Genericity, Inheritance and Enhancement},
    pages	= {223-233},
    publisher	= {Springer-Verlag},
    year	= 1987,
    volume	= 276,
    series	= "Lecture Notes in Computer Science",
    note	= "ECOOP '87 European Conference on Object-Oriented Programming",
    summary	= {
	Considers effect of conformance on Meyer's conclusions in
	\cite{polymorphism}.

	Implementing a swap function as a member of a type {\cd Swappable}
	with {\cd in out Top} parameters doesn't work, because conformance
	requires arguments to be of type {\cd Top}.

	An enhancive type has a type parameter, bounded by some type, and
	defines members.  Types conforming to the bound can be passed as
	arguments to create types with the extra members.  The signature of
	the enhanced type is based on the signature of the argument, not the
	bound, as if enhancive types were macros.  Hence enhanced types do not
	necessarily conform to each other.  Types conforming to the bound
	conform to enhanced types, which allows new functions to be applied
	to old types.

	Enhancive types are not generic types.  If the argument is omitted,
	the bound is used as a default.  Assignment of enhanced types to
	default-enhanced types is allowed (enhanced types conform to the
	default-enhanced type).  This is (probably) statically type-safe,
	because arguments must conform to the bound, and the new members
	only use operations defined for the bound.

	With facilities for member renaming and deletion, enhancive types
	provide the equivalent of constrained generic types.
    }
}

@phdthesis{Ditchfield92,
    keywords	= {C, parametric polymorphism, overloading},
    contributer	= {pabuhr@plg},
    author	= {Glen Jeffrey Ditchfield},
    title	= {Contextual Polymorphism},
    school	= {Department of Computer Science, University of Waterloo},
    year	= 1992,
    address	= {Waterloo, Ontario, Canada, N2L 3G1},
    note	= {\href{http://plg.uwaterloo.ca/theses/DitchfieldThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-DitchfieldThesis.pdf}}
}

@inproceedings{frameworks:HHG90,
    keywords	= {formal},
    contributer	= {pabuhr@plg},
    author	= {Richard Helm and Ian M. Holland and Dipayan Gangopadhyay},
    title	= {Contracts: Specifying Behavioural Compositions in Cbject-Oriented Systems},
    booktitle	= {Proceedings of ACM Symposium on Object-Oriented Programming: Systems, Languages and Applications},
    year	= 1990,
    pages	= {169-180},
}

@article{Wand80,
    keywords	= {concurrency, continuation},
    contributer	= {pabuhr@plg},
    author	= {Mitchell Wand},
    title	= {Continuation-Based Multiprocessing},
    publisher	= {The Lisp Conference},
    journal	= {Conference Record of the 1980 Lisp Conference},
    pages	= {19-28},
    year	= 1980,
}

@article{Hieb90,
    keywords	= {continuations, concurrency},
    contributer	= {pabuhr@plg},
    author	= {Robert Hieb and R. Kent Dybvig},
    title	= {Continuations and Concurrency},
    journal	= sigplan,
    volume	= 25,
    number	= 3,
    month	= mar,
    year	= 1990,
    pages	= {128-136},
    note	= {Proceedings of the Second ACM SIGPLAN Symposium on Principles \& Practise of Parallel Programming,
		   March. 14--16, 1990, Seattle, Washington, U.S.A},
}

@inproceedings{Haynes84,
    keywords	= {continuations, coroutines, Scheme},
    contributer	= {pabuhr@plg},
    author	= {Christopher T. Haynes and Daniel P. Friedman and Mitchell Wand},
    title	= {Continuations and Coroutines},
    booktitle	= {Conference Record of the 1984 {ACM} Symposium on Lisp and Functional Programming},
    organization= {Association for Computing Machinery},
    month	= aug,
    year	= 1984,
    pages	= {293-298},
    abstract	= {
	The power of first class continuations is demonstrated by implementing
	a variety of coroutine mechanisms using only continuations and
	functional abstraction. The importance of general abstraction
	mechanisms such as continuations is discussed.},
}

@inproceedings{Zahn74,
    keywords	= {goto, structured programming},
    contributer	= {pabuhr@plg},
    author	= {C. T. Zahn},
    title	= {Control Statement for Natural Top-down Structured Programming},
    booktitle	= {Symposium on Programming Languages},
    address	= {Paris, France},
    year	= 1974,
}

@techreport{Dijkstra65,
    keywords	= {concurrency, Dekker's algorithm, semaphores},
    contributer	= {pabuhr@plg},
    author	= {Edsger W. Dijkstra},
    title	= {Cooperating Sequential Processes},
    institution	= {Technological University},
    address	= {Eindhoven, Netherlands},
    year	= 1965,
    note	= {Reprinted in \cite{Genuys68} pp. 43--112.}
}

@book{Marlin80,
    keywords	= {coroutines},
    contributer	= {pabuhr@plg},
    author	= {Christopher D. Marlin},
    title	= {Coroutines: A Programming Methodology, a Language Design and an Implementation},
    publisher	= {Springer-Verlag},
    year	= 1980,
    volume	= 95,
    series	= {Lecture Notes in Computer Science, Ed. by G. Goos and J. Hartmanis}
}
 
@article{Wang71,
    keywords	= {coroutines},
    contributer	= {pabuhr@plg},
    author	= {Arne Wang and Ole-Johan Dahl},
    title	= {Coroutine Sequencing in a Block Structured Environment},
    journal	= "BIT",
    volume	= 11,
    month	= nov,
    year	= 1971,
    pages	= {425-449},
}
 
@article{Castagna95,
    keywords	= {type-systems, covariance, contravariance},
    contributer	= {pabuhr@plg},
    author	= {Giuseppe Castagna},
    title	= {Covariance and Contravariance : Conflict without a Cause},
    journal	= toplas,
    volume	= 17,
    number	= 3,
    month	= may,
    year	= 1995,
    pages	= {341-447},
}

@book{Fischer88,
    keywords	= {compiler construction},
    author	= {Charles N. Fischer and Richard J. {LeBlanc, Jr.}},
    title	= {Crafting a Compiler},
    publisher	= {Benjamin Cummings},
    year	= 1991,
}

@inproceedings{Jim02,
    keywords	= {C dialect, parametric polymorphic, safe memory allocation},
    contributer	= {pabuhr@plg},
    author	= {Trevor Jim and Greg Morrisett and Dan Grossman and Michael Hicks and James Cheney and and Yanling Wang},
    title	= {{C}yclone: A Safe Dialect of {C}},
    booktitle	= {USENIX Annual Technical Conference},
    organization= {USENIX Association},
    address	= {Monterey, California, U.S.A.},
    month	= jun,
    year	= 2002,
    pages	= {275-288},
}

% D

@manual{D,
    keywords	= {D programming language},
    contributer	= {pabuhr@plg},
    title	= {{D} Programming Language},
    author	= {Walter Bright and Andrei Alexandrescu},
    organization= {Digital Mars},
    year	= 2016,
    note	= {\href{http://dlang.org/spec/spec.html}{http://\-dlang.org/\-spec/\-spec.html}},
}

@techreport{Cui90,
    keywords	= {exception handling},
    contributer	= {pabuhr@plg},
    author	= {Qian Cui},
    title	= {Data-Oriented Exception Handling},
    institution	= {Department of Computer Science, University of Maryland},
    address	= {College Park, Maryland, U.S.A., 20742},
    number	= {CS-TR-2384},
    month	= jan,
    year	= 1990,
}

@article{Cui92,
    contributer	= {rkrische@plg},
    author	= {Qian Cui and John Gannon},
    title	= {Data-oriented Exception Handling},
    journal	= {IEEE Transactions on Software Engineering},
    month	= may,
    year	= 1992,
    volume	= 18,
    number	= 5,
    pages	= {393-401},
}

@manual{SIMULA87,
    keywords	= {Simula standard},
    contributer	= {gjditchfield@plg},
    title	= {Databehandling -- Programspr{\aa}k -- {SIMULA}},
    organization= {Standardiseringskommissionen i Sverige},
    note	= {Svensk Standard SS 63 61 14},
    year	= 1987,
    abstract	= {
        Standard for the programming language SIMULA.  Written in English.
    }
}

@article{Liskov75,
    keywords	= {abstract data types, encapsulation, verification},
    contributer	= {gjditchfield@plg},
    author	= {Barbara H. Liskov},
    title	= {Data Types and Program Correctness},
    journal	= sigplan,
    year	= 1975,
    month	= jul,
    volume	= 10,
    number	= 7,
    pages	= {16-17},
    summary	= {
        Type definitions should contain the implementation of the type and
	its operations.  The grouping makes programs simpler and more
	understandable.  Encapsulating the definition aids verification and
	forces a precise specification of the interface.
    }
}

@article{dtav,
    keywords	= {Russell, types},
    contributer	= {gjditchfield@plg},
    author	= {James Donahue and Alan Demers},
    title	= {Data Types are Values},
    journal	= toplas,
    month	= jul,
    year	= 1985,
    volume	= 7,
    number	= 3,
    pages	= {426-445},
    comment	= {
        Data types are sets of operations providing interpretations of
	values from a meaningless, typeless universal value space.  Types
	and operations are also contained in this value space.

	Functions returning types replace generic types.

	Polymorphic functions have type parameters.  Evaluation is not
	macro expansion:
	\begin{verbatim}
	    R == func [n:val integer; T:type[]] val integer
	        {if n > 0 => r[n-1, Array[1,10,T]] # n <= 0 => 17 fi}
	\end{verbatim}
    }
}

@article{Holt72,
    keywords	= {concurrency, deadlock},
    contributer	= {pabuhr@plg},
    author	= {Richard C. Holt},
    title	= {Some Deadlock Properties of Computer Systems},
    journal	= acmcs,
    volume	= 4,
    number	= 3,
    month	= sep,
    year	= 1972,
    pages	= {179-196},
}

@misc{debug-malloc,
    keywords	= {memory allocation debugger},
    contributer	= {gjditchfield@plg},
    author	= {Conor P. Cahill},
    title	= {debug\_malloc},
    howpublished= {comp.sources.unix, volume 22, issue 112},
    abstract	= {
	This package is a collection of routines which are a drop-in
	replacement for the malloc(3), memory(3), string(3), and bstring(3)
	library functions.
    }
}

@book{sml,
    keywords	= {},
    contributer	= {pabuhr@plg},
    author	= {Robin Milner and Mads Tofte and Robert Harper},
    title	= {The Definition of Standard {ML}},
    publisher	= {MIT Press},
    address	= {Cambridge, Massachusetts, U.S.A.},
    year	= 1990
}

@techreport{sml:old,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {Robert Harper and Robin Milner and Mads Tofte},
    title	= {The Definition of Standard {ML}, Version 2},
    institution	= {Department of Computer Science, University of Edinburgh},
    year	= 1988,
    address	= {The King's Buildings, Edinburgh EH9 3JZ},
    type	= {LFCS Report Series}, month = aug, number = {ECS-LFCS-88-62}
}

@inproceedings{Reynolds72,
    keywords	= {continuation},
    contributer	= {pabuhr@plg},
    author	= {John Reynolds},
    title	= {Definitional Interpreters for Higher Order Programming Languages},
    booktitle	= {ACM Conference Proceedings},
    organization= {ACM},
    year	= 1972,
    pages	= {717-740}
}

@article{Buhr16,
    keywords	= {Dekker's algorithm, software solution, mutual exclusion, performance experiment},
    author	= {Peter A. Buhr and David Dice and Wim H. Hesselink},
    title	= {Dekker's Mutual Exclusion Algorithm Made RW-Safe},
    journal	= {Concurrency and Computation: Practice and Experience},
    volume	= 28,
    number	= 1,
    pages	= {144-165},
    month	= jan,
    year	= 2016,
}

@misc{steelman,
    keywords	= {Ada},
    contributer	= {gjditchfied@plg},
    author	= {High Order Language Working Group},
    title	= {Department of Defense Requirements for High Order Computer Programming Languages},
    month	= jun, year = 1978,
    note	= {Reprinted in \cite{pldesign}.}
}

@incollection{Tsay98,
    keywords	= {local spins, mutual exclusion, read/write atomicity, refinement, scalability},
    author	= {Yih-Kuen Tsay},
    title	= {Deriving a scalable algorithm for mutual exclusion},
    booktitle	= {Distributed Computing},
    editor	= {Shay Kutten},
    volume	= {1499},
    series	= {LNCS},
    publisher	= {Springer},
    address	= {Berlin Heidelberg},
    year	= {1998},
    pages	= {393-407},
}

@article{Conway63,
    keywords	= {coroutine, original},
    contributer	= {pabuhr@plg},
    author	= {Melvin E. Conway},
    title	= {Design of a Separable Transition-Diagram Compiler},
    journal	= cacm,
    month	= jul,
    year	= 1963,
    volume	= 6,
    number	= 7,
    pages	= {396-408},
}

@book{Stroustrup94,
    keywords    = {C++},
    contributor = {wyrmok@plg},
    author      = {Bjarne Stroustrup},
    title       = {The Design and Evolution of {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    publisher   = {Addison-Wesley},
    year        = 1994
}

@inproceedings{st:concurrent,
    keywords	= {concurrency, Smalltalk, futures},
    contributer	= {gjditchfield@plg},
    author	= {Yasuhiko Yokote and Mario Tokoro},
    title	= {The Design and Implementation of {ConcurrentSmalltalk}},
    crossref	= "OOPSLA86",
    pages	= {331-340},
    comment	= {
	Objects are ordinary Smalltalk objects or ``atomic'' objects, which
	process messages one at a time in FIFO order.  Asynchronous method
	calls are made by appending ``\&'' at the call site.  The sender does
	not wait for a reply.  If the method returns a value, it
	(immediately?) returns a CBox object, which is like a future.  The
	sender can send the ``receive'' message to the CBox, which blocks
	until the CBox contains a value.

	A method can execute the ``\verb|^|'' statement to return an object
	and terminate, or it can execute ``\verb|^^|'' to return an object
	and continue execution.  If ``\verb|^^foo|'' is executed after
	``\verb|^^bar|'', foo is discarded, since bar has already been
	returned.

	The article does not say whether asynchronous messages can be sent
	to ordinary objects, or whether ordinary messages can be sent to
	atomic objects.
    }
}

@inproceedings{Ichbiah83,
    keywords	= {Ada, packages, generics},
    contributer	= {gjditchfield@plg},
    author	= {Jean D. Ichbiah},
    title	= {On the Design of {Ada}},
    booktitle	= {Information Processing 83},
    year	= 1983,
    month	= sep, pages = {1-10},
    editor	= {R. E. A. Mason},
    organization= {IFIP},
    publisher = {North-Holland},
    summary = {
        Packages group related declarations or subprograms, and encapsulate
	data types.  Separate interfaces and bodies promotes information
	hiding by removing the need to scan the body, allows the body to be
	confidential, and provides a better specification of the contract
	between client and implementor.  Generics are an efficient way to
	factor out parts of similar definitions.
    }
}

@book{Motet96,
    keywords	= {Ada, exception handling},
    contributer	= {wyrmok@plg},
    author	= {G. Motet and A. Mapinard and J. C. Geoffroy},
    title	= {Design of Dependable {A}da Software},
    publisher	= {Prentice Hall},
    year	= 1996,
}
 
@article{Richardson93,
    keywords	= {C++, persistence, database},
    contributer	= {pabuhr@plg},
    author	= {Joel E. Richardson and Michael J. Carey and Daniel T. Schuh},
    title	= {The Design of the {E} Programming Language},
    journal	= toplas,
    month	= jul,
    year	= 1993,
    volume	= 15,
    number	= 3,
    pages	= {494-534},
}

@article{Hansen81b,
    keywords	= {concurrency, monitor, critical region},
    contributer	= {pabuhr@plg},
    author	= {Per {Brinch Hansen}},
    title	= {The Design of {E}dison},
    journal	= spe,
    volume	= 11,
    number	= 4,
    month	= apr,
    year	= 1981,
    pages	= {363-396},
}

@book{Gamma95,
    keywords	= {design patterns},
    author	= {Erich Gamma and Richard Helm and Ralph Johnson and John Vlissides},
    title	= {Design Patterns: Elements of Reusable Object-Oriented Software},
    publisher	= {Addison-Wesley},
    year	= 1995,
    series	= {Professional Computing Series},
}

@inproceedings{Wirth74,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {Niklaus Wirth},
    title	= {On the Design of Programming Languages},
    booktitle	= {Information Processing 74},
    year	= 1974,
    pages	= {386-393},
    publisher	= {North Holland Publishing Company},
    note	= {Reprinted in \cite{pldesign}.}
}

@techreport{forceone,
    keywords	= {Parametric polymorphism, ForceOne},
    contributer	= {gjditchfield@plg},
    author	= {Andrew K. Wright},
    title	= {Design of the Programming Language {ForceOne}},
    institution	= {University of Waterloo},
    month	= feb, year = 1987,
    number	= {CS-87-10}
}

@techreport{x-2,
    keywords	= {object based},
    contributer	= {gjditchfield@plg},
    author	= {David W. Sandberg},
    title	= {The Design of the Programming Language {X-2}},
    institution	= {Oregon State University},
    year	= 1985,
    address	= {Department of Computer Science, Corvallis, Oregon, 97331},
    number	= {85-60-1}
}

@article{design,
    keywords	= {Smalltalk, designing classes},
    contributer	= {gjditchfield@plg},
    author	= {Ralph E. Johnson and Brian Foote},
    title	= {Designing Reusable Classes},
    journal	= {Journal of Object-Oriented Programming},
    year	= 1988,
    volume	= 1, number = 2, pages = {22-35},
    comment	= {
	Abstract classes represent standard protocols.  ``It is better to
	inherit from an abstract class than from a concrete class''.
	Frameworks are collections of related abstract classes.  Successful
	abstractions are discovered, not designed.

	Protocols: ``If an operation X is implemented by performing a
	similar operation on the components of the receiver, then that
	operation should also be named X''.  Eliminate case analysis by
	creating classes with the same operations.  Create classes to
	represent bundles of parameters.  Shrink methods larger than 30
	lines.

	Hierarchies should be deep and narrow.  Subclasses should be
	specializations.

	Frameworks: split large classes.  Factor implementation differences
	into subcomponents.  Separate methods that do not share instance
	variables into components that reflect the different views of the
	object.  Send messages to components, not self.  Reduce implicit
	parameter passing through instance variables.
    }
}

@article{dim:c++,
    keywords	= {Dimensional Analysis, C++},
    contributer	= {gjditchfield@plg},
    author	= {Robert F. Cmelic and Narain Gehani},
    title	= {Dimensional Analysis with {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    journal	= {IEEE Software},
    month	= may, year = 1988,
    volume	= 5, number = 3, pages = {21-29}
}

@article{Wegner87,
    contributer	= {pabuhr@plg},
    author	= {Peter Wegner},
    title	= {Dimensions of Object--Based Language Design},
    journal	= sigplan,
    volume	= 22,
    number	= 12,
    month	= dec,
    year	= 1987,
    pages	= {168-182},
    note	= {Proceedings of the OOPSLA'87 Conference, Oct. 4--8, 1987, Orlando, Florida},
}

@book{Dijkstra76,
    keywords	= {concurrent assignment},
    author	= {E. W. Dijkstra},
    title	= {A Discipline of Programming},
    publisher	= {Prentice-Hall},
    year	= 1976,
}

@book{Lynch96,
    keywords	= {distributed algorithms},
    author	= {Nancy A. Lynch},
    title	= {Distributed Algorithms},
    publisher	= {Morgan Kaufmann},
    year	= 1996,
}

@book{Tanenbaum02,
    keywords	= {distributed programming},
    author	= {Andrew S. Tanenbaum and Maarten van Steen},
    title	= {Distributed Systems: Principles and Paradigms},
    publisher	= {Prentice-Hall},
    year	= 2002,
}

@inproceedings{Cargill90,
    keywords	= {concurrency},
    contributer	= {pabuhr@plg},
    author	= {Tom A. Cargill},
    title	= {Does {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Really Need Multiple Inheritance?},
    booktitle	= {USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Conference Proceedings},
    organization= {USENIX Association},
    address	= {San Francisco, California, U.S.A.},
    month	= apr,
    year	= 1990,
    pages	= {315-323}
}

@unpublished{Duff83,
    keywords	= {C, switch statement, control flow},
    contributer	= {pabuhr@plg},
    author	= {Tom Duff},
    title	= {Duff's Device},
    month	= nov,
    year	= 1983,
    note	= {\href{http://www.lysator.liu.se/c/duffs-device.html}{http://\-www.lysator.liu.se/\-c/\-duffs-device.html}}
}

@manual{dwarf2,
    keywords    = {Debugging DWARF2 specification},
    contributer = {rkrische@plg},
    title       = {DWARF Debugging Information Format},
    organization= {Unix International Programming Languages SIG},
    publisher   = {Unix International},
    address     = {Waterview Corporate Center, 20 Waterview Boulevard, Parsippany, NJ 07054},
    year        = {1993}
}

@article{classicada,
    keywords	= {Classic Ada},
    contributer	= {gjditchfield@plg},
    author	= {Cameron M. Donaldson},
    title	= {Dynamic Binding and Inheritance in an Object-Oriented {Ada} Design},
    journal	= {Journal of Pascal, {Ada} \& Modula-2},
    year	= 1990,
    month	= {jul/aug}, volume = 9, number = 4, pages = {12-19},
    comment	= {
        Classes are like packages: they can contain subprograms, types,
	variables, generic instantiations, and exceptions.  They can also
	contain class methods, instance methods, and instance variables,
	and define creation and initialization subprograms or methods for
	instances.  Single inheritance provides inheritance of
	implementations. Dynamic binding is done with a {\em send}
	statement that invokes a class or instance method.  A preprocessor
	converts Classic Ada to normal Ada.
    }
}

@article{Costanza03,
    keywords	= {dynamic call},
    contributer	= {pabuhr@plg},
    author	= {Pascal Costanza},
    title	= {Dynamic Scoped Functions as the Essence of {AOP}},
    journal	= sigplan,
    volume	= 38,
    number	= 8,
    month	= aug,
    year	= 2003,
    pages	= {29-35},
}

% E

@inproceedings{Wegbreit71,
    keywords	= {polymorphism},
    contributer	= {pabuhr@plg},
    author	= {B. Wegbreit},
    title	= {The ECL Programming System},
    booktitle	= {Proceedings of AFIPS 1971 FJCC},
    publisher	= {AFIPS Press, vol. 39},
    address	= {Montvale, New Jersey, U.S.A},
    year	= 1971,
    pages	= {253-262},
}

@manual{JavaScript,
    keywords	= {JavaScript},
    contributer	= {pabuhr},
    title	= {ECMAScript 2015 Language Specification {JavaScript}},
    organization= {ECAM International},
    address	= {Rue du Rhone 114, CH-1204 Geneva, Switzerland},
    month	= jun,
    year	= 2015,
    note	= {6th Edition}
}

@inproceedings{Peterson77,
    keywords	= {N-thread software-solution mutual exclusion},
    contributer	= {pabuhr@plg},
    author	= {Gary L. Peterson and Michael J. Fischer},
    title	= {Economical Solutions for the Critical Section Problem in a Distributed System (Extended Abstract)},
    booktitle	= {Proceedings of the Ninth Annual ACM Symposium on Theory of Computing},
    series	= {STOC '77},
    year	= 1977,
    location	= {Boulder, Colorado, USA},
    pages	= {91--97},
    numpages	= {7},
    publisher	= {ACM},
    address	= {New York, NY, USA},
}

@article{Hansen81a,
    keywords	= {concurrency, monitor, critical region},
    contributer	= {pabuhr@plg},
    author	= {Per {Brinch Hansen}},
    title	= {{E}dison---a Multiprocessor Language},
    journal	= spe,
    volume	= 11,
    number	= 4,
    month	= apr,
    year	= {1981},
    pages	= {325-361},
}

@book{Eiffel,
    keywords	= {Eiffel},
    contributer	= {pabuhr@plg},
    author	= {Bertrand Meyer},
    title	= {Eiffel: The Language},
    publisher	= {Prentice-Hall},
    year	= 1992,
    series	= {Prentice Hall Object-Oriented Series},
}

@article{WS:overload,
    keywords	= {compilation},
    contributer	= {gjditchfield@plg},
    author	= {Peter J. L. Wallis and Bernhard W. Silverman},
    title	= {Efficient Implementation of the {Ada} Overloading Rules},
    journal	= ipl,
    year	= 1980,
    month	= apr, volume = 10, number = 3, pages = {120-123},
    comment	= {
        The ``two-pass'' algorithm.  An upward pass over a parse tree
	calculates the set of possible result types of operators.  The
	root must have exactly one type, produced in one way.  A
	downward pass selects the version of the operator that produces the
	desired result type, thus setting the result types of subtrees.
	See \cite{D:overload}.
    }
}

@techreport{Habermann80,
    keywords	= {Ada, threads},
    contributer	= {pabuhr@plg},
    author	= {A. N. Habermann and I. R. Nassi},
    title	= {Efficient Implementation of {Ada} Tasks},
    institution	= {Carnegie-Mellon University},
    number	= {CMU-CS-80-103},
    year	= 1980
}

@article{Emerald,
    keywords	= {concurrency, polymorphism},
    contributer	= {pabuhr@plg},
    author	= {Rajendra K. Raj and Ewan Tempero and Henry M. Levy and Andrew P. Black and Norman C. Hutchinson and Eric Jul},
    title	= {Emerald: A General-Purpose Programming Language},
    journal	= spe,
    month	= jan,
    year	= 1991,
    volume	= 21,
    number	= 1,
    pages	= {91-118}
}

@InProceedings{chambers89a,
    keywords	= {maps, delegation},
    author	= "Craig Chambers and David Ungar and Elgin Lee",
    title	= "An Efficient Implementation of {SELF}, a Dynamically-Typed
		 Object-Oriented Language Based on Prototypes",
    crossref	= "OOPSLA89",
    pages	= {49-70}
}

@article{oop:encapsulation,
    keywords	= {Encapsulation, Inheritance, Subclasses, Multiple Inheritance},
    contributer	= {gjditchfield@plg},
    author	= {Alan Snyder},
    title	= {Encapsulation and Inheritance in Object-Oriented Programming
	Languages},
    journal	= sigplan,
    volume	= {21},    number = {11},
    pages	= {38-45},
    month	= nov, year = 1986,
    comment	= {
	Client, child interfaces should be distinct.  Child interface
	shouldn't grant total access to parent.

	Rules for redefining parent variable name in a child affect
	re-implementation of the parent.

	Inheritance can be a promise to obey the semantics of the parent,
	or code reuse; the two may be contradictory.  Unification
	exposes use of inheritance: a child can not be re-implemented
	without breaking code that assumes that it is a subclass of the
	original parent.  If a class uses the names of its parents'
	ancestors, then inheritance is part of the parent's child
	interface.

	Linearizing a multiple inheritance tree means that a class's use of
	calls on super need to be understood before it is used as a parent.
	Merging repeated ancestors exposes inheritance if an ancestor is
	re-implemented.  Forbidding inheritance of distinct methods with
	the same name exposes implementation of ancestors.  Proposed
	solution treats the set of ancestors as a tree.
    }
}

@article{st:encapsulator,
    keywords	= {encapsulator, Smalltalk, monitor},
    contributer	= {gjditchfield@plg},
    author	= {Geoffrey A. Pascoe},
    title	= {Encapsulators: A New Software Paradigm in Smalltalk-80},
    journal	= sigplan,
    volume	= {21},    number	= {11},
    pages	= {341-346},
    month	= nov, year = 1986,
    comment	= {
	Encapsulators are objects that surround other objects.
	Pre- and post-actions are performed when messages are sent to the
	encapsulated object.  They are created here by sending the message
	object: to an encapsulator class.  Examples given are monitors,
	atomic objects, and Model (for model-view-controller interfaces).

	Encapsulator classes use a family of selectors that the
	encapsulated object will not respond to.  Messages for the
	encapsulated object are passed on by trapping them with the
	doesNotUnderstand method.  Various fiddles were needed when setting
	up the class and metaclass hierarchies.  A few selectors (==,
	class) always directly invoke primitive methods; they can't be
	used.

	Can an encapsulated object be an encapsulator?  Probably, but the
	middle object's selectors are inaccessible.
    }
}

@manual{EPT,
    keywords	= {concurrency, light-weight threads},
    contributer	= {pabuhr@plg},
    key		= {Encore},
    title	= {Encore Parallel Thread Manual, 724-06210},
    organization= {Encore Computer Corporation},
    month	= may,
    year	= 1988,
}

@manual{Erlang,
    keywords	= {Erlang},
    contributer	= {pabuhr},
    title	= {Erlang Reference Manual User's Guide, Vertion 7.0},
    organization= {Erlang/OTP System Documentation},
    address	= {1430 Broadway, New York, New York  10018},
    month	= jun,
    year	= 2015,
    note	= {\href{http://www.erlang.org/doc/pdf/otp-system-documentation.pdf}{\textsf{http://www.erlang.org/\-doc/\-pdf/\-otp-system-documentation.pdf}}},
}

@inproceedings{MH88,
    keywords	= {modules, general sums, general products},
    contributer	= {gjditchfield@plg},
    author	= {John C. Mitchell and Robert Harper},
    title	= {The Essence of {ML}},
    booktitle	= popl,
    year	= 1988,
    pages	= {28-46}
}

@book{LeVerrand,
    keywords	= {},
    author	= {D. Le Verrand},
    title	= {Evaluating {Ada}},
    publisher	= {North Oxford Academic},
    year	= 1985
}

@inproceedings{Bloom79,
    keywords	= {concurrency},
    contributer	= {pabuhr@plg},
    author	= {Toby Bloom},
    title	= {Evaluating Synchronization Mechanisms},
    booktitle	= {Proceedings of the Seventh Symposium on Operating Systems Principles},
    organization= {ACM SIGOPS},
    address	= {Pacific Grove, California, U.S.A},
    month	= dec,
    year	= 1979,
    pages	= {24-32}
}

@article{Buhr06a,
    keywords	= {concurrency, C++, uC++},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr and Richard C. Bilson},
    title	= {Examining $\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} :
		   High-level Object-Oriented Concurrency in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    journal	= {Dr. Dobb's Journal : Software Tools for the Professional Programmer},
    month	= feb,
    year	= 2006,
    volume	= 31,
    number	= 2,
    pages	= {36-40},
}

@article{ExceptionalC,
    keywords	= {exception handling, asynchronous events},
    contributer	= {wyrmok@plg},
    author	= {N. H. Gehani},
    title	= {Exceptional {C} or {C} with Exceptions},
    journal	= spe,
    year	= 1992,
    month	= oct,
    volume	= 22,
    number	= 10,
    pages	= {827-848},
    comment	= {
	It is the most extensive exceptional handling mechanism thus
 	far. Though it doesn't have Mesa resumption, it has
 	asynchronous signal which is more general and abstract than
 	the unix signal mechanism.  It has an Eiffel like retry
 	mechanism. Consequently, the scope of guarded region is not
 	immediately terminated when an exception is raised. In fact,
 	an exception handler creates a scope under its guarded
 	region.
	}
}

@incollection{Buhr02,
    keywords	= {exception handling},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr and Ashif Harji and W. Y. Russell Mok},
    title	= {Exception Handling},
    editor	= {Marvin V. Zelkowitz},
    booktitle	= {Advances in COMPUTERS},
    publisher	= {Academic Press},
    volume	= 56,
    year	= 2002,
    pages	= {245-303},
}

@article{Cargill94,
    keywords	= {exception handling},
    contributer	= {pabuhr@plg},
    author	= {Tom Cargill},
    title	= {Exception Handling: a False Sense of Security},
    journal	= {{C}{\kern-.2em\hbox{\large\texttt{+\kern-.2em+}}} Report},
    year	= 1994,
    month	= nov,
    volume	= 6,
    number	= 9,
    note	= {http://www.informit.com/\-content/\-images/\-020163371x/\-supplements/\-Exception\_\-Handling\_\-Article.\-html}
}

@article{Knudsen84,
    keywords	= {static exception handling, BETA, sequel},
    contributer	= {wyrmok@plg},
    author	= {J{\o}rgen Lindskov Knudsen},
    title	= {Exception Handling --- A Static Approach},
    journal	= spe,
    year	= 1984,
    month	= may,
    volume	= 14,
    number	= 5,
    pages	= {429-449},
}

@article{Drew94,
    keywords	= {exceptions, exception handling},
    contributer	= {wyrmok@plg},
    author	= {Steven J. Drew and K. John Gough},
    title	= {Exception Handling: Expecting the Unexpected},
    journal	= {Computer Languages},
    year	= 1994,
    month	= may,
    volume	= 20,
    number	= 2,
    comment	= {
        A recent and good survey on various exception handling mechanisms found
	in imperative programming languages. It classifies various mechanism in
	terms of flow control and scopes. Asynchronous exceptions and signals
	are also covered as Exceptional C is in the survey.
	}
}

@article{Koenig90,
    keywords	= {exception handling},
    contributer	= {pabuhr@plg},
    author	= {Andrew Koenig and Bjarne Stroustrup},
    title	= {Exception Handling for {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    journal	= joop,
    month	= {July/August},
    year	= 1990,
    volume	= 3,
    number	= 2,
    pages	= {16-33},
}

@article{Lee83,
    keywords	= {exception handling, C},
    contributer	= {pabuhr@plg},
    author	= {P. A. Lee},
    title	= {Exception Handling in {C} Programs},
    journal	= spe,
    volume	= 13,
    number	= 5,
    month	= may,
    year	= 1983,
    pages	= {389-405},
}

@article{Liskov79,
    keywords	= {exception handling},
    contributer	= {pabuhr@plg},
    author	= {Barbara H. Liskov and Alan Snyder},
    title	= {Exception Handling in {CLU}},
    journal	= ieeese,
    month	= nov,
    year	= 1979,
    volume	= {SE-5},
    number	= 6,
    pages	= {546-558},
}

@article{Szalas85,
    keywords	= {concurrency, C++},
    contributer	= {pabuhr@plg},
    author	= {Andrzej Szalas and Danuta Szczepanska},
    title	= {Exception Handling in Parallel Computations},
    journal	= sigplan,
    volume	= 20,
    number	= 10,
    month	= oct,
    year	= 1985,
    issn	= {0362-1340},
    pages	= {95-104},
    url		= {http://doi.acm.org/10.1145/382286.382385},
    doi		= {http://doi.acm.org/10.1145/382286.382385},
    acmid	= {382385},
    publisher	= {ACM},
    address	= {New York, NY, USA},
}

@article{MacLaren77,
    keywords	= {exception handling, PL/I},
    contributer	= {pabuhr@plg},
    author	= {M. Donald MacLaren},
    title	= {Exception Handling in {PL/I}},
    journal	= sigplan,
    volume	= 12,
    number	= 3,
    month	= mar,
    year	= 1977,
    pages	= {101-104},
    note	= {Proceedings of an ACM Conference on Language Design for Reliable Software,
		   March 28--30, 1977, Raleigh, North Carolina, U.S.A.},
}

@article{Goodenough75,
    keywords	= {exception handling},
    contributer	= {pabuhr@plg},
    author	= {J. B. Goodenough},
    title	= {Exception Handling: Issues and a Proposed Notation},
    journal	= cacm,
    month	= dec,
    year	= 1975,
    volume	= 18,
    number	= 12,
    pages	= {683-696},
}

@article{Lampson80,
    keywords	= {monitors},
    contributer	= {pabuhr@plg},
    author	= {B. W. Lampson and D. D. Redell},
    title	= {Experience with Processes and Monitors in Mesa},
    journal	= cacm,
    volume	= 23,
    number	= 2,
    month	= feb,
    year	= 1980,
    pages	= {105-117},
}

@inproceedings{Shopiro87,
    keywords	= {concurrency},
    contributer	= {pabuhr@plg},
    author	= {Jonathan E. Shopiro},
    title	= {Extending the {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Task System for Real-Time Control},
    booktitle	= {Proceedings and Additional Papers {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Workshop},
    organization= {USENIX Association},
    address	= {Santa Fe, New Mexico, U.S.A},
    month	= nov,
    year	= 1987,
    pages	= {77-94}
}

@article{Modula-2+,
    keywords	= {Modula-2, exceptions, garbage collection, concurrency},
    contributer	= {gjditchfield@plg},
    author	= {Paul Rovner},
    title	= {Extending Modula-2 to Build Large, Integrated Systems},
    journal	= {IEEE Software},
    month	= nov, year = 1986,
    volume	= 3, number = 6, pages = {46-57},
    comment	= {
    	Exceptions can have a parameter.  Procedures can declare the
	exceptions they can propagate; others are converted to {\tt
	SYSTEM.Fail}.  If they don't, all exceptions propagate.
	Block cleanup statements execute no matter how control leaves the
	block.

	{\tt REF t} is a garbage-collected pointer.  A {\tt REFANY} can be
	assigned any {\tt REF t}.  Open array types can be used in
	parameter and {\tt REF} types.  {\tt NEW} creates arrays of fixed,
	dynamically determined size.

	The {\tt THREAD} module provides lightweight processes, semaphores,
	and conditions.  A statement {\tt LOCK {\em semaphore} DO
	{\em statements} END} is built in.

	{\tt SAFE} modules do run-time checks, and only import {\tt
	SAFE} modules.  One implementation module can implement several
	definition modules.  Opaque type implementations can be
	repeated in modules that import its definition, so implementation
	modules can collaborate.  The linker checks that all
	implementations are the same.
    }
}

@inproceedings{BNRPascal,
    keywords	= {concurrency, rendezvous},
    contributer	= {pabuhr@plg},
    author	= {R. Kamel and N. Gammage},
    title	= {Experience with Rendezvous},
    booktitle	= {Proceedings of the 1988 International Conference on Computer Languages},
    month	= oct,
    year	= 1988,
    pages	= {143-149}
}

% F

@inproceedings{Knudsen01,
    keywords	= {Beta, exception handling},
    contributer	= {pabuhr@plg},
    author	= {J{\o}rgen Lindskov Knudsen},
    title	= {Fault Tolerance and Exception Handling in {BETA}},
    booktitle	= {Exception Handling},
    publisher	= {Springer-Verlag},
    volume	= 2022,
    series	= {Lecture Notes in Computer Science},
    year	= 2001,
    pages	= {1-17}
}

@article{Lamport87,
    keywords	= {software solutions, mutual exclusion, fast},
    contributer	= {pabuhr@plg},
    author	= {Leslie Lamport},
    title	= {A Fast Mutual Exclusion Algorithm},
    journal	= tocs,
    volume	= 5,
    number	= 1,
    month	= jan,
    year	= {1987},
    pages	= {1--11},
    publisher	= {ACM},
    address	= {New York, NY, USA},
}

@inproceedings{F-bound,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {Peter Canning and William Cook and Walter Hill and Walter Olthoff and John C. Mitchell},
    title	= {F-Bounded Polymorphism for Object-Oriented Programming},
    booktitle	= {Fourth International Conference on Functional Programming Languages and Computer Architecture},
    year	= 1989,
    month	= sep,
    pages	= {273-280}
}

@mastersthesis{Wasik08,
    author	= {Ayelet Wasik},
    title	= {Features of a Multi-Threaded Memory Allocator},
    school	= {University of Waterloo},
    year	= 2008,
    month	= jan,
    address	= {Waterloo, Ontario, Canada, N2L 3G1},
    note	= {\textsf{http://uwspace.uwaterloo.ca/\-bitstream/\-10012/\-3501/\-1/\-Thesis.pdf}},
}

@article{Holzmann94,
    keywords	= {semaphore, flags},
    contributer	= {pabuhr@plg},
    author	= {Gerard J. Holzmann and Bj\"{o}rn Pehrson},
    title	= {The First Data Networks},
    journal	= {Scientific American},
    month	= jan,
    year	= 1994,
    volume	= 12,
    number	= 1,
    pages	= {124-129},
}

@article{Bohm66,
    keywords	= {goto, structured programming},
    contributer	= {pabuhr@plg},
    author	= {C. B\"{o}hm and G. Jacopini},
    title	= {Flow diagrams, Turing Machines and Languages with only two Formation Rules},
    journal	= cacm,
    month	= may,
    year	= 1966,
    volume	= 9,
    number	= 5,
    pages	= {366-371},
}

@manual{Fortran95,
    keywords	= {Fortran 95},
    contributer	= {pabuhr@plg},
    key		= {Fortran95},
    title	= {Fortran 95 Standard, ISO/IEC 1539},
    organization = {Unicomp, Inc.},
    address	= {7660 E. Broadway, Tucson, Arizona, U.S.A, 85710},
    month	= jan,
    year	= 1997,
}

@manual{Fortran08,
    keywords	= {ISO/IEC Fortran 08},
    contributer	= {pabuhr@plg},
    key		= {Fortran08},
    title	= {Programming Languages -- {Fortran} Part 1},
    organization= {International Standard ISO/IEC 1989:2014},
    publisher   = {International Standard Organization},
    address	= {http://www.iso.org},
    year	= 2010,
}

@book{Andrews00:book,
    keywords	= {concurrency},
    contributer	= {pabuhr@plg},
    author	= {Gregory R. Andrews},
    title	= {Foundations of Multithreaded, Parallel and Distributed Programming},
    publisher	= {Addison--Wesley},
    year	= 2000,
}

@article{Agha89,
    keywords	= {actors, concurrency},
    contributer	= {pabuhr@plg},
    author	= {Gul A. Agha},
    title	= {Foundational Issues in Concurrent Computing},
    journal	= sigplan,
    month	= apr,
    year	= 1989,
    volume	= 24,
    number	= 4,
    pages	= {60-65},
    note	= {Proceedings of the ACM SIGPLAN Workshop on Object-Based Concurrent Programming,
		   Sept. 26--27, 1988, San Diego, California, U.S.A},
}

@article{ool,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {Douglas T. Ross},
    title	= {Toward Foundations for the Understanding of Type},
    journal	= sigplan,
    year	= 1976,
    volume	= 11, pages = {63-65},
    note	= {Conference on Data: Abstraction, Definition and Structure},
    summary	= {
        Possibly the first use (without definition, alas) of the phrase
	"object oriented language".  Metaphysical to the point of incoherence.
    }
}

@article{frames,
    keywords	= {frames},
    contributer	= {gjditchfield@plg},
    author	= {Paul G. Basset},
    title	= {Frame-Based Software Engineering},
    journal	= {IEEE Software},
    month	= jul, year = 1987,
    volume	= 4, number = 4, pages = {9-16}
}

@article{Sutter05,
    keywords	= {concurrency, C++},
    contributer	= {pabuhr@plg},
    author	= {Herb Sutter},
    title	= {A Fundamental Turn Toward Concurrency in Software},
    journal	= {Dr. Dobb's Journal : Software Tools for the Professional Programmer},
    month	= mar,
    year	= 2005,
    volume	= 30,
    number	= 3,
    pages	= {16-22},
}

@inproceedings{Dony01,
    keywords	= {Smalltalk, exception handling},
    contributer	= {pabuhr@plg},
    author	= {Chistophe Dony},
    title	= {A Fully Object-Oriented Exception Handling System: Rationale and Smalltalk Implementation},
    booktitle	= {Exception Handling},
    publisher	= {Springer-Verlag},
    volume	= 2022,
    series	= {Lecture Notes in Computer Science},
    year	= 2001,
    pages	= {18-38}
}

@misc{FW,
    key		= {FW},
    contributer	= {gjditchfield@plg},
    title	= {Funk \& Wagnalls Standard Desk Dictionary},
    year	= 1980
}

@book{Knuth73V1,
    contributer	= {pabuhr@plg},
    author	= {Donald E. Knuth},
    title	= {Fundamental Algorithms},
    series	= {The Art of Computer Programming},
    publisher	= {Addison-Wesley},
    year	= 1973,
    volume	= 1,
    edition	= {second},
}

@inproceedings{Strachey,
    keywords	= {polymorphism},
    contributer	= {gjditchfield@plg},
    author	= {C. Strachey},
    title	= {Fundamental Concepts in Programming Languages},
    booktitle	= {Lecture Notes for the International Summer School in Computer Programming},
    year	= 1967,
    month	= aug,
    address	= {Copenhagen},
    comment	= {
        Defines ad-hoc and parametric polymorphism.
    }
}

@article{Eisenberg72,
    keywords	= {concurrency, N-Process solution, O(N)},
    contributer	= {pabuhr@plg},
    author	= {Murray A. Eisenberg and Michael R. McGuire},
    title	= {Further Comments on {D}ijkstra's Concurrent Programming Control Problem},
    journal	= cacm,
    month	= nov,
    year	= 1972,
    volume	= 15,
    number	= 11,
    pages	= {999},
}

% G

@article{Boehm88,
    keywords	= {conservative garbage collection, C},
    contributer	= {gjditchfield@plg},
    author	= {Hans-Juergen Boehm and Mark Weiser},
    title	= {Garbage Collection in an Uncooperative Environment},
    journal	= spe,
    month	= sep,
    year	= 1988,
    volume	= 18,
    number	= 9,
    pages	= {807-820}
}

@manual{gcc,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    title	= {GCC},
    author	= {Richard M. Stallman},
    organization= {Free Software Foundation},
    address	= {Cambridge, MA}
}

@article{doUpon,
    keywords	= {formal verification, axiomatic semantics, control structures},
    contributer	= {gjditchfield@plg},
    author	= {Ed Anson},
    title	= {A Generalized Iterative Construct and Its Semantics},
    journal	= toplas,
    volume	= {9},    number = {4},
    pages	= {567-581},
    month	= oct, year = 1987,
    comment	= {
	\begin{verbatim}
            do
                   P1 -> L1
               [] P2 -> L2
            ...
               [] Pm -> Lm
            upon
                   Q1 -> M1
               [] Q2 -> M2
            ...
               [] qn -> mn
            od
	\end{verbatim}

	If there is an i such that Qi is true, execute Mi and terminate.
	Otherwise, if there is an i such that Pi is true, execute Li and
	repeat the loop.  Otherwise, fail.
    }
}

@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{Go,
    keywords	= {Go programming language},
    contributer	= {pabuhr@plg},
    title	= {{Go} Programming Language},
    author	= {Robert Griesemer and Rob Pike and Ken Thompson},
    organization= {Google},
    year	= 2009,
    note	= {\href{http://golang.org/ref/spec}{http://golang.org/\-ref/\-spec}},
}

@article{Dijkstra68a,
    keywords	= {goto},
    contributer	= {pabuhr@plg},
    author	= {Edsger W. Dijkstra},
    title	= {Go To Statement Considered Harmful},
    journal	= cacm,
    month	= mar,
    year	= 1968,
    volume	= 11,
    number	= 3,
    pages	= {147-148},
    note	= {Reprinted in \cite{Yourdon79} pp. 29--36.},
}

@article{Choi91,
    keywords	= {contra-variance, functions},
    contributer	= {pabuhr@plg},
    author	= {Injun Choi and Michael V. Mannino},
    title	= {Graph Interpretation of Methods: A Unifying Framework for Polymorphism in Object-Oriented Programming},
    journal	= {OOPS Messenger},
    volume	= 2,
    number	= 1,
    month	= jan,
    year	= 1991,
    pages	= {38-54},
}

@misc{GNU-C,
    keywords	= {C, ANSI C},
    contributer	= {pabuhr@plg},
    author	= {Richard Stallman},
    title	= {The Free Software Foundation's Gnu {C} Compiler},
    howpublished= {Free Software Foundation, 1000 Mass Ave., Cambridge, MA, U.S.A., 02138},
    year	= 1989,
}

@article{Dijkstra:green,
    keywords	= {ada},
    contributer	= {gjditchfield@plg},
    author	= {Edsger W. Dijkstra},
    title	= {On the GREEN Language submitted to the DoD},
    journal	= sigplan,
    year	= 1978,
    month	= oct,
    volume	= 13,
    number	= 10,
    pages	= {16-21}
}

@inproceedings{Miller02,
    keywords	= {exception handling},
    contributer	= {pabuhr@plg},
    author	= {Robert Miller and Anand Tripathi},
    title	= {The Guardian Model for Exception Handling in Distributed Systems},
    booktitle	= {21st Symposium on Reliable Distributed Systems},
    organization= {IEEE},
    address	= {Suita, Japan},
    year	= 2002,
    month	= oct,
    pages	= {304-313}
}

@phdthesis{Chen09,
    author	= {Jun Chen},
    title	= {Guided Testing of Concurrent Programs Using Value Schedules},
    school	= {University of Waterloo},
    year	= 2009,
    month	= sep,
    address	= {Waterloo, Ontario, Canada, N2L 3G1},
    note	= {\textsf{http://uwspace.uwaterloo.ca/bitstream/\-10012/\-4735/\-1/\-Chen-Jun.pdf}},
}

@misc{GNU-C++,
    keywords	= {C++, GNU C},
    contributer	= {pabuhr@plg},
    author	= {Michael D. Tiemann},
    title	= {User's Guide to GNU {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    howpublished= {Free Software Foundation, 1000 Mass Ave., Cambridge, MA, U.S.A., 02138},
    month	= mar,
    year	= 1990,
}

% H

@article{Michael04a,
    keywords	= {Lock-free, synchronization, concurrent programming, memory management, multiprogramming, dynamic data structures},
    author	= {Maged M. Michael},
    title	= {Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects},
    journal	= ieeepds,
    volume	= 15,
    number	= 6,
    month	= jun,
    year	= 2004,
    pages	= {491-504},
    publisher	= {IEEE Press},
    address	= {Piscataway, NJ, USA},
}

@techreport{Hermes90,
    keywords	= {processes, distributed computing},
    contributer	= {pabuhr@plg},
    author	= {Robert E. Strom and David F. Bacon and Arthur P. Goldberg and Andy Lowry and Daniel M. Yellin and Shaula Alexander Yemini}, 
    title	= {Hermes: A Language for Distributed Computing},
    institution	= {IBM T. J. Watson Research Center},
    address	= {Yorktown Heights, New York, U.S.A., 10598},
    month	= oct,
    year	= 1990,
}

@book{Hermes91,
    keywords	= {processes, distributed computing},
    contributer	= {pabuhr@plg},
    author	= {Robert E. Strom and David F. Bacon and Arthur P. Goldberg and Andy Lowry and Daniel M. Yellin and Shaula Alexander Yemini}, 
    title	= {Hermes: A Language for Distributed Computing},
    publisher	= {Prentice Hall},
    series	= {Innovative Technology},
    year	= 1991,
}

@article{katzenelson83b,
    contributer	= {gjditchfield@plg},
    author	= "Jacob Katzenelsen",
    title	= "Higher Level Programming and Data Abstraction---A Case Study using Enhanced C",
    journal	= spe,
    year	= 1983,
    volume	= 13,
    number	= 7,
    pages	= {577-596},
    month	= jul
}

@techreport{Hoare73,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {C. A. R. Hoare},
    title	= {Hints on Programming Language Design},
    institution	= {Stanford University Computer Science Department},
    year	= 1973,
    month	= dec,
    number	= {CS-73-403},
    note	= {Reprinted in \cite{pldesign}.}
}

@article{Dijkstra71,
    keywords	= {monitor, secretary},
    contributer	= {pabuhr@plg},
    author	= {E. W. Dijkstra},
    title	= {Hierarchical Ordering of Sequential Processes},
    journal	= acta,
    volume	= 1,
    pages	= {115-138},
    year	= 1971,
}

@article{Buhr15a,
    keywords	= {software solution, mutual exclusion, performance experiment},
    author	= {Peter A. Buhr and David Dice and Wim H. Hesselink},
    title	= {High-Performance {$N$}-Thread Software Solutions for Mutual Exclusion},
    journal	= {Concurrency and Computation: Practice and Experience},
    volume	= 27,
    number	= 3,
    pages	= {651-701},
    month	= mar,
    year	= 2015,
}

@article{Ackermann28,
    keywords	= {recursion, Ackermann function},
    contributer	= {pabuhr@plg},
    author	= {Wilhelm Ackermann},
    title	= {Zum Hilbertschen Aufbau der reellen Zahlen},
    publisher	= {Springer},
    journal	= {Mathematische Annalen},
    number	= 1,
    volume	= 99,
    pages	= {118-133},
    month	= dec,
    year	= 1928,
}

@inproceedings{typeclass,
    keywords	= {Hindley/Miller type systems, Haskell},
    contributer	= {gjditchfield@plg},
    author	= {Philip Wadler and Stephen Blott},
    title	= {How to make {\em Ad-Hoc} Polymorphism Less {\em Ad-Hoc}},
    booktitle	= popl,
    year	= 1989,
    pages	= {60-76},
    organization= {Association for Computing Machinery}
}

% I

@book{IBM370,
    keywords	= {370, IBM},
    contributer	= {pabuhr@plg},
    key		= {IBM370},
    title	= {{IBM} System/370 Principles of Operation},
    publisher	= {IBM},
    number	= {GA22-7000-8},
    month	= oct,
    year	= 1981,
    edition	= {9th}
}

@book{Icon,
    keywords	= {Icon},
    contributer	= {pabuhr@plg},
    author	= {Ralph E. Griswold and Madge T. Griswold},
    title	= {The Icon Programming Language},
    publisher	= {Prentice-Hall},
    year	= 1983,
}

@inproceedings{Valois94,
    keywords	= {lock free, queue},
    contributer	= {pabuhr@plg},
    author	= {John D. Valois},
    title	= {Implementing Lock-Free Queues},
    booktitle	= {Seventh International Conference on Parallel and Distributed Computing Systems},
    address	= {Las Vegas, Nevada, U.S.A.},
    year	= {1994},
    pages	= {64-69},
}

@article{Hehner81,
    keywords	= {concurrency, critical section, bakery algorithm},
    contributer	= {pabuhr@plg},
    author	= {Eric C. R. Hehner and R. K. Shyamasundar},
    title	= {An Implementation of {P} and {V}},
    journal	= ipl,
    year	= 1981,
    month	= aug,
    volume	= 12,
    number	= 4,
    pages	= {196-198},
}

@incollection{Steenkiste91,
    keywords	= {lisp},
    contributer	= {gjditchfield@plg},
    author	= {Peter A. Steenkiste},
    title	= {The Implementation of Tags and Run-Time Checking},
    booktitle	= {Topics in Advanced Language Implementation},
    pages	= {3-24},
    year	= 1991,
    editor	= {Peter Lee},
    chapter	= {1},
    publisher	= {The MIT Press}
}

@techreport{Roberts89,
    keywords	= {},
    contributer	= {pabuhr@plg},
    author	= {Eric S. Roberts},
    title	= {Implementing Exceptions in {C}},
    institution	= {Digital Systems Research Center},
    address	= {130 Lytton Avenue, Palo Alto, California, 94301},
    number	= {40},
    month	= mar,
    year	= 1989,
}

@mastersthesis{Bilson03,
    keywords	= {Cforall, parametric polymorphism, overloading},
    contributer	= {pabuhr@plg},
    author	= {Richard C. Bilson},
    title	= {Implementing Overloading and Polymorphism in Cforall},
    school	= {School of Computer Science, University of Waterloo},
    year	= 2003,
    address	= {Waterloo, Ontario, Canada, N2L 3G1},
    note	= {\href{http://plg.uwaterloo.ca/theses/BilsonThesis.pdf}{http://\-plg.uwaterloo.ca/\-theses/\-BilsonThesis.pdf}},
}

@article{Buhr05b,
    keywords	= {monitor, automatic signal, implicit signal},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr and Ashif S. Harji},
    title	= {Implicit-signal monitors},
    journal	= toplas,
    volume	= 27,
    number	= 6,
    month	= nov,
    year	= 2005,
    issn	= {0164-0925},
    pages	= {1270--1343},
    doi		= {http://doi.acm.org/10.1145/1108970.1108975},
    publisher	= {ACM Press},
    address	= {New York, NY, USA},
}

@article{Baker77,
    author	= {Henry C. Baker, Jr. and Carl Hewitt},
    title	= {The Incremental Garbage Collection of Processes},
    journal	= {SIGART Bulletin},
    publisher	= {ACM},
    address	= {New York, NY, USA},
    month	= aug,
    year	= 1977,
    pages	= {55-59},
    issn	= {0163-5719},
    doi		= {http://doi.acm.org/10.1145/872736.806932},
 }

@book{Algol68,
    keywords	= {Algol68},
    contributer	= {pabuhr@plg},
    author	= {C. H. Lindsey and S. G. van der Meulen},
    title	= {Informal Introduction to ALGOL 68},
    publisher	= {North-Holland},
    address	= {London},
    year	= 1977,
}

@inproceedings{Cook90,
    keywords	= {f-bounded polymorhpism, lambda calculus},
    contributer	= {gjditchfield@plg},
    author	= {William R. Cook and Walter L. Hill and Peter S. Canning},
    title	= {Inheritance is Not Subtyping},
    booktitle	= popl,
    year	= 1990,
    pages	= {125-135},
    organization= {Association for Computing Machinery},
    abstract	= {
        In typed object-oriented languages the subtype relation is
	typically based on the inheritance hierarchy.  This approach,
	however, leads either to insecure type-systems or to restrictions
	on inheritance that make it less flexible than untyped Smalltalk
	inheritance.  We present a new typed model of inheritance that
	allows more of the flexibility of Smalltalk inheritance within a
	statically-typed system.  Significant features of our analysis are
	the introduction of polymorphism into the typing of inheritance and
	the uniform application of inheritance to objects, classes and
	types.  The resulting notion of {\em type inheritance} allows us to
	show that the type of an inherited object is an inherited type but
	not always a subtype.
    }
}

@inproceedings{MMR92,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {Robert E. Minnear and Patrick A. Muckelbauer and Vincent F. Russo},
    title	= {Integrating the {Sun Microsystems} {XDR/RPC} Protocols
		  into the {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Stream Model},
    booktitle	= {USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Conference Proceedings},
    year	= 1992,
    month	= aug,
    pages	= {295-312},
    organization= {USENIX Association},
    address	= {2590 Ninth Street, Suite 215, Berkeley, CA 94710},
    abstract	= {
        This paper reports our experiences integrating the Sun Microsystems
	RPC and XDR protocol specifications into the C++ model of
	input/output streams.  As part of the {\it Renaissance} operating
	system project, we wish to construct network servers and clients,
	written in C++, which interoperate with existing UNIX clients
	and servers.  We discovered that, although it would be possible to
	re-implement the procedural based XDR/RPC implementation
	distributed by Sun Microsystems in C++, it is far cleaner to
	integrate the protocols with the C++ I/O stream model.  We
	feel the resulting model provides a cleaner way of implementing RPC
	clients and servers without losing functionality or compatibility
	with existing clients and servers.
    }
}

@inproceedings{Zuo08,
    keywords	= {shared memory systems,intelligent multiport memory,multiprocessors systems,shared memory system},
    author	= {Wang Zuo and Wang Zuo and Li Jiaxing},
    title	= {An Intelligent Multi-Port Memory},
    booktitle	= {Symposium on Intelligent Information Technology Application Workshops, Shanghai, China},
    month	= dec,
    year	= 2008,
    pages	= {251-254},
    publisher	= {IEEE Computer Society},
    address	= {Los Alamitos, CA, USA},
}

@book{Francez96,
    keywords	= {await, formal},
    contributer	= {pabuhr@plg},
    author	= {Nissim Francez and Ira R. Forman},
    title	= {Interacting Processes: A Multiparty Approach to Coordinated Distributed Programming},
    publisher	= {Addison-Wesley},
    series	= {ACM Press Books},
    year	= 1996,
}

@article{Labreche90,
    keywords	= {concurrency, C++},
    contributer	= {pabuhr@plg},
    author	= {Pierre Labr{\`{e}}che},
    title	= {Interactors: A Real-Time Executive with Multiparty Interactions in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    journal	= sigplan,
    volume	= 25,
    number	= 4,
    month	= apr,
    year	= 1990,
    pages	= {20-32},
}

@inproceedings{interfaces,
    keywords	= {parameterized interfaces, classes, recursion/inheritance},
    contributer	= {gjditchfield@plg},
    author	= {Peter S. Canning and William R. Cook and Walter L. Hill and
        Walter G. Olthoff},
    title	= {Interfaces for Strongly-Typed Object-Oriented Programming},
    crossref	= "OOPSLA89",
    pages	= {457-467},
    abstract	= {
        This paper develops a system of explicit interfaces for
	object-oriented programming.  The system provides the benefits of
	module interfaces found in languages like Ada and Modula-2 while
	preserving the expressiveness that gives untyped object-oriented
	languages like Smalltalk their flexibility.  Interfaces are
	interpreted as polymorphic types to make the system sufficiently
	powerful.  We use interfaces to analyze the properties of
	inheritance, and identify three distinct kinds of inheritance in
	object-oriented programming, corresponding to objects, classes, and
	interfaces, respectively.  Object interfaces clarify the
	distinction between interface containment and inheritance and give
	insight into limitations caused by equating the notions of type and
	class in many typed object-oriented programming languages.
	Interfaces also have practical consequences for design,
	specification, and maintenance of object-oriented systems.
    }
}

@phdthesis{Girard72,
    keywords	= {universal quantification},
    contributer	= {gjditchfield@plg},
    author	= {J.-Y. Girard},
    title	= {Interpretation fonctionelle et elimination des coupures de
	l'arithmetique d'ordre superieur},
    school	= {Universite Paris},
    year	= {1972}
}

@article{Karaorman93,
    keywords	= {Eiffel, concurrency libraries},
    contributer	= {pabuhr@plg},
    author	= {Murat Karaorman and John Bruno},
    title	= {Introducing Concurrency to a Sequential Language},
    journal	= cacm,
    month	= sep,
    year	= 1993,
    volume	= 36,
    number	= 9,
    pages	= {103-116}
}

@book{Corman92,
    keywords	= {PRAM, parallel algorithms},
    contributer	= {pabuhr@plg},
    author	= {Thomas H. Cormen and Charles E. Leiserson and Ronald L. Rivest},
    title	= {Introduction to Algorithms},
    publisher	= {MIT Press/McGraw-Hill},
    series	= {Electrical Engineering and Computer Science Series},
    year	= 1992,
}

@book{Hopcroft79,
    keywords	= {finite-state machine, push-dowm automata},
    contributer	= {pabuhr@plg},
    author	= {John E. Hopcroft and Jeffrey D. Ullman},
    title	= {Introduction to Automata Theory, Languages and Computation},
    publisher	= {Addison-Wesley},
    year	= 1979,
}

@techreport{walker87,
    keywords	= {CCS},
    contributer	= {gjditchfield@plg},
    author	= {David Walker},
    title	= {Introduction to a Calculus of Communicating Systems},
    institution	= {Laboratory for Foundations of Computer Science},
    year	= 1987,
    address	= {Department of Computer Science, University of Edinburgh, Edinburgh EH9 3JZ},
    month	= jun,
    number	= {ECS-LFCS-87-22},
}

@article{katzenelson83a,
    author	= {Jacob Katzenelson},
    title	= {Introduction to Enhanced C (EC)},
    journal	= spe,
    volume	= 13,
    number	= 7,
    year	= 1983,
    month	= jul,
    pages	= {551-576},
}

@book{Deitel90,
    keywords	= {concurrency, operating systems},
    contributer	= {pabuhr@plg},
    author	= {Harvey M. Deitel},
    title	= {An Introduction to Operating Systems},
    publisher	= {Addison-Wesley},
    year	= 1990,
    edition	= {second},
}

@techreport{Birrell89,
    keywords	= {threads, monitors},
    contributer	= {pabuhr@plg},
    author	= {Andrew D. Birrell},
    title	= {An Introduction to Programming with Threads},
    institution	= {Digital Systems Research Center},
    address	= {130 Lytton Avenue, Palo Alto, California, 94301},
    number	= {35},
    month	= jan,
    year	= 1989,
    note	= {{\textsf{http://www.hpl.hp.com/\-techreports/\-Compaq-DEC/\-SRC-RR-35.html}}},

}

@article{t/o,
    keywords	= {Trellis/Owl},
    contributer	= {gjditchfield@plg},
    author	= {Craig Schaffert and Topher Cooper and Bruce Bullis and Mike Kilian and Carrie Wilpot},
    title	= {An Introduction to Trellis/Owl},
    journal	= sigplan,
    volume	= 21,
    number	= 11,
    year	= 1986,
    month	= nov,
    pages	= {9-16},
}

@inproceedings{Hibbard77,
    keywords	= {algol-68, concurrency},
    contributer	= {pabuhr@plg},
    author	= {Peter G. Hibbard and P. Knueven and B. W. Leverett},
    title	= {Issues in the Efficient Implementation and Use of Multiprocessing in {Algol} 68},
    booktitle	= {Proceedings of the 5th Annual iii Conference},
    address	= {Guidel, France},
    month	= may,
    year	= 1977,
    pages	= {203-221}
}

@inproceedings{Miller97,
    keywords	= {exception handling, software-engineering},
    contributer	= {pabuhr@plg},
    author	= {Robert Miller and Anand Tripathi},
    title	= {Issues with Exception Hnadling in Object-Oriented Systems},
    booktitle	= {ECOOP'97},
    publisher	= {Springer-Verlag},
    volume	= 1241,
    series	= {Lecture Notes in Computer Science},
    year	= 1997,
    pages	= {85-103}
}
   
@article{Murer96,
    keywords	= {interators, generators, cursors},
    contributer	= {pabuhr@plg},
    author	= {Stephan Murer and Stephen Omohundro and David Stoutamire and Clemens Szyperski},
    title	= {Iteration Abstraction in Sather},
    journal	= toplas,
    month	= jan,
    year	= 1996,
    volume	= 18,
    number	= 1,
    pages	= {1-15},
}

% J
		  
@book{Java,
    keywords    = {Java},
    contributer	= {pabuhr@plg},
    author      = {James Gosling and Bill Joy and Guy Steele and Gilad Bracha},
    title       = {The {Java} Language Specification},
    publisher	= {Addison-Wesley},
    year        = 2000,
    edition	= {second},
}

@manual{Java8,
    keywords    = {Java SE 8},
    contributer	= {pabuhr@plg},
    author      = {James Gosling and Bill Joy and Guy Steele and Gilad Bracha and Alex Buckley},
    title       = {The {Java} Language Specification},
    publisher	= {Oracle},
    year        = 2015,
    edition	= {Java SE 8},
}

@manual{JUC,
    keywords	= {Java concurrency library},
    contributer	= {pabuhr@plg},
    title	= {java.util.concurrency},
    author	= {Doug Lea},
    organization= {Oracle},
    year	= 2014,
    note	= {\href{http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html}{\textsf{http://docs.oracle.com/\-javase/7/\-docs/\-api/\-java/\-util/\-concurrent/\-package-summary.html}}},
}

% K

@article{Duggan96,
    keywords	= {concurrency, critical section},
    contributer	= {pabuhr@plg},
    author	= {Dominic Duggan and Gordon V. Cormack and John Ophel},
    title	= {Kinded Type Inference for Parametric Overloading},
    journal	= acta,
    volume	= 33,
    number	= 1,
    year	= 1996,
    pages	= {21-68},
}

@article{Peter35,
    keywords	= {recursion, Ackermann function},
    contributer	= {pabuhr@plg},
    author	= {R{\'{o}}zsa P{\'{e}}ter},
    title	= {Konstruktion nichtrekursiver Funktionen},
    publisher	= {Springer},
    journal	= {Mathematische Annalen},
    number	= 111,
    volume	= 1,
    pages	= {42-60},
    month	= dec,
    year	= 1935,
}

% L

@TechReport{WVWR88:L,
    contributer	= {gjditchf@plg},
    author	= {Hanno Wupper and Jan Vytopil and Martin Wieczorek and Dick de Reus},
    title	= {{L}_{3333}: A Simple Language with Static Typing of Hard Real-Time Constraints},
    institution	= {Department of Informatics, Faculty of Science, Catholic University Nijmegen},
    year	= 1988,
    number	= {88-3},
    address	= {Katholieke Universiteit Nijmegen, Fakulteit der Wiskunde
		   en Natuurwetenschappen, Infomatica V, Toernooiveld, 6512
		   ED Nijmegen, The Netherlands},
    month	= apr,
    annote	= {A polymorphic typed lambda calculus with \begin{itemize}
		   \item A trivial type, ``!'', with a single element.
		   \item Labelled types, distinct from each other.
		   ``!False'' and ``!True'' are distinct types, each
		   containing a single value serving as boolean false and
		   true.  ``2'' is an abbreviation for ``!0 succ succ'', the
		   type containing only 2.
		   \item Disjunction types ``\{| !False, !True |\}''.  Interval
		   types are abbreviations for disjunctions.
		   \item Conjunction types ``\{\& real Re, real Im \&\}'', where
		   ``Re'' and ``Im'' are type labels that distinguish between the
		   fields.
		   \item Pair types ``\{^ a, b ^\}'', for use in recursive types
		   and dyadic infix functions.
		   \item Function types, universal types, existential types,
		   and subtyping (viewed as coercion), as in Fun.
		   \end{itemize}
		   Disjunctions and conjunctions types are associative and
		   commutative (i.e. flat).  Each type has a matching
		   constructor.  Functions use pattern matching on type
		   labels to strip labels and extract conjunction fields:
		   \begin{verbatim}
		   \lambda n {0...1000000 Guilders}. ... n ...
		   -- both argument and n are amounts in Guilders.
		   \lambda n {0...1000000} Guilders. ... n ...
		   -- argument in Guilders, but n is in 0...1000000.
		   \end{verbatim}
		   ``Function bundles'' (conjunctions of functions), applied
		   to arguments, replace Dijkstra's guarded if...fi, but the
		   bundles are first-class and the guards are part of their
		   type.

		   The same trick used to define the type ``2'' is used to
		   move absolute times into the type system, to allow static
		   checking. ``0`'' denotes a time before the system begins
		   execution.  ``\#`'' denotes ``eventually'', and ``?`''
		   denotes ``maybe never''.  ``a\\t'' and ``a@t'' are types
		   of a value of type a that will be available no later
		   (earlier) than time t.  Universals and existentials use
		   subtyping to parameterize functions by start time:
		   \begin{verbatim}
		   let f {\forall t > \#`}. {a\t} \on {b\t+d}
		   f{then} y -- argument y must be available at time ``then''.
		   \end{verbatim}
		   Functions can return before their arguments are available
		   if they don't use them.  However, function {\em bundles}
		   can't return until their result type is known, so the
		   lower and upper time bounds of the bundle are the
		   second-last upper bound of the component functions: at
		   that time, there is only one alternative left.

		   Explicit time parameterization allows slack in time
		   specification.  Tools could point out slack or determine
		   degree of parallelism.}
}

@mastersthesis{Clarke90,
    keywords	= {concurrency, postponing requests},
    contributer	= {pabuhr@plg},
    author	= {Charles L. A. Clarke},
    title	= {Language and Compiler Support for Synchronous Message Passing Architectures},
    school	= {University of Waterloo},
    year	= 1990,
    address	= {Waterloo, Ontario, Canada, N2L 3G1}
}

@article{Tennent77,
    keywords	= {abstraction, correspondence, Pascal},
    contributer	= {gjditchfield@plg},
    author	= {R. D. Tennent},
    title	= {Language Design Methods Based on Semantic Principles},
    journal	= acta,
    year	= 1977,
    volume	= 8,
    number	= 2,
    pages	= {97-112},
    note	= {reprinted in \cite{pldesign}},
    abstract	= {
        Two language design methods based on principles derived from the
	denotational approach to programming language semantics are
	described and illustrated by an application to the language Pascal.
	The principles are, firstly, the correspondence between parametric
	and declarative mechanisms and secondly, a principle of abstraction
	for programming languages adapted from set theory.  Several useful
	extensions and generalizations of Pascal emerge by applying these
	principles, including a solution to the array parameter problem,
	and a modularization facility.
    },
}

@article{Liskov86,
    keywords	= {synchronous communication, concurrency},
    contributer	= {pabuhr@plg},
    author	= {Barbara Liskov and Maurice Kerlihy and Lucy Gilbert},
    title	= {Limitations of Synchronous Communication with Static
		   Process Structure in Languages for Distributed Computing},
    journal	= {},
    volume	= {},
    number	= {},
    month	= {},
    year	= {},
    pages	= {},
}

@article{Linda,
    keywords	= {Linda, concurrency},
    contributer	= {pabuhr@plg},
    author	= {Nicholas Carriero and David Gelernter},
    title	= {Linda in Context},
    journal	= cacm,
    volume	= 32,
    number	= 4,
    month	= apr,
    year	= 1989,
    pages	= {444-458}
}

@book{Weissman67,
    keywords	= {lisp},
    author	= {Clark Weissman},
    title	= {Lisp 1.5 Primer},
    publisher	= {Dickenson Publishing},
    year	= 1967,
}

@article{Sundell08,
    keywords	= {lock free, deque},
    contributer	= {pabuhr@plg},
    author	= {H{\r{a}}kan Sundell and Philippas Tsigas},
    title	= {Lock-free Deques and Doubly Linked Lists},
    journal	= {J. Parallel Distrib. Comput.},
    volume	= 68,
    number	= 7,
    year	= 2008,
    pages	= {1008-1020},
}

@article{Cormack89,
    keywords	= {parsing, LR, error recovery},
    contributer	= {pabuhr@plg},
    author	= {Gordon V. Cormack},
    title	= {An {LR} Substring Parser for Noncorrecting Syntax Error Recovery},
    journal	= sigplan,
    volume	= 24,
    number	= 7,
    month	= jul,
    year	= 1989,
    pages	= {161-169},
    note	= {Proceedings of the {SIGPLAN}~'89 Conference on Programming Language Design and Implementation}
}

% M

@book{M68K,
    keywords	= {M680XX, Motorola},
    contributer	= {pabuhr@plg},
    key		= {Motorola},
    title	= {M68000 Family Programmer's Reference Manual},
    publisher	= {Motorola},
    year	= 1992,
}

@article{c++libs,
    keywords	= {directory structure},
    contributer	= {gjditchfield@plg},
    author	= {J. M. Coggins and G. Bollella},
    title	= {Managing {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Libraries},
    journal	= sigplan,
    year	= 1989,
    month	= jun, volume = 24, number = 6, pages = {37-48},
    abstract	= {
        This paper describes a scheme we have used to manage a large
	library written in the C++ language.  The scheme imposes a
	directory structure, and represents dependency hierarchy in a
	globally accessible file we call the 'prelude' file.  We also
	discuss the structure of the description files (makefiles) used
	with the UNIX options we have found to be useful in reducing the
	size of the library, and how to minimize recompilation time after
	trivial changes to the source code of the library.
    }
}

@inproceedings{mprof,
    keywords	= {malloc},
    contributer	= {gjditchfield@plg},
    author	= {Benjamin Zorn and Paul Hilfinger},
    title	= {A Memory Allocation Profiler for {C} and Lisp Programs},
    booktitle	= {Summer 1988 {USENIX} proceedings},
    year	= 1988
}

@manual{MMTk,
    keywords	= {Java memory management},
    contributer	= {pabuhr@plg},
    title	= {MMTk: The Memory Management Toolkit},
    author	= {Steve Blackburn and Robin Garner and Daniel Frampton},
    month	= sep,
    year	= 2006,
    note	= {\textsf{http://cs.anu.edu.au/\-\char`\~Robin.Garner/\-mmtk-guide.pdf}},
}

@article{Adve10,
    keywords	= {Java memory management},
    contributer	= {pabuhr@plg},
    author	= {Sarita V. Adve and Hans-J. Boehm},
    title	= {Memory Models: A Case for Rethinking Parallel Languages and Hardware},
    journal	= cacm,
    volume	= 53,
    number	= 8,
    month	= aug,
    year	= 2010,
    pages	= {90-101},
    publisher	= {ACM},
    address	= {New York, NY, USA},
}
@techreport{Mesa,
    keywords	= {monitors, packages},
    contributer	= {pabuhr@plg},
    author	= {James G. Mitchell and William Maybury and Richard Sweet},
    title	= {Mesa Language Manual},
    institution	= {Xerox Palo Alto Research Center},
    number	= {CSL--79--3},
    month	= apr,
    year	= 1979
}

@article{Andrews89,
    keywords	= {semaphore, split-binary, baton},
    contributer	= {pabuhr@plg},
    author	= {Gregory R. Andrews},
    title	= {A Method for Solving Synronization Problems},
    journal	= scp,
    volume	= 13,
    number	= 4,
    month	= dec,
    year	= 1989,
    pages	= {1-21},
}

@inproceedings{Mitchell78,
    keywords	= {Mesa},
    contributer	= {pabuhr@plg},
    author	= {James G. Mitchell},
    title	= {Mesa: A Designer's User Perspective},
    booktitle	= {Spring CompCom 78},
    organization= {Sixteenth IEEE Computer Society International Conference},
    address	= {San Francisco, California, U.S.A.},
    month	= feb,
    year	= 1978,
    pages	= {36-39},
    note	= {IEEE Catalog No. 78CH1328-4C},
}

@article{Gentleman81,
    keywords	= {messages, concurrency},
    contributer	= {pabuhr@plg},
    author	= {W. Morven Gentleman},
    title	= {Message Passing between Sequential Processes:
		   the Reply Primitive and the Administrator Concept},
    journal	= spe,
    month	= may,
    year	= 1981,
    volume	= 11,
    number	= 5,
    pages	= {435-466}
}

@article{Cormack88,
    keywords	= {concurrency},
    contributer	= {pabuhr@plg},
    author	= {G. V. Cormack},
    title	= {A Micro Kernel for Concurrency in C},
    journal	= spe,
    month	= may,
    year	= 1988,
    volume	= 18,
    number	= 4,
    pages	= {485-491}
}

@article{Buhr90a,
    keywords	= {concurrency, light-weight process, shared memory},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr and Richard A. Stroobosscher},
    title	= {The $\mu${S}ystem: Providing Light-Weight Concurrency on Shared-Memory Multiprocessor Computers Running {UNIX}},
    journal	= spe,
    volume	= 20,
    number	= 9,
    month	= sep,
    year	= 1990,
    pages	= {929-963},
}

@techreport{uSystem,
    keywords	= {C, concurrency, light-weight process, shared memory},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr and Hamish I. Macdonald and Richard A. Stroobosscher},
    title	= {$\mu${S}ystem Annotated Reference Manual, Version 4.4.3},
    institution	= {Department of Computer Science, University of Waterloo},
    address	= {Waterloo, Ontario, Canada, N2L 3G1},
    month	= sep,
    year	= 1994,
    note	= {{\small\textsf{ftp://\-plg.uwaterloo.ca/\-pub/\-uSystem/\-uSystem.ps.gz}}},
}

@book{Mips4000,
    key		= {Mips4000},
    title	= {MIPS R4000 Microprocessor User's Manual},
    publisher	= {MIPS Computer Systems Inc},
    year	= 1991,
}

@inproceedings{Mjolner,
    keywords	= {Mjolner, hierarchical windows},
    contributer	= {pabuhr@plg},
    author	= {G\"{o}rel Hedin and Boris Magnusson},
    title	= {The Mj{\o}lner Environment: Direct Interaction with Abstractions},
    booktitle	= {Proceedings of the European Conference on Object Oriented Programming},
    organization= {ECOOP'88},
    publisher	= {Springer-Verlag},
    volume	= 322,
    editor	= {S. Gjessing and K. Nygaard},
    address	= {Oslo, Norway},
    month	= aug,
    year	= 1988,
    pages	= {41-54},
    note	= {Lecture Notes in Computer Science, Ed. by G. Goos and J. Hartmanis},
}

@article{Skillicorn98,
    keywords	= {parallel models},
    contributer	= {pabuhr@plg},
    author	= {David B. Skillicorn and Domenico Talia},
    title	= {Models and Languages for Parallel Computation},
    journal	= acmcs,
    volume	= 30,
    number	= 2,
    month	= jun,
    year	= 1998,
    pages	= {123-169},
}

@article{Werther96,
    keywords	= {C++, language syntax},
    contributer	= {pabuhr@plg},
    author	= {Ben Werther and Damian Conway},
    title	= {A Modest Proposal: {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Resyntaxed},
    journal	= sigplan,
    volume	= 31,
    number	= 11,
    month	= nov,
    year	= 1996,
    pages	= {74-82},
}

@book{Alexandrescu01,
    keywords	= {c design-patterns programming},
    contributer	= {pabuhr@plg},
    author	= {Andrei Alexandrescu},
    title	= {Modern C++ Design: Generic Programming and Design Patterns Applied},
    publisher	= {Addison-Wesley Professional},
    month	= feb,
    year	= 2001,
    isbn	= {0201704315},
}

@book{Tanenbaum92,
    keywords	= {concurrency, operating systems},
    contributer	= {pabuhr@plg},
    author	= {Andrew S. Tanenbaum},
    title	= {Modern Operating Systems},
    publisher	= {Prentice-Hall},
    year	= 1992,
}

@article{Wirth77,
    keywords	= {modules, coroutines},
    contributer	= {pabuhr},
    author	= {Niklaus Wirth},
    title	= {Modula: a Language for Modular Multiprogramming},
    journal	= spe,
    month	= {January--February},
    year	= 1977,
    volume	= 7,
    number	= 1,
    pages	= {3-35},
}

@book{Harbison92,
    contributer	= {mhcoffin},
    author	= {Samuel P. Harbison},
    title	= {Modula-3},
    publisher	= {Prentise Hall, Inc.},
    year	= {1992},
    comment	= {This is a textbook for learning Modula-3.}
}

@techreport{Modula-3:old,
    keywords	= {Modula-3, inheritance, type extension},
    contributer	= {gjditchfield@plg},
    author	= {Luca Cardelli and James Donahue and Lucille Glassman and Mick
		   Jordan and Bill Kalsow and Greg Nelson},
    title	= {Modula-3 Report},
    institution	= {Systems Research Center},
    address	= {130 Lytton Avenue, Palo Alto, California  94301},
    month	= aug,
    year	= 1988,
    number	= 31
}
 
@article{Dueck90,
    keywords	= {attribute grammars},
    contributer	= {pabuhr@plg},
    author	= {Gerald D. P. Dueck and Gordon V. Cormack},
    title	= {Modular Attribute Grammars},
    journal	= {The Computer Journal},
    month	= apr,
    year	= 1990,
    volume	= 33,
    number	= 2,
    pages	= {164-172},
}

@article{Yemini85,
    keywords	= {exception handling},
    contributer	= {pabuhr@plg},
    author	= {Shaula Yemini and Daniel M. Berry},
    title	= {A Modular Verifiable Exception-Handling Mechanism},
    journal	= toplas,
    month	= apr,
    year	= 1985,
    volume	= 7,
    number	= 2,
    pages	= {214-243},
}

@article{Buhr95b,
    keywords	= {concurrency, monitors, classification},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr and Michel Fortier and Michael H. Coffin},
    title	= {Monitor Classification},
    journal	= acmcs,
    volume	= 27,
    number	= 1,
    month	= mar,
    year	= 1995,
    pages	= {63-107},
}

@article{Hoare74,
    keywords	= {monitor},
    contributer	= {pabuhr@plg},
    author	= {C. A. R. Hoare},
    title	= {Monitors: An Operating System Structuring Concept},
    journal	= cacm,
    volume	= 17,
    number	= 10,
    month	= oct,
    year	= 1974,
    pages	= {549-557},
    annote	= {
    }
}

@inbook{Buhr99a,
    keywords	= {concurrency, monitors, classification},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr and Michel Fortier and Michael H. Coffin},
    title	= {Encyclopedia of Computer Science and Technology},
    chapter	= {Monitor Taxonomy},
    publisher	= {Marcel Dekker, Inc},
    volume	= {40, supplement 25},
    year	= 1999,
    pages	= {191-212},
}
%    editor	= {Allen Kent and James G. Williams},

@manual{MPI,
    keywords	= {MPI},
    contributer	= {pabuhr@plg},
    title	= {MPI: A Message-Passing Interface Standard, Version 3.1},
    organization= {Message Passing Interface Forum},
    address	= {University of Tennessee, Knoxville, Tennessee},
    month	= jun,
    year	= 2015,
    note	= {\href{http://www.mpi-forum.org/docs/mpi-3.1/mpi31-report.pdf}{\textsf{http://www.mpi-forum.org/\-docs/\-mpi-3.1/\-mpi31-report.pdf}}},
}

@article{multilisp,
    keywords	= {futures, scheme},
    contributer	= {gjditchfield@plg},
    author	= {Halstead, Jr.,Robert H.},
    title	= {Multilisp: A Language for Concurrent Symbolic Programming},
    journal	= toplas,
    volume	= 7,
    number	= 4,
    pages	= {501-538},
    month	= oct,
    year	= 1985,
    comment	= {
	(future E) begins evaluating the expression E, and
	returns a ``future'' representing the value.  When evaluation is
	finished, the value of E replaces the future.  Operations that need
	the future's value suspend until it is available.  Assignment and
	parameter passing do not suspend.  Future introduces concurrency
	between the calculation of a value and its use; reference to
	futures is a synchronization mechanism.

	(pcall F A B ... C) concurrently evaluates F, A, B, ... C, and then
	applies F to the arguments.  pcall can be built from future and a
	``touch'' operation.  pcall is included because it may not be easy
	to determine that there are no critical sections between the future
	expression and the code between the future call and the value's
	first use.

	(delay E) is like future, but E's process does not begin until its
	value is needed.  It provides lazy evaluation.  Replacing delay
	with future would launch an infinite number of processes.
    }
}

@techreport{Bretthauer89,
    keywords	= {multiple inheritance},
    contributer	= {pabuhr@plg},
    author	= {Harry Bretthauer and Thomas Christaller and J\"{u}rgen Kopp}, 
    title	= {Multiple vs. Single Inheritance in Object-oriented Programming Languages. What do we really want?},
    institution	= {Gesellschaft F\"{u}r Mathematik und Datenverarbeitung mbH},
    address	= {Schlo$\beta$ Birlinghoven, Postfach 12 40, D-5205 Sankt Augustin 1, Deutschland},
    number	= {Arbeitspapiere der GMD 415},
    month	= nov,
    year	= 1989,
}

@inproceedings{c++:multinh,
    keywords	= {C++, multiple inheritance, implementation},
    contributer	= {gjditchfield@plg},
    author	= {Bjarne Stroustrup},
    title	= {Multiple Inheritance for {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    booktitle	= {Proceedings of the Spring '87 EUUG Conference},
    month	= may, year = 1987
}

@inproceedings{st:mult,
    keywords	= {smalltalk, multiple inheritance, implementation},
    contributer	= {gjditchfield@plg},
    author	= {Daniel H. H. Ingalls and A. H. Borning},
    title	= {Multiple Inheritance in Smalltalk-80},
    booktitle	= {Proceedings of the National Conference on Artificial Intelligence},
    month	= aug,
    year	= 1982,
    pages	= {234-238},
    organization= {American Association for Artificial Intelligence},
    comment	= {
        Methods are looked up in the current class, the superclasses, the
	supersuperclasses, etc.  The same method can be inherited
	repeatedly, but having different methods for the same message is an
	error.  Only one copy is made for multiply-inherited fields.

	{\tt X.m} is the method m in superclass X.  {\tt super.m} is
	allowed if there is no ambiguity; {\tt self super.m} replaces {\tt
	super m}.  {\tt all.m} invokes all inherited versions of m.

	Methods on the first-superclass chain are found as usual.  Methods
	from other superclasses are copied into the class dictionary.  An
	error method is created if inherited methods conflict.  The parser
	is changed to allow compound selectors.  {\tt Object
	messageNotUnderstood} is changed to look for compound selectors and
	dynamically add a method with the right name and body to the class.
	When methods are edited, they are copied into subclasses and
	compound selector versions are deleted, as appropriate.
    }
}

@article{Lamport86I,
    keywords	= {software solutions, N-thread, mutual exclusions},
    contributer	= {pabuhr@plg},
    author	= {Leslie Lamport},
    title	= {The Mutual Exclusion Problem: Part\,{I}--A Theory of Interprocess Communication},
    journal	= jacm,
    volume	= 33,
    number	= 2,
    month	= apr,
    year	= 1986,
    pages	= {313--326},
    numpages	= {14},
    publisher	= {ACM},
    address	= {New York, NY, USA},
}

@article{Lamport86II,
    keywords	= {software solutions, N-thread, mutual exclusions},
    contributer	= {pabuhr@plg},
    author	= {Leslie Lamport},
    title	= {The Mutual Exclusion Problem: Part\,{II}--Statement and Solutions},
    journal	= jacm,
    volume	= 33,
    number	= 2,
    month	= apr,
    year	= 1986,
    pages	= {327--348},
    numpages	= {22},
    publisher	= {ACM},
    address	= {New York, NY, USA},
}

@article{Burns78,
    keywords	= {hardware, N-process solution, O(N)},
    contributer	= {pabuhr@plg},
    author	= {James E. Burns},
    title	= {Mutual Exclusion with Linear Waiting Using Binary Shared Variables},
    journal	= {SIGACT News},
    volume	= 10,
    number	= 2,
    month	= {Summer},
    year	= 1978,
    pages	= {42-47},
}

@inproceedings{Burns80,
    keywords	= {N-process software solution},
    contributer	= {pabuhr@plg},
    author	= {James E. Burns and Nancy A. Lynch},
    title	= {Mutual Exclusion using Indivisible Reads and Writes},
    booktitle	= {Proceedings of the 18th Annual Allerton Conference on Communications, Control and Computing, Monticello, Illinois, USA},
    year	= 1980,
    pages	= {833-842},
    note	= {\href{http://groups.csail.mit.edu/tds/papers/Lynch/allertonconf.pdf}{\textsf{http://\-groups.csail.mit.edu/\-tds/\-papers/\-Lynch/\-allertonconf.pdf}} [Accessed on March 2014]},
    optnote	= {\textsf{http://\-groups.csail.mit.edu/\-tds/\-papers/\-Lynch/\-allertonconf.pdf}},
}

@article{Peterson81,
    keywords	= {concurrency, critical section},
    contributer	= {pabuhr@plg},
    author	= {G. L. Peterson},
    title	= {Myths About the Mutual Exclusion Problem},
    journal	= ipl,
    year	= 1981,
    month	= jun,
    volume	= 12,
    number	= 3,
    pages	= {115-116},
}

% N

@article{Haddon77,
    keywords	= {monitors, nested monitor calls},
    contributer	= {pabuhr@plg},
    author	= {Bruce K. Haddon},
    title	= {Nested Monitor Calls},
    journal	= osr,
    volume	= 11,
    number	= 4,
    month	= oct,
    year	= 1977,
    pages	= {18-23},
}

@inproceedings{nesting,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {Lori A. Clarke and Jack C. Wilenden and Alexander L. Wolf},
    title	= {Nesting in {Ada} Programs is for the Birds},
    booktitle	= {Proceedings of the ACM-SIGPLAN Symposium on the {Ada}
        Programming Language},
    year	= 1980,
    month	= dec, pages = {139-145},
    note	= {SIGPLAN Notices, v. 15, n. 11},
    abstract	= {
        Given a data abstraction construct like the Ada package and in the
	light of current thoughts on programming methodology, we feel that
	nesting is an anachronism.  In this paper we propose a nest-free
	program style for Ada that eschews nested program units and
	declarations within blocks and instead heavily utilizes packages
	and context specifications as mechanisms for controlling
	visibility.  We view this proposal as a first step toward the
	development of programming methods that exploit the novel language
	features available in Ada.  Consideration of this proposal's
	ramifications for data flow, control flow, and overall program
	structure substantiates our contention that a tree structure is
	seldom a natural representation of a program and that nesting
	therefore generally interferes with program development and
	readability.
    }
}

@inproceedings{Buhr88,
    keywords	= {nested classes, persistence},
    contributer	= {pabuhr@plg},
    author	= {P. A. Buhr and C. R. Zarnke},
    title	= {Nesting in an Object Oriented Language is NOT for the Birds},
    booktitle	= {Proceedings of the European Conference on Object Oriented Programming},
    publisher	= {Springer-Verlag},
    volume	= 322,
    editor	= {S. Gjessing and K. Nygaard},
    address	= {Oslo, Norway},
    month	= aug,
    year	= 1988,
    pages	= {128-145},
    note	= {Lecture Notes in Computer Science, Ed. by G. Goos and J. Hartmanis},
}

@inproceedings{Thompson90new,
    keywords	= {Plan 9},
    contributer	= {pabuhr@plg},
    title	= {A New C Compiler},
    author	= {Ken Thompson},
    booktitle	= {Proceedings of the Summer 1990 UKUUG Conference},
    year	= 1990,
    pages	= {41--51},
    url		= {http://doc.cat-v.org/bell_labs/new_c_compilers/new_c_compiler.pdf}
}

@article{Trono94,
    author	= {John A. Trono},
    title	= {A New Exercise in Concurrency},
    journal	= {SIGCSE Bulletin},
    volume	= {26},
    number	= {3},
    month	= sep,
    year	= {1994},
    pages	= {8-10},
    publisher	= {ACM},
    address	= {New York, NY, USA},
}

@article{Lamport74,
    keywords	= {concurrency, N-Process solution, O(N)},
    contributer	= {pabuhr@plg},
    author	= {Leslie Lamport},
    title	= {A New Solution of Dijkstra's Concurrent Programming Problem},
    journal	= cacm,
    month	= aug,
    year	= 1974,
    volume	= 17,
    number	= 8,
    pages	= {453-455},
}

@article{landin,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {P. J. Landin},
    title	= {The Next 700 Programing Languages},
    journal	= cacm,
    year	= 1966,
    volume	= 9,
    pages	= {157-164},
}

@article{Herlihy05,
    keywords	= {Multiprocessors, concurrent data structures, dynamic data structures, memory management, nonblocking synchronization},
    contributer	= {pabuhr@plg},
    author	= {Maurice Herlihy and Victor Luchangco and Paul Martin and Mark Moir},
    title	= {Nonblocking Memory Management Support for Dynamic-sized Data Structures},
    journal	= tocs,
    volume	= 23,
    number	= 2,
    month	= may,
    year	= 2005,
    pages	= {146-196},
    numpages	= {51},
    publisher	= {ACM},
    address	= {New York, NY, USA},
}

% O

@inproceedings{oop:abcl/1,
    keywords	= {concurrency, OOPL, futures},
    contributer	= {gjditchfield@plg},
    author	= {Akinori Yonezawa and Jean-Pierre Briot and Etsuya Shibayama},
    title	= {Object-Oriented Concurrent Programming in {ABCL/1}},
    crossref	= "OOPSLA86",
    pages	= {258-268},
    comment	= {
	Actions for messages sent to an object are executed concurrently
	iff the object has no members.  A select construct specifies a set
	of message patterns.

	Express messages have priority.  If an express message arrives
	while an ordinary message is being processed, the action for the
	ordinary message is suspended or aborted and the action for the
	express message is executed.  The sender decides which class a
	message belongs in.  Non-interruptible sections can be defined.

	Message sends can be non-blocking, or can block until a reply is
	received, at the sender's option.  The receiver can continue to
	execute after sending the reply.

	Replies can send back ``futures'', and put values in them later.
	Futures are queues of values, not single values.  The caller can
	use a ``ready?'' predicate to test for empty queue, or can use
	operations to get the first or all queue elements; these operations
	block if the queue is empty.
    }
}

@techreport{Schmidt95,
    keywords	= {ACE, concurrency, library},
    contributer	= {pabuhr@plg},
    author	= {Douglas C. Schmidt},
    title	= {An OO Encapsulation of Lightweight OS Concurrency Mechanisms in the {ACE} Toolkit},
    institution	= {Washington University in St. Louis},
    year	= 1995,
    number	= 31,
    note	= {{\small\textsf{http://\-www.cs.wustl.edu/\-\char`\~schmidt/\-PDF/\-IPC\_SAP-92.pdf}}},
}

@inproceedings{OOEx,
    keywords	= {Exceptions, object-oriented programming languages},
    contributer	= {gjditchfield@plg},
    author	= {Christophe Dony},
    title	= {An Object-oriented Exception Handling System for an Object-oriented Language},
    booktitle	= {ECOOP '88. European Conference on Object-Oriented Programming},
    year	= 1988,
    pages	= {146-161},
    editor	= {S. Gjessing and K. Nygaard},
    organization= {DND, The Norwegian Computer Society},
    publisher	= {Springer-Verlag},
    comment	= {
	   Objectives:
	   - Users can define new exceptions.
	   - Default handlers can be attached to exceptions.
	   - Handlers can be attached to classes.
	   - Handlers can be attached to dynamic entities (expressions).
	   - Exceptions propagate first along the invocation chain.
	   - Exceptions should be hierarchically organized classes.
	   - Handlers should take into account the exception hierarchy (i.e.,
	     should handle raising of sub-exceptions).
	   The ``exceptional-event'' class has two subclasses.  ``Warning''
	   has a ``resume'' method, and ``error'' has ``exit'' and
	   ``retry'' methods.  Signalling an exception creates an instance
	   of the exception, whose members are used to pass information
	   back to the handler.  Handlers are instances of class
	   ``protect-handler'' with a method ``protect {\em expression}'',
	   or are methods defined for the class or the exception.
    }
}

@article{CommonObjects,
    author	= {A. Snyder},
    title	= {Object-Oriented Programming for Common Lisp},
    address	= {Palo Alto CA},
    year	= 1985,
    publisher	= {Software Technology Laboratory, Hewlett-Packard Laboratories},
    journal	= {Report ATC-85-1},
}

@book{objective-c,
    keywords	= {},
    author	= {Brad J. Cox},
    title	= {Object-oriented programming; an evolutionary approach},
    publisher	= {Addison-Wesley},
    year	= 1986
}

@book{Beta,
    keywords	= {Beta, object oriented, concurrency, exceptions},
    contributer	= {pabuhr@plg},
    author	= {Ole Lehrmann Madsen and Birger M{\o}ller-Pedersen and Kristen Nygaard},
    title	= {Object-oriented Programming in the {BETA} Programming Language},
    publisher	= {Addison-Wesley},
    year	= 1993,
}

@article{Flavors,
    author	= {D. A. Moon},
    title	= {Object-Oriented Programming with Flavors},
    address	= {Portland OR},
    month	= sep,
    year	= 1986,
    journal	= {Proc. ACM Conf. on Object-Oriented Systems, Languages and Applications},
}

@article{Buhr00b,
    keywords	= {concurrency, C++, real-time},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr and Ashif S. Harji and Philipp E. Lim and Jiongxiong Chen},
    title	= {Object-Oriented Real-Time Concurrency},
    journal	= sigplan,
    volume	= 35,
    number	= 10,
    month	= oct,
    year	= 2000,
    pages	= {29-46},
    note	= {OOPSLA'00, Oct. 15--19, 2000, Minneapolis, Minnesota, U.S.A.},
}

@book{Meyer88,
    keywords	= {Eiffel},
    contributer	= {pabuhr@plg},
    author	= {Bertrand Meyer},
    title	= {Object-oriented Software Construction},
    publisher	= {Prentice Hall},
    year	= {1988},
    series	= {Prentice Hall International Series in Computer Science},
}

@article{objectPascal,
    keywords	= {objects, modules},
    contributer	= {gjditchfield@plg},
    author	= {Larry Tesler},
    title	= {Object Pascal Report},
    journal	= {Structured Language World},
    year	= 1985,
    volume	= 9,
    number	= 3,
}

@misc{obj-c:next,
    keywords	= {categories, protocols, Objective C},
    contributor	= {gjditchfield@angus},
    author	= {NeXT Computer, Inc.},
    title	= {Objective C Extensions},
    howpublished= {On-line documentation in ``NEXTSTEP 3.1 Developer''},
    year	= 1993
}

@book{Galletly96,
    keywords	= {occam},
    author	= {John Galletly},
    title	= {{OCCAM} 2: Including {OCCAM} 2.1},
    publisher	= {{UCL} (University College London) Press Ltd.},
    edition	= {second},
    year	= 1996,
}

@techreport{Morrison88,
    keywords	= {objects, concurrency, persistence},
    contributer	= {pabuhr@plg},
    author	= {R. Morrison and A. L. Brown and R. Carrick and R. Connor and A. Dearle},
    title	= {On the integration of Object-Oriented and Process-Oriented computation in persistent environments},
    institution	= {Department of Computational Science, University of St. Andrews, Scotland},
    number	= {PPRR 57},
    month	= jan,
    year	= 1988,
}

@article{Peterson73,
    keywords	= {goto, structured programming},
    contributer	= {pabuhr@plg},
    author	= {W. W. Peterson and T. Kasami and N. Tokura},
    title	= {On the Capabilities of While, Repeat, and Exit Statements},
    journal	= cacm,
    month	= aug,
    year	= 1973,
    volume	= 16,
    number	= 8,
    pages	= {503-512}
}

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

@techreport{OpenMP,
    keywords	= {concurrency, openmp, spmd},
    contributer	= {pabuhr@plg},
    author	= {OpenMP Architecture Review Board},
    title	= {OpenMP Application Program Interface, Version 4.0},
    month	= jul,
    year	= 2013,
    note	= {\href{http://www.openmp.org/mp-documents/OpenMP4.0.0.pdf}{\textsf{http://www.openmp.org/mp-documents/OpenMP4.0.0.pdf}}},
}

@book{Deitel04,
    keywords	= {concurrency, operating systems},
    contributer	= {pabuhr@plg},
    author	= {Harvey M. Deitel and Paul J. Deitel and David R. Choffnes},
    title	= {Operating Systems},
    publisher	= {Pearson Prentice-Hall},
    year	= 2004,
    edition	= {third},
}

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

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

@book{Silberschatz91,
    keywords	= {concurrency, operating systems},
    contributer	= {pabuhr@plg},
    author	= {Abraham Silberschatz and James L. Peterson and Peter Galvin},
    title	= {Operating System Concepts},
    publisher	= {Addision-Wesley},
    year	= 1991,
    edition	= {third},
}

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

@book{Hansen73,
    keywords	= {monitors},
    contributer	= {pabuhr@plg},
    author	= {Per {Brinch Hansen}},
    title	= {Operating System Principles},
    publisher	= {Prentice-Hall},
    year	= 1973,
}

@book{Bic03,
    keywords	= {concurrency, operating systems},
    contributer	= {pabuhr@plg},
    author	= {Lubomir F. Bic and Alan C. Shaw},
    title	= {Operating System Principles},
    publisher	= {Prentice-Hall},
    year	= 2003,
}

@techreport{milner88,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {Robin Milner},
    title	= {Operational and Algebraic Semantics of Concurrent Processes},
    institution	= {Laboratory for Foundations of Computer Science},
    year	= 1988,
    address	= {Department of Computer Science, University of Edinburgh, Edinburgh EH9 3JZ},
    month	= feb,
    number	= {ECS-LFCS-88-46}
}

@article{Ford82,
    keywords	= {},
    contributer	= {pabuhr@plg},
    author	= {G. Ford and B. Hansche},
    title	= {Optional, Repeatable, and Varying Type Parameters},
    journal	= sigplan,
    volume	= 17,
    number	= 2,
    month	= feb,
    year	= 1982,
    pages	= {41-48},
}

@manual{pli,
    keywords	= {PL/I},
    contributer	= {gjditchfield@plg},
    key		= {IBM},
    title	= {{OS} and {DOS} {PL/I} Reference Manual},
    organization= {International Business Machines},
    edition	= {first},
    month	= sep,
    year	= 1981,
    note	= {Manual GC26-3977-0},
}

@techreport{D:overload,
    keywords	= {overload resolution, compilation},
    contributer	= {gjditchfield@plg},
    author	= {M. Dausmann et. al.},
    title	= {Overloading in {Ada}},
    institution	= {Universitat Karlsruhe},
    year	= 1979,
    number	= {23/79},
    comment	= {
	Probably the earliest description of the two-pass (bottom-up,
	top-down) overload resolution algorithm. See also
	\cite{PW:overload,WS:overload,PDM:overload,Cor:overload,Bak:overload}.
    }
}

@article{EB87,
    keywords	= {packages, private types, assignment, equality},
    contributer	= {gjditchfield@plg},
    author	= {J. Dana Eckart and Richard J. LeBlanc},
    title	= {Overloading in the {Ada} Language: Is it too restrictive?},
    journal	= {Computer Languages},
    year	= 1987,
    volume	= 12, number = {3/4}, pages = {163-172},
    abstract	= {
        Packages in the Ada language provide a mechanism for extending the
	language through the development of additional data types.  Such
	types can be better integrated into the language using operator
	overloading; however, key limitations prevent new types from being
	transparently integrated into the language.  Allowing function
	names to overload private type names would give a cleaner and
	clearer mechanism for building values of these types.  Furthermore,
	by allowing redefinitions of ``:='' and by making it easier to
	overload ``='' for private types, Ada coud be transformed into a
	more expressive language.
    }
}

@article{PW:overload,
    keywords	= {compilation},
    contributer	= {gjditchfield@plg},
    author	= {Guido Persch and Georg Winterstein and Manfred Dausman and Sophia Drossopoulou},
    title	= {Overloading in Preliminary {Ada}},
    journal	= sigplan,
    year	= 1980,
    month	= nov, volume = 15, number = 11, pages = {47-56},
    note	= {Proceedings of the ACM-SIGPLAN Symposium on the {Ada} Programming
	 Language}, 
    comment	= {
        The two-pass (bottom-up, then top-down) algorithm, with a proof
	that two passes suffice.  See also \cite{D:overload}.
    }
}

@article{SR,
    keywords	= {concurrency, messages, rendezvous},
    contributer	= {pabuhr@plg},
    author	= {Gregory R. Andrews and Ronald A. Olsson and Michael Coffin and
		  Irving Elshoff and Kelvin Nilsen and Titus Purdin and Gregg Townsend},
    title	= {An Overview of the {SR} Language and Implementation},
    journal	= toplas,
    month	= jan,
    year	= 1988,
    volume	= 10,
    number	= 1,
    pages	= {51-86},
}

% P

@article{Andrews91,
    keywords	= {general concurrency},
    contributer	= {pabuhr@plg},
    author	= {Gregory R. Andrews},
    title	= {Paradigms for Process Interaction in Distributed Programs},
    journal	= acmcs,
    volume	= 23,
    number	= 1,
    month	= mar,
    year	= 1991,
    pages	= {49-90},
}

@book{PPC++,
    keywords	= {concurrency, parallel, distributed, C++},
    contributer	= {pabuhr@plg},
    editor	= {Gregory V. Wilson and Paul Lu},
    title	= {Parallel Programming in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    publisher	= {MIT Press},
    series	= {Scientific and Engineering Computation Series},
    year	= 1996,
    pages	= {1-42},
}

@incollection{Stroustrup96,
    keywords	= {concurrency, C++},
    contributer	= {pabuhr@plg},
    author	= {Bjarne Stroustrup},
    title	= {A Perspective on Concurrency in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    editor	= {Gregory V. Wilson and Paul Lu},
    booktitle	= {Parallel Programming in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    publisher	= {MIT Press},
    series	= {Scientific and Engineering Computation Series},
    year	= 1996,
    pages	= {xxvi-xxvii},
}

@incollection{Yang96b,
    keywords	= {concurrency, C++},
    contributer	= {pabuhr@plg},
    author	= {Shelby X. Yang and Dennis Gannon and Peter Beckman and Jacob Gotwals and Neelakantan Sundaresan},
    editor	= {Gregory V. Wilson and Paul Lu},
    title	= {p{C}++},
    booktitle	= {Parallel Programming in {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    publisher	= {MIT Press},
    address	= {Cambridge, MA, USA},
    series	= {Scientific and Engineering Computation Series},
    pages	= {507-546},
    year	= 1996,
}

@article{goguen84,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {Goseph A. Goguen},
    title	= {Parameterized Programming},
    journal	= ieeese,
    year	= 1984,
    month	= sep, volume = "SE-10", number = 5, pages = {528-543},
    abstract	= {
        Parameterized programming is a powerful technique for the reliable
	reuse of software.  In this technique, modules are parameterized
	over very general interfaces that describe what properties of an
	environment are required for the module to work correctly.
	Reusability is enhanced by the flexibility of the parameterization
	mechanism proposed here.  Reliability is further enhanced by
	permitting interface requirements to include more than purely
	syntactic information.  This paper introduces three new ideas that
	seem especially useful in supporting parameterized programming: 1)
	{\em theories}, which declare global properties of program modules
	and interfaces; 2) {\em views}, which connect theories with program
	modules in an elegant way; and 3) {\em module expressions}, a kind
	of general structured program transformation which produces new
	modules by modifying and combining existing modules.  Although
	these ideas are illustrated with some simple examples in the OBJ
	programming language, they should also be taken as proposals for an
	Ada library system, for adding modules to Prolog, and as
	considerations for future language design efforts.  OBJ is an
	ultra-high level programming language, based upon rewrite rules,
	that incorporates these ideas, and many others from modern
	programming methodology.
    }
}

@inproceedings{c++:templates,
    author	= {Bjarne Stroustrup},
    contributer	= {gjditchfield@plg},
    title	= {Parameterized Types for {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    booktitle	= {USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Conference},
    organization= {USENIX Association},
    year	= 1988, pages = {1-18}
}

@inproceedings{Boehm85,
    keywords	= {second-order unification},
    contributer	= {gjditchfield@plg},
    author	= {Hans-J. Boehm},
    title	= {Partial Polymorphic Type Inference is Undecidable},
    booktitle	= {26th Annual Symposium on Foundations of Computer Science},
    year	= 1985,
    pages	= {339-345},
    organization= {IEEE Computer Society},
    publisher	= {IEEE Computer Society Press},
    address	= {1730 Massachusetts Avenue, N.W, Washington, D.C. 20036-1903},
    summary	= {
        Given a base typed lambda calculus with function types, type
	abstractions, and a recursive expression \(\mbox{fix } x:t.e\),
	then type inference for the partially typed language 
	\begin{eqnarray}
	\lambda x:\tau.e	&\Rightarrow& \lambda x.e	\\
	\mbox{fix } x:\tau.e	&\Rightarrow& \mbox{fix } x.e	\\
	e \tau			&\Rightarrow& e ?
	\end{eqnarray}
	is undecidable.
    }
}

@book{Pascal,
    keywords	= {Pascal},
    contributer	= {pabuhr@plg},
    author	= {Kathleen Jensen and Niklaus Wirth},
    title	= {{P}ascal User Manual and Report},
    publisher	= {Springer--Verlag},
    year	= 1985,
    edition	= {third},
    note	= {Revised by Andrew B. Mickel and James F. Miner, ISO Pascal Standard}
}

@book{Pascal:old,
    keywords	= {Pascal},
    contributer	= {pabuhr@plg},
    author	= {Kathleen Jensen and Niklaus Wirth},
    title	= {{P}ascal User Manual and Report},
    publisher	= {Springer--Verlag},
    year	= 1975,
    edition	= {first},
}

@article{Turba85,
    keywords	= {Pascal, exception handling, inheritance},
    contributer	= {pabuhr@plg},
    author	= {Thomas N. Turba},
    title	= {The {P}ascal Exception Handling Proposal},
    journal	= sigplan,
    volume	= 20,
    number	= 8,
    month	= aug,
    year	= 1985,
    pages	= {93-98},
}

@manual{Pascal/VS,
    keywords	= {PL/I},
    contributer	= {pabuhr@plg},
    key		= {IBM},
    title	= {{P}ascal/{VS} Language Reference Manual},
    organization= {International Business Machines},
    edition	= {first},
    year	= 1981,
    note	= {Manual SH20-6168-1},
}

@article{Anderson90,
    keywords	= {spin locks, back off, performance},
    contributer	= {pabuhr@plg},
    author	= {Thomas E. Anderson},
    title	= {The Performance of Spin Lock Alternatives for Shared-Memory Multiprocessors},
    journal	= ieeepds,
    month	= jan,
    year	= 1990,
    volume	= 1,
    number	= 1,
    pages	= {6-16},
}

@article{poly,
    keywords	= {Poly, Standard ML, Russell, persistence},
    contributer	= {gjditchfield@plg},
    author	= {David C. J. Matthews},
    title	= {Poly Manual},
    journal	= sigplan,
    month	= sep, year = 1985,
    volume	= 20, number = 9, pages = {52-76}
}

@techreport{Atkinson87b,
    keywords	= {naming, persistence},
    contributer	= {pabuhr@plg},
    author	= {M. P. Atkinson and R. Morrison},
    title	= {Polymorphic Names and Iterations},
    institution	= {Universities of Glasgow and St. Andrews, Scotland},
    number	= {PPRR-53-87},
    month	= nov,
    year	= 1987,
}

@book{Harland,
    keywords	= {},
    author	= {David M. Harland},
    title	= {Polymorphic Programming Languages: Design and Implementation},
    publisher	= {Ellis Horwood},
    year	= 1984,
    series	= {Computers and their Applications},
    address	= {Market Cross House, Cooper Street, Chichester, West Sussex,
	PO19 1EB, England},
    summary	= {
        The principles of Procedural Abstraction, Data Type Completeness,
        Declaration Correspondence, and Orthogonality are ruthlessly applied
        to the design of a polymorphic language.
    }
}

@unpublished{poa,
    keywords	= {Force N, type inference, reusability, transcendance},
    contributer	= {gjditchfield@plg},
    author	= {G. V. Cormack and A. K. Wright},
    title	= {Polymorphism, Overloading, and Abstraction},
    note	= {personal communication}
}

@inproceedings{forceone:impl,
    keywords	= {Parametric polymorphism, ForceOne},
    contributer	= {gjditchfield@plg},
    author	= {G. V. Cormack and A. K. Wright},
    title	= {Polymorphism in the Compiled Language {ForceOne}},
    booktitle	= {Proceedings of the 20th Hawaii International Conference on Systems Sciences},
    month	= jan,
    year	= 1987,
    pages	= {284-292},
}

@incollection{POOL-T,
    keywords	= {objects, concurrency},
    contributer	= {pabuhr@plg},
    author	= {Pierre America},
    title	= {POOL-T: A Parallel Object-Oriented Language},
    booktitle	= {Object-Oriented Concurrent Programming},
    publisher	= {The MIT Press},
    year	= 1987,
    pages	= {199-220},
    editor	= {Akinori Yonezawa and Mario Tokoro}
}

@article{Hardgrave76,
    keywords	= {positional, keyword, parameters, arguments},
    contributer	= {pabuhr@plg},
    author	= {W. T. Hardgrave},
    title	= {Positional versus Keyword Parameter Communication in Programming Languages},
    journal	= sigplan,
    volume	= 11,
    number	= 5,
    month	= may,
    year	= 1976,
    pages	= {52-58},
}

@book{PowerPC,
    key		= {PowerPC processor},
    title	= {Programming Environments Manual for 32-Bit Implementations of the PowerPC ArchitectureARM Architecture},
    publisher	= {Freescale Semiconductor},
    volume	= {MPCFPE32B},
    edition	= {Rev. 3},
    month	= 9,
    year	= 2005,
}

@article{Ada:preliminary,
    keywords	= {Ada},
    contributer	= {pabuhr@plg},
    author	= {Jean D. Ichbiah and Bernd Krieg-Brueckner and Brian A. Wichmann
		   and Henry F. Ledgard and Jean-Claude Heliard and Jean-Raymond Abrial
		   and John G. P. Barnes and Olivier Roubine},
    title	= {Preliminary {Ada} Reference Manual},
    journal	= sigplan,
    volume	= 14,
    number	= 6,
    month	= jun,
    year	= 1979,
    note	= {Part A},
}

@techreport{Forsythe,
    author	= {John C. Reynolds},
    title	= {Preliminary Design of the Programming Language {Forsythe}},
    institution	= {Carnegie Mellon University},
    number	= {CMU-CS-88-159},
    month	= jun,
    year	= 1988,
}

@article{PRESTO,
    keywords	= {concurrency, threads},
    contributer	= {dgharriss@plg},
    author	= {B. N. Bershad and E. D. Lazowska and H. M. Levy},
    title	= {{PRESTO}: A System for Object-oriented Parallel Programming},
    journal	= spe,
    volume	= 18,
    number	= 8,
    month	= aug,
    year	= 1988,
    pages	= {713-732}
}

@book{Ben-Ari82,
    keywords	= {concurrency, parallel, programming languages},
    contributer	= {pabuhr@plg},
    author	= {Mordechai Ben-Ari},
    title	= {Principles of Concurrent Programming},
    publisher	= {Prentice-Hall International},
    year	= 1982,
}

@book{Tennent81,
    author	= {R. D. Tennent},
    title	= {Principles of Programming Languages},
    publisher	= {Prentice-Hall International},
    year	= 1981,
    series	= {Series in Computer Science}
}

@article{Lister77,
    keywords	= {monitors, nested monitor calls},
    contributer	= {pabuhr@plg},
    author	= {Andrew Lister},
    title	= {The Problem of Nested Monitor Calls},
    journal	= osr,
    volume	= 11,
    number	= 3,
    month	= jul,
    year	= 1977,
    pages	= {5-7},
}

@article{psa:persistence,
    keywords	= {persistence, first-class procedures, closure, PS-Algol,
	Abstract Data Types},
    contributer	= {gjditchfield@plg},
    author	= {Malcolm P. Atkinson and Ronald Morrison},
    title	= {Procedures as Persistent Data Objects},
    journal	= toplas,
    volume	= {7},    number = {4},
    pages	= {539-559},
    month	= oct, year = 1985,
    comment	= {
    	PS-Algol has ``structures'', accessible only through ``pntrs''.
	Pntrs can refer to any type of structure.  Field references involve
	a run-time check.  This, plus first-class procedures, can simulate
	abstract data types.  Procedure variables operating on pntrs
	simulate ADT operations.  A block defines a structure to implement
	the ADT, and assigns procedures to the variables.  Functions
	returning structures containing procedures  simulate multiple
	implementations and parameterized ADTs.

	An outer procedure that returns a procedure that contains
	(non-local) references to the outer procedure's parameters
	implements partial evaluation.

	Modules can be simulated like ADT's.  The module itself is a
	structure instance that is placed in persistent storage, and the
	module is imported by fetching it from the persistent store.
	Multiple instances of modules are easy.  Installation of new
	versions can be done by replacing the version in the database.
    }
}

@article{Procol89,
    keywords	= {active objects, object-oriented languages,
	object-based languages, explicit per-object protocol},
    contributer	= {akgoel@plg},
    author	= {Jan van den Bos and Chris Laffra},
    title	= {PROCOL: A Parallel Object Language with Protocols},
    journal	= sigplan,
    volume	= 24,
    number	= 10,
    month	= oct,
    year	= 1989,
    pages	= {95-102},
    note	= {Proceedings of the OOPSLA'89 Conference, Oct. 1--6, 1989, New Orleans, Lousiana},
    abstract	= {},
}

@book{Butenhof97,
    keywords	= {PThreads, concurrency},
    contributer	= {pabuhr@plg},
    author	= {David R. Butenhof},
    title	= {Programming with {POSIX} Threads},
    publisher	= {Addison-Wesley},
    series	= {Professional Computing},
    year	= 1997,
}

@book{SETL,
    keywords	= {SETL},
    contributer	= {pabuhr@plg},
    author	= {J. T. Schwartz and R. B. K. Dewar and E. Dubinsky and E. Schonberg},
    title	= {Programming with Sets: An Introduction to {SETL}},
    publisher	= {Springer-Verlag},
    year	= 1986,
}

@book{Genuys68,
    keywords	= {contains Dijkstra's Cooperating Sequential Processes},
    contributer	= {pabuhr@plg},
    editor	= {F. Genuys},
    title	= {Programming Languages},
    publisher	= {Academic Press},
    address	= {London, New York},
    year	= 1968,
    note	= {NATO Advanced Study Institute, Villard-de-Lans, 1966}
}

@manual{ANSI99:C,
    keywords	= {ANSI C 99},
    contributer	= {pabuhr@plg},
    title	= {Programming Languages -- {C}},
    organization= {International Standard ISO/IEC 9899:1999 (E)},
    publisher   = {American National Standards Institute},
    address	= {www.ansi.org},
    year	= 1999,
}

@manual{ANSI98:C++,
    keywords	= {ANSI C++ 98},
    contributer	= {pabuhr@plg},
    key		= {C++98},
    title	= {Programming Languages -- {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    organization= {International Standard ISO/IEC 14882:1998 (E)},
    publisher   = {American National Standards Institute},
    address	= {www.ansi.org},
    year	= 1998,
}

@manual{ANSI14:C++,
    keywords	= {ISO/IEC C++ 14},
    contributer	= {pabuhr@plg},
    key		= {C++14},
    title	= {Programming Languages -- {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    edition	= {fourth},
    organization= {International Standard ISO/IEC 14882:2014 (E)},
    publisher   = {International Standard Organization},
    address	= {http://www.iso.org},
    year	= 2014,
}

@manual{MS:VisualC++,
    keywords	= {Microsoft Visual C++},
    contributer	= {pabuhr@plg},
    title	= {Microsoft Visual {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} .NET Language Reference},
    organization= {Microsoft Corporation},
    year	= 2002,
    note	= {Microsoft Press, Redmond, Washington, U.S.A.},
}

@article{HasselBring00,
    keywords	= {concurrency, prototyping},
    contributer	= {pabuhr@plg},
    author	= {Wilhelm Hasselbring},
    title	= {Programming Languages and Systems for Prototyping Concurrent Applications},
    journal	= acmcs,
    volume	= 32,
    number	= 1,
    month	= mar,
    year	= 2000,
    pages	= {43-79},
}

@article{LLgen,
    keywords	= {ll(1), parser generator, separate compilation},
    contributer	= {gjditchfield@plg},
    author	= {Dick Grune and Ceriel J. J. Jacobs},
    title	= {A Programmer-friendly LL(1) Parser Generator},
    journal	= spe,
    month	= jan, year = 1988,
    volume	= 18, number = 1, pages = {29-33},
    comment	= {
        LLgen generates C-language recursive-descent parsers.  The input
        contains procedure-like rules with alternation and repetition
        constructs on the right, and (typed) parameters on the left.
        C actions are specified between items in the right side.
        Alternation and repetition (reduce and shift) conflicts can be
        resolved statically or at run time.

	A grammar can be specified in several files.  All files must be
        submitted to LLgen at once, but if the C file generated is no
        different from the old version, then the old version is not
        replaced and hence need not be recompiled, which saves lots of
        time.

	When an incorrect token is found, the automatic error recovery
	algorithm discards tokens until an ``acceptable'' token is found;
	if the acceptable token is not correct, a correct one is inserted.
    }
}

@techreport{russell,
    keywords	= {Russell},
    contributer	= {gjditchfield@plg},
    author	= {H. Boehm and A. Demers and J. Donahue},
    title	= {A Programmer's Introduction to Russell},
    institution	= {Rice University},
    year	= 1985,
    number	= {85-16}
}

@techreport{PDM89,
    keywords	= {existential types, universal types},
    contributer	= {gjditchfield@plg},
    author	= {Benjamin Pierce and Scott Dietzen and Spiro Michaylov},
    title	= {Programming in Higher-Order Typed Lambda Calculi},
    institution	= {School of Computer Science, Carnegie Mellon University},
    year	= 1989,
    address	= {Pittsburg, PA 15213-3890},
    month	= mar, number = {CMU-CS-89-111},
    abstract	= {
	This tutorial presents a hierarchy of increasingly powerful
	languages, beginning with Church's simply typed
	\(\lambda\)-calculus (\(F_1\)) and the second-order polymorphic
	\(\lambda\)-calculus of Girard and Reynolds, and culminating in a
	fragment of Girard's \(\omega\)-order polymorphic
	\(\lambda\)-calculus (\(F_\omega\)).  Our focus throughout is on
	the unusual style of programming that arises in these languages,
	where all functions are total and the primary control construct is
	iteration rather than general recursion.
    }
}

@book{Modula-2,
    keywords	= {modules, coroutines},
    contributer	= {pabuhr},
    author	= {Niklaus Wirth},
    title	= {Programming in Modula-2},
    publisher	= {Springer-Verlag},
    year	= 1988,
    edition	= {fourth},
    series	= {Texts and Monographs in Computer Science},
}

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

@manual{ada:old,
    keywords	= {Ada, packages, tasks, exceptions},
    contributer	= {gjditchfield@plg},
    title	= {The Programming Language {Ada}: Reference Manual},
    organization= {United States Department of Defense},
    publisher	= {Springer-Verlag},
    year	= 1981
}

@book{Ghezzi,
    keywords	= {},
    author	= {Carlo Ghezzi and Mehdi Jazayeri},
    title	= {Programming Language Concepts},
    publisher	= {Wiley},
    year	= 1982
}

@article{ConcurrentPascal,
    keywords	= {Concurrent Pascal},
    contributer	= {pabuhr@plg},
    author	= {Per {Brinch Hansen}},
    title	= {The Programming Language Concurrent Pascal},
    journal	= ieeese,
    volume	= 2,
    month	= jun,
    year	= 1975,
    pages	= {199-206}
}

@phdthesis{Buhr85:thesis,
    keywords	= {},
    contributer	= {pabuhr@plg},
    author	= {P. A. Buhr},
    title	= {A Programming System},
    school	= {University of Manitoba},
    year	= {1985}
}

@techreport{pierce91,
    keywords	= {typed lambda calculus},
    contributer	= {gjditchfield@plg},
    author	= {Benjamin C. Pierce},
    title	= {Programming with Intersection Types, Union Types, and Polymorphism},
    institution	= {Carnegie Mellon University},
    year	= 1991,
    month	= feb, number = "CMU-CS-91-106",
    annote	= {
        Discusses a typed lambda calculus with
	\begin{itemize}
	\item
	Intersection types \(\tau = \tau_1\wedge\tau_2\) with \(\tau \le
	\tau_i\) for all \(i\).
	\item
	Union types \(\tau = \tau_1\vee\tau_2\) with \(\tau_i \le \tau\),
	and with implicit coercions from \(tau_i\) to \(\tau\).  Only
	operations valid for both element types can be applied to the
	union; there are no projections.  Union types are to variant
	records as set union is to disjoint set union.
	\item
	Function types and universal quantification, with subtyping rules.
	When functions and arguments intersections, the result of
	application is the intersection of all valid combinations.
	\item
	Distribution rules for combinations of types.
	\item
	"Union elimination": "case \(x = e\) of \(e'\)", where \(e\) is a
	union, has type \(\tau\) if \(e'\) has that type with \(x\) having
	every element type of the union.
	\item
	"Finitary quantification": "for \(t\) in \(\tau_1,\ldots,\tau_n.e\)"
	typechecks \(e\) with \(t\) bound to each choice, and intersects
	the results.
	\end{itemize}

	Examples include: type of "natural" numbers, treated as a union of
	"zero" and "positive" types; default parameters, faked by using an
	argument that is an intersection of a data type and a function
	taking an explicit argument.

	Unions can be mostly faked, according to Mitchell:
	\[\tau_1\vee\tau_2 \equiv
	     \forall\tau.(\tau_1\on\tau)\wedge(\tau_2\on\tau)\]
    }
}

@article{promises,
    keywords	= {futures, Argus, call streams, rpc},
    contributer	= {gjditchfield@plg},
    author	= {Barbara Liskov and Liuba Shrira},
    title	= {Promises: Linguistic Support for Efficient Asynchronous
	  Procedure Calls in Distributed Systems},
    journal	= sigplan,
    year	= 1988,
    month	= jul, volume = 23, number = 7, pages = {260-267},
    note	= {Proceedings of the SIGPLAN '88 Conference on Programming Language
	 Design and Implementation},
    abstract	= {
        This paper deals with the integration of an efficient asynchronous
	remote procedure call mechanism into a programming language.  It
	describes a new data type called a {\em promise} that was designed
	to support asynchronous calls.  Promises allow a caller to run in
	parallel with a call and to pick up the results of the call,
	including any exceptions it raises, in a convenient and type-safe
	manner.  The paper also discusses efficient composition of
	sequences of asynchronous calls to different locations in a
	network. 
    }
}

@article{Cook89,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {W. R. Cook},
    title	= {A Proposal for Making {Eiffel} Type-safe},
    journal	= {The Computer Journal},
    year	= 1989,
    volume	= 32, number = 4, pages = {305-311},
    abstract	= {
        
    }
}

@inproceedings{Foxall79,
    keywords	= {},
    contributer	= {pabuhr@plg},
    author	= {D. G. Foxall and M. L. Joliat and R. F. Kamel and J. J. Miceli},
    title	= {{PROTEL}: A High Level Language for Telephony},
    booktitle	= {Proceedings 3rd International Computer Software and Applications Conference},
    month	= nov,
    year	= 1979,
    pages	= {193-197},
}

@techreport{PS-Algol,
    keywords	= {algol, persistence},
    contributer	= {pabuhr@plg},
    key		= {PS-Algol},
    title	= {The {PS-Algol} Reference Manual, 4th Ed.},
    author	= {},
    institution	= {University of Glasgow and St. Andrews, Scotland},
    number	= {PPRR 12},
    month	= jun,
    year	= 1987,
}

@manual{Python,
    keywords	= {Python},
    contributer	= {pabuhr},
    title	= {Python Reference Manual, Release 2.5},
    author	= {Guido van Rossum},
    organization= {Python Software Foundation},
    month	= sep,
    year	= 2006,
    note	= {Fred L. Drake, Jr., editor},
}

% Q

@article{Grossman06,
 keywords = {Cyclone, existential types, polymorphism, type variables},
 contributer = {a3moss@plg},
 author = {Grossman, Dan},
 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},
 numpages = {47},
 url = {http://doi.acm.org.proxy.lib.uwaterloo.ca/10.1145/1133651.1133653},
 doi = {10.1145/1133651.1133653},
 acmid = {1133653},
 publisher = {ACM},
 address = {New York, NY, USA},
}

@article{Hoare61,
    keywords	= {quick sort},
    contributer	= {pabuhr@plg},
    author	= {C. A. R. Hoare},
    title	= {Algorithms 63/64: Partition/Quicksort},
    journal	= cacm,
    volume	= 4,
    number	= 7,
    month	= jul,
    year	= 1961,
    pages	= {321},
}

% R

@article{Ada:rationale:preliminary,
    keywords	= {Ada},
    contributer	= {pabuhr@plg},
    author	= {J. D. Ichbiah and J. C. Heliard and O. Roubine and
		   J. G. P. Barnes and B. Krieg-Brueckner and B. A. Wichmann},
    title	= {Rationale for the Design of the {ADA} Programming Language},
    journal	= sigplan,
    volume	= 14,
    number	= 6,
    month	= jun,
    year	= 1979,
    note	= {Part B},
}

@book{Ada:rationale,
    keywords	= {Ada},
    contributer	= {pabuhr@plg},
    author	= {Jean D. Ichbiah and John G. P. Barnes and Robert J. Firth and Mike Woodger},
    title	= {Rationale for the Design of the {ADA} Programming Language},
    publisher	= {Under Secretary of Defense, Research and Engineering},
    year	= 1986,
    address	= {Ada Joint Program Office, OUSDRE(R\&AT), The Pentagon, Washington, D. C., 20301, U.S.A.},
}

@manual{Ada95,
    keywords	= {Ada},
    contributer	= {pabuhr@plg},
    title	= {{A}da Reference Manual},
    edition	= {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}},
    organization = {Intermetrics, Inc.},
    month	= dec,
    year	= 1995,
    note	= {Language and Standards Libraries}
}

@manual{Ada12,
    keywords	= {Ada},
    contributer	= {pabuhr@plg},
    title	= {Programming languages -- {Ada}},
    edition	= {third},
    organization= {International Standard ISO/IEC 1989:2014},
    publisher   = {International Standard Organization},
    address	= {http://www.iso.org},
    year	= 2012,
}

@manual{Ada95:annotated,
    keywords	= {Ada},
    contributer	= {pabuhr@plg},
    title	= {Annotated {A}da Reference Manual},
    edition	= {International Standard {ISO}/{IEC} {8652:1995(E)} with {COR.1:2000}},
    organization = {Intermetrics, Inc.},
    month	= dec,
    year	= 1995,
    note	= {Language and Standards Libraries}
}

@book{JavaRT00,
    keywords	= {real time, draft},
    contributer	= {pabuhr@plg},
    author	= {Greg Bollella and Ben Brosgol and Peter Dibble and Steve Furr and James Gosling and David Hardin and Mark Turnbull},
    title	= {The Real-Time Specification for {J}ava},
    series	= {The Real-Time for Java Expert Group, {\small\textsf{http://\-www.rtj.org}}},
    publisher	= {Addison-Wesley},
    year	= 2000,
}

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

@article{Robinson48,
    keywords	= {recursion, Ackermann function},
    contributer	= {pabuhr@plg},
    author	= {Raphael Mitchel Robinson},
    title	= {Recursion and Double Recursion},
    publisher	= {American Mathematical Society},
    journal	= {Bulletin of the American Mathematical Society},
    volume	= 54,
    pages	= {987-993},
    year	= 1948,
}

@article{Dijkstra:red,
    keywords	= {ada},
    contributer	= {gjditchfield@plg},
    author	= {Edsger W. Dijkstra},
    title	= {On the RED Language submitted to the DoD},
    journal	= sigplan,
    year	= 1978,
    month	= oct,
    volume	= 13,
    number	= 10,
    pages	= {27-32},
}

@article{RemoteRendezvous,
    keywords	= {rendezvous, concurrency},
    contributer	= {pabuhr@plg},
    author	= {N. D. Gammage and R. F. Kamel and L. M. Casey},
    title	= {Remote Rendezvous},
    journal	= spe,
    month	= oct,
    year	= 1987,
    volume	= 17,
    number	= 10,
    pages	= {741-755}
}

@article{Euclid,
    keywords	= {Euclid},
    contributer	= {pabuhr@plg},
    author	= {B. W. Lampson and J. J. Horning and R. L. London and J. G. Mitchell and G. L. Popek},
    title	= {Report on the Programming Language Euclid},
    journal	= sigplan,
    volume	= 12,
    number	= 2,
    month	= feb,
    year	= 1977,
    pages	= {1-79}
}

@techreport{LOGLAN88,
    keywords	= {LOGLAN},
    contributer	= {pabuhr@plg},
    author	= {Boleslaw Ciesielski and Antoni Kreczmar and Marek Lao and Andrzej Litwiniuk and Teresa Przytycka and Andrzej Salwicki and Jolanta Warpechowska and Marek Warpechowski and Andrzej Szalas and Danuta Szczepanska--Wasersztrum},
    title	= {Report on the Programming Language LOGLAN'88},
    institution	= {Institute of Informatics, University of Warsaw},
    address	= {Pkin 8th Floor, 00-901 Warsaw, Poland},
    number	= {},
    month	= dec,
    year	= 1988,
}

@article{FH91,
    keywords	= {lcc},
    contributer	= {gjditchfield@plg},
    author	= {Christopher W. Fraser and David R. Hanson},
    title	= {A Retargetable Compiler for {ANSI} {C}},
    journal	= sigplan,
    year	= 1991,
    month	= oct, volume = 26, number = 10, pages = {29-43},
    abstract	= {
        {\tt lcc} is a new retargetable compiler for ANSI C.  Versions for
	the VAX, Motorola 68020, SPARC, and MIPS are in production use at
	Princeton University and at AT\&T Bell Laboratories.  With a few
	exceptions, little about {\tt lcc} is unusual---it integrates
	several well engineered, existing techniques---but it is smaller
	and faster than most other C compilers, and it generates code of
	comparable quality.  {\tt lcc}'s target-independent front end
	performs a few simple, but effective, optimizations that contribute
	to good code; examples include simulating register declarations and
	partitioning switch statements into dense tables.  It also
	implements target-independent function tracing and expression-level
	profiling. 
    }
}

@article{Algol68revised,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {A. van Wijngaarden and B. J. Mailloux and J. E. L. Peck and
        C. H. A. Koster and M. Sintzoff and C. H. Lindsey and L. G. L. T.
	Meertens and R. G. Fisher},
    title	= {Revised Report on the Algorithmic Language {ALGOL} 68},
    journal	= sigplan,
    year	= 1977,
    month	= may,
    volume	= 12,
    number	= 5,
    pages	= {1-70}
}

@article{scheme,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {Jonathan Rees and William Clinger},
    title	= {Revised$^3$ Report on the Algorithmic Language {S}cheme},
    journal	= sigplan,
    year	= 1986,
    month	= dec,
    volume	= 21,
    number	= 12,
    pages	= {37-79},
}

@article{scheme5,
    keywords	= {scheme},
    contributer	= {pabuhr@plg},
    author	= {H. Abelson and Adams, IV, N. I. and D. H. Bartley and G. Brooks and R. K. Dybvig and D. P. Friedman and
		   R. Halstead and C. Hanson and C. T. Haynes and E. Kohlbecker and D. Oxley and K. M. Pitman and G. J. Rozas and
		   G. L. Steele Jr. and G. J. Sussman and M. Wand and \emph{Ed. by} Richard Kelsey and William Clinger and Jonathan Rees},
    title	= {Revised$^5$ Report on the Algorithmic Language {S}cheme},
    journal	= sigplan,
    year	= 1998,
    month	= sep,
    volume	= 33,
    number	= 9,
    pages	= {26-76},
}

@manual{Rust,
    keywords	= {Rust programming language},
    contributer	= {pabuhr@plg},
    title	= {The {Rust} Programming Language},
    organization= {The Rust Project Developers},
    year	= 2015,
    note	= {\href{https://doc.rust-lang.org/reference.html}{https://\-doc.rust-lang.org/\-reference.html}},
}

% S

@inproceedings{Michael04,
    keywords	= {lock free, dynamic memory allocation},
    contributer	= {pabuhr@plg},
    author	= {Maged M. Michael},
    title	= {Scalable Lock-free Dynamic Memory Allocation},
    booktitle	= {PLDI '04: Proceedings of the ACM SIGPLAN 2004 Conference on Programming Language Design and Implementation},
    location	= {Washington DC, USA},
    publisher	= {ACM},
    address	= {New York, NY, USA},
    volume	= 39,
    year	= 2004,
    month	= jun,
    pages	= {35-46},
}

@article{Anderson92,
    keywords	= {light-weight tasks},
    contributer	= {pabuhr@plg},
    author	= {Thomas E. Anderson and Brian N. Bershad and Edward D. Lazowska and Henry M. Levy},
    title	= {Scheduler Activations: Effective Kernel Support for the User-Level Management of Parallelism},
    journal	= tocs,
    volume	= 10,
    number	= 1,
    month	= feb,
    year	= 1992,
    pages	= {53-79},
}

@manual{SELF,
    keywords	= {programming language, obect-oriented, polymorphism},
    contributer	= {pabuhr@plg},
    author	= {Ole Agesen and Lars Bak and Craig Chambers and Bay-Wei Chang and Urs H{\o}lzle
		   and John H. Maloney and Randall B. Smith and David Ungar and Mario Wolczko},
    title	= {The {SELF} 3.0 Programmer's Reference Manual},
    organization= {Sun Microsystems, Inc., and Stanford University},
    year	= 1993,
}

@inproceedings{Cardelli84,
    keywords	= {subtypes, recursive types, records, variants, object oriented},
    contributer	= {gjditchfield@plg},
    author	= {Luca Cardelli},
    title	= {A Semantics of Multiple Inheritance},
    booktitle	= {Semantics of Data Types},
    year	= 1984,
    pages	= {51-67},
    editor	= {G. Kahn and D. B. MacQueen and G. D. Plotkin},
    publisher	= {Springer-Verlag},
    note	= {Lecture Notes in Computer Science v. 173},
}

@techreport{Adve95,
    keywords	= {shared memory, consistency models},
    contributer	= {pabuhr@plg},
    author	= {Sarita V. Adve and Kourosh Gharachorloo},
    title	= {Shared Memory Consistency Models: A Tutorial},
    institution	= {Western Research Laboratory},
    address	= {250 University Avenue, Palo Alto, California, 94301, U.S.A.},
    number	= {7},
    month	= sep,
    year	= 1995,
    note	= {\href{http://www.hpl.hp.com/techreports/Compaq-DEC/WRL-95-7.pdf}{\textsf{http://www.hpl.hp.com/\-techreports/\-Compaq-DEC/\-WRL-95-7.pdf}}, Reprinted in \cite{Adve95reprint}.},
}

@article{Adve95reprint,
    keywords	= {shared memory, consistency models},
    contributer	= {pabuhr@plg},
    author	= {Sarita V. Adve and Kourosh Gharachorloo},
    journal	= {Computer},
    title	= {Shared Memory Consistency Models: A Tutorial},
    month	= dec,
    year	= 1996,
    volume	= 29,
    number	= 12,
    pages	= {66-76},
}

@inproceedings{Howard76b,
    keywords	= {monitors},
    contributer	= {pabuhr@plg},
    author	= {J. H. Howard},
    title	= {Signaling in Monitors},
    booktitle	= {Proceedings Second International Conference Software Engineering},
    address	= {San Francisco, U.S.A},
    publisher	= {IEEE Computer Society},
    month	= oct,
    year	= 1976,
    pages	= {47-52}
}

@techreport{Schemenauer01,
    keywords	= {Phthon, generator, coroutine},
    contributer	= {pabuhr@plg},
    author	= {Neil Schemenauer and Tim Peters and Magnus Lie Hetland},
    title	= {Simple Generators},
    month	= may,
    year	= 2001,
    note	= {{\small\textsf{http://www.python.org/peps/pep-0255.html}}},
}

@inproceedings{Michael96,
    keywords	= {compare_and_swap, concurrent queue, lock-free, multiprogramming, non-blocking},
    contributer	= {pabuhr@plg},
    author	= {Maged M. Michael and Michael L. Scott},
    title	= {Simple, Fast, and Practical Non-blocking and Blocking Concurrent Queue Algorithms},
    booktitle	= {Proceedings of the Fifteenth Annual ACM Symposium on Principles of Distributed Computing},
    series	= {PODC'96},
    year	= 1996,
    location	= {Philadelphia, Pennsylvania, USA},
    pages	= {267--275},
    numpages	= {9},
    publisher	= {ACM},
    address	= {New York, NY, USA},
}

@inproceedings{Dice10,
    keywords	= {hardware, synchronization, transactional memory},
    author	= {Dave Dice and Yossi Lev and Virendra J. Marathe and Mark Moir and Dan Nussbaum and Marek Olszewski},
    title	= {Simplifying Concurrent Algorithms by Exploiting Hardware Transactional Memory},
    booktitle	= {Proceedings of the Twenty-second Annual ACM Symposium on Parallelism in Algorithms and Architectures},
    series	= {SPAA'10},
    year	= 2010,
    location	= {Thira, Santorini, Greece},
    pages	= {325-334},
    numpages	= {10},
    publisher	= {ACM},
    address	= {New York, NY, USA},
}

@article{PDM:overload,
    keywords	= {compilation},
    contributer	= {gjditchfield@plg},
    author	= {Tom Pennello and Frank DeRemer and Richard Meyers},
    title	= {A Simplified Operator Identification Scheme for {Ada}},
    journal	= sigplan,
    year	= 1980,
    month	= {July--August},
    volume	= 15,
    number	= {7/8},
    pages	= {82-87},
    comment	= {
        The two-pass (bottom-up, top-down) overload resolution algorithm
	for Ada, with a proof that two passes suffice and a claim that two
	are necessary.  See \cite{D:overload}.
    }
}

@book{SimulaBegin,
    author	= {Graham M. Birtwistle and Ole-Johan Dahl and Bj{\o}rn Myhrhaug and Kristen Nygaard},
    title	= {{SIMULA} begin},
    publisher	= {Studentlitteratur},
    year	= {1980},
    address	= {Lund, Sweden},
    edition	= {second},
}

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

@book{smalltalk,
    keywords	= {Smalltalk, abstract class, protocol},
    contributer	= {gjditchfield@plg},
    author	= {A. Goldberg and D. Robson}, 
    title	= {Smalltalk-80: The Language and its Implementation},
    publisher	= {Addison-Wesley},
    year	= 1983
}

@inproceedings{Edelson92,
    keywords	= {persistence, pointers},
    contributer	= {pabuhr@plg},
    author	= {Daniel R. Edelson},
    title	= {Smart Pointers: They're Smart, but They're Not Pointers},
    booktitle	= {USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Technical Conference Proceedings},
    organization= {USENIX Association},
    address	= {Portland, Oregon, U.S.A.},
    month	= aug,
    year	= 1992,
    pages	= {1-19},
}

@book{SNOBOL,
    keywords	= {SNOBOL4},
    contributer	= {pabuhr@plg},
    author	= {R. E. Griswold and J. F. Poage and I. P. Polonsky},
    title	= {The SNOBOL4 Programming Language},
    edition	= {second},
    publisher	= {Prentice-Hall},
    year	= 1971,
}

@article{Sutter05b,
    keywords	= {concurrency},
    contributer	= {pabuhr@plg},
    author	= {Herb Sutter and James Larus},
    title	= {Software and the Concurrency Revolution},
    journal	= Queue,
    year	= 2005,
    month	= sep,
    volume	= 3,
    number	= 7,
    pages	= {54-62},
}

@inproceedings{raytheon,
    keywords	= {cobol},
    contributer	= {gjditchfield@plg},
    author	= {Robert G. Lanergan and Charles A. Grasso},
    title	= {Software Engineering with Reusable Designs and Code},
    booktitle	= {Workshop on Reusability in Programming},
    year	= 1983,
    month	= sep,
    pages	= {224-234},
    organization= {{ITT} Programming},
    summary	= {
	60\% of business application design and code are redundant.
	Three standard program plans are used.  Reuse doubles productivity
	during development and greatly helps program comprehension during
	maintenance.
    }
}

@article{Hecht86,
    keywords	= {exception handling, robustness},
    contributer	= {pabuhr@plg},
    author	= {H. Hecht and M. Hecht},
    title	= {Software Reliability in the Systems Context},
    journal	= ieeese,
    year	= 1986,
    volume	= 12,
    number	= 1,
    pages	= {51-58},
}

@inproceedings{Herlihy03,
    author	= {Maurice Herlihy and Victor Luchangco and Mark Moir and William N. {Scherer III}},
    title	= {Software Transactional Memory for Dynamic-sized Data Structures},
    booktitle	= {Proceedings of the Twenty-second Annual Symposium on Principles of Distributed Computing},
    series	= {PODC '03},
    year	= {2003},
    location	= {Boston, Massachusetts},
    pages	= {92-101},
    numpages	= {10},
    publisher	= {ACM},
    address	= {New York, NY, USA},
}

@article{Dijkstra65a,
    keywords	= {N-thread software-solution mutual exclusion},
    contributer	= {pabuhr@plg},
    author	= {Edsger W. Dijkstra},
    title	= {Solution of a Problem in Concurrent Programming Control},
    journal	= cacm,
    volume	= 8,
    number	= 9,
    month	= sep,
    year	= 1965,
    pages	= {569},
    publisher	= {ACM},
    address	= {New York, NY, USA},
}

@inproceedings{Chen05,
    keywords	= {fixed-priority, preemption},
    contributer	= {pabuhr@plg},
    author	= {Jiongxiong Chen and Ashif Harji and Peter Buhr},
    title	= {Solution Space for Fixed-Priority with Preemption Threshold},
    booktitle	= {Proceedings of the 11th Real Time and Embedded Technology and Applications Symposium (RTAS'05)},
    organization= {IEEE},
    address	= {San Francisco, CA, U.S.A},
    month	= mar,
    year	= 2005,
    pages	= {385-394}
}

@inproceedings{Tiemann88,
    keywords	= {wrappers},
    contributer	= {pabuhr@plg},
    author	= {Michael D. Tiemann},
    title	= {Solving the RPC problem in GNU {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    booktitle	= {Proceedings of the USENIX {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Conference},
    organization= {USENIX Association},
    address	= {Denver, Colorado, U.S.A},
    month	= oct,
    year	= 1988,
    pages	= {343-361}
}

@book{Campbell74,
    keywords	= {path expressions},
    contributer	= {pabuhr@plg},
    author	= {R. H. Campbell and A. N. Habermann},
    title	= {The Specification of Process Synchronization by Path Expressions},
    publisher	= {Springer-Verlag},
    year	= 1974,
    volume	= 16,
    pages	= {89-102},
    series	= {Lecture Notes in Computer Science},
}

@article{Bentley85,
    keywords	= {CSP, concurrency},
    contributer	= {pabuhr@plg},
    author	= {J. Bentley},
    title	= {A Spelling Checker},
    journal	= cacm,
    month	= may,
    year	= 1985,
    volume	= 28,
    number	= 5,
    pages	= {456-462},
}

@manual{POSIX01,
    keywords	= {POSIX, Standard},
    contributer	= {pabuhr@plg},
    key		= {POSIX},
    title	= {1003.1 Standard for Information Technology -- Portable Operating System Interface (POSIX), System Interface, Issue 6},
    organization= {IEEE and The Open Group},
    year	= 2001,
}

@manual{POSIX08,
    keywords	= {POSIX, Standard},
    contributer	= {pabuhr@plg},
    key		= {POSIX},
    title	= {1003.1 Standard for Information Technology -- Portable Operating System Interface (POSIX), Base Specifications, Issue 7},
    organization= {IEEE and The Open Group},
    year	= 2008,
}

@inproceedings{ML:NJ,
    keywords	= {continuations, ML},
    contributer	= {pabuhr@plg},
    author	= {A. Appel and D. MacQueen},
    title	= {A Standard {ML} Compiler},
    booktitle	= {Functional Programming Languages and Computer Architecture},
    publisher	= {Springer-Verlag},
    series	= {Lecture Notes in Computer Science},
    volume	= 274,
    year	= 1987,
    pages	= {301-324},
}

@techreport{MLreport,
    keywords	= {ML, polymorphism},
    contributer	= {pabuhr@plg},
    author	= {R. Milner},
    title	= {The Standard {ML} Core Language},
    institution	= {},
    number	= {Polymorphism II.2},
    month	= oct,
    year	= 1985
}

@inproceedings{Ghelli,
    keywords	= {},
    contributer	= {gjditchfield@plg},
    author	= {Giorgio Ghelli},
    title	= {A Static Type System for Message Passing},
    crossref	= "OOPSLA91",
    pages	= {129-145},
    summary	= {
        A strong, statically checked type system for object oriented
	languages is defined by modelling methods as overloaded functions
	with a "self" parameter, with dynamic overload resolution.  This
	allows covariant method redefinition.  However, if equality is
	covariantly redefined for Point and ColoredPoint classes, and a
	ColoredPoint is compared to a Point, Point equality will be used,
	even if self is the colored point!
    }
}

@article{Dijkstra68b,
    keywords	= {semaphore, P/V},
    contributer	= {pabuhr@plg},
    author	= {E. W. Dijkstra},
    title	= {The Structure of the ``{THE}''--Multiprogramming System},
    journal	= cacm,
    month	= may,
    year	= 1968,
    volume	= 11,
    number	= 5,
    pages	= {341-346}
}

@book{Holt78,
    keywords	= {operating systems, concurrency},
    contributer	= {pabuhr@plg},
    author	= {R. C. Holt and G. S. Graham and E. D. Lazowska and M. A. Scott},
    title	= {Structured Concurrent Programming with Operating System Applications},
    publisher	= {Addison-Wesley},
    year	= 1978,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

% T

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@book{pldesign,
    keywords	= {},
    editor	= {Anthony I. Wasserman},
    title	= {Tutorial: Programming Language Design},
    publisher	= {Computer Society Press},
    year	= 1980
}
 
@article{Leroy00,
    keywords	= {type-systems, exceptions},
    contributer	= {pabuhr@plg},
    author	= {Xavier Leroy and Fran\c{c}ois Pessaux},
    title	= {Type-Based Analysis of Uncaught Exceptions},
    journal	= toplas,
    month	= mar,
    year	= 2000,
    volume	= 22,
    number	= 2,
    pages	= {340-377},
    comment	= {
    	Argues against declaring exceptions on routine definitions.
    },
}

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

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

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

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

% U

@unpublished{uC++book,
    keywords	= {control structure, concurrency},
    contributer	= {pabuhr@plg},
    author	= {Peter A. Buhr},
    title	= {Understanding Control Flow with Concurrent Programming using $\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}},
    year	= 1999,
    note	= {Textbook in preparation}
}

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

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

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

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

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

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

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

% V

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

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

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

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

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

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

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

% W

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

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

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

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

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

% X

% Y

% Z

% Cross-referenced entries:

% O

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

@proceedings{OOPSLA87,
    contributer	= {gjditchfield@plg},
    title	= {{OOPSLA} '87 Conference Proceedings},
    booktitle	= {{OOPSLA} '87 Conference Proceedings},
    year	= 1987,
    editor	= {Norman Meyrowitz},
    publisher	= sigplan # " 22(12)",
    organization= {Association for Computing Machinery},
    address	= {Orlando, Florida},
    month	= oct # { 4--8}
}

@proceedings{OOPSLA88,
    contributer	= {gjditchfield@plg},
    title	= {{OOPSLA} '88 Conference Proceedings},
    booktitle	= {{OOPSLA} '88 Conference Proceedings},
    year	= 1988,
    editor	= {Norman Meyrowitz},
    publisher	= sigplan # " 23(11)",
    organization= {Association for Computing Machinery},
    address	= {San Diego, California},
    month	= sep # { 25--30}
}

@proceedings{OOPSLA89,
    contributer	= {gjditchfield@plg},
    title	= {{OOPSLA} '89 Conference Proceedings},
    booktitle	= {{OOPSLA} '89 Conference Proceedings},
    year	= 1989,
    editor	= {Norman Meyrowitz},
    publisher	= sigplan # " 24(10)",
    organization= {Association for Computing Machinery},
    address	= {New Orleans, Louisiana},
    month	= oct # { 1--6}
}

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

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