% % database for my virtual bookshelf % % DESCRIPTION % This virtual bookshelf is generated automatically from % the BibTeX-database. It contains references to publications % - related to current work or interests - that I have read % (well, more or less) and want easy access to. % % If you find any errors or can direct me to publications % related to the topics mentioned here (especially first class input/output, % first class modules, persistence, and reflection for functional languages), % feel free to drop me an email. % ENDDESCRIPTION % % TOPICS % Functional Programming : FP - Graphics/Visual, FP - Input/Output, FP - State, FP - General, FP - Monads, FP - Implementation, FP - Programming, FP - Nonsequential Execution, FP - Languages, FP - Lambda Calculi % Logical Programming : LP - General, LP - Unification, LP - Implementation, LP - Programming, LP - Nonsequential Execution, LP - Languages % Aspects of Programming Languages : Data Abstraction, Semantics, Language Design/Semantics, Modules, Persistence, Records, Type Systems, Programming Environments, Programming/Software Engineering, Rewrite Systems, Object-Orientation, History, Libraries and Tools, Concurrency, Foreign Function Interfaces, Component-Based Programming, Human Computer Interfaces % FP - Languages : Standard ML, FFI, Kiel Reduction Language, Lisp/Scheme, Haskell, Clean, Hope, ML2000, Poly, Misc. Functional Languages % Visual Programming : UML, Petri Nets, VRML % Reasoning (about Programs) : Static Analysis, Partial Evaluation, Type Systems, Theorem Proving/Logical Frameworks, Reflection/Meta-Programming, Knowledge Representation, Logic/Category Theory, Attribute Grammars % Non-Functional Programming Languages : Java, Simula, SmallTalk, Miscellaneous Languages % ENDTOPICS % % KEYS % Rewrite Systems : Rewriting, Narrowing % Type Systems : Existential Types, Type (Constructor) Classes, Uniqueness Typing, Dynamic Types, Overloading, Polymorphism % FP - Input/Output : Monads, Continuations, Unique Environment Passing, GUIs, Process Communication % ML2000 : Would be nice to have an official site for this language design process instead of these ubiquituos "hints" % Modules : There are still a few more module papers on my real shelf (I just haven't got that much time for reading currently). % ENDKEYS % @STRING{FIDEINSTITUTION={ESPRIT Basic Research Action, Project Number 3070---FIDE}} @STRING{FIDE2INSTITUTION={ESPRIT Basic Research Action, Project Number 6309---\mbox{FIDE$_2$}}} @string{fiderep={FIDE Technical Report Series}} @string{fidecoord={FIDE Project Coordinator, Dept. of Computing Sciences, University of Glasgow, Glasgow G128QQ}} @string{PLILP = {{Programming Languages: Implementations, Logics and Programs}}} @string{PLDI = {{SIGPLAN Conference on Programming Language Design and Implementation}}} @string{POPL = {{ACM Symposium on Principles of Programming Languages}}} @string{OOPSLA = {{ACM Symposium on Object-Oriented Programming: Systems, Languages and Applications}}} @string{ECOOP = {{European Conference on Object-Oriented Programming}}} @string{IFL = {{Workshop on the Implementation of Functional Languages}}} @string{CACM = {{Communications of the ACM}}} @string{ADDWES = {{Addison-Wesley}}} @string{LNCS = {{Lecture Notes in Computer Science}}} @string{SPRINGER = {{Springer Verlag}}} @string{JFP = {{Journal of Functional Programming}}} @string{FTP = {ftp}} @string{PIRED = {{$\pi$-RED$^+$}}} @string{CAU = {{Christian-Albrechts-Universit"at zu Kiel}}} @string{CMU = {{School of Computer Science, Carnegie Mellon University}}} @string{EDCS = {{University of Edinburgh, Dept. of Computer Science}}} @string{GMD = {{Gesellschaft f{\"u}r Mathematik und Datenverarbeitung mbH, Bonn}}} @string{ifiGer = {{Institut f{\"u}r Informatik und praktische Mathe\-matik, Universit{\"a}t Kiel}}} @string{ifi = {{Institute of Computer Science and Applied Mathematics, Christian-Albrechts-University, Kiel}}} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @misc{Scholz, author = {Sven-Bodo Scholz}, title = {{Sven-Bodo Scholz's Virtual Bookshelf}}, howpublished = {\url{http://www.informatik.uni-kiel.de/~sbs/bib/bookshelf.html}}, year = 1998, sourceURL = {http://www.informatik.uni-kiel.de/~sbs/bib/bookshelf.html}, topics = {Other Virtual Bookshelfs} } @misc{Grelck, author = {Clemens Grelck}, title = {{Clemens Grelck's Virtual Bookshelf}}, howpublished = {\url{http://www.informatik.uni-kiel.de/~cg/bib/bookshelf.html}}, year = 1998, sourceURL = {http://www.informatik.uni-kiel.de/~cg/bib/bookshelf.html}, topics = {Other Virtual Bookshelfs} } %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% A @inproceedings{AbadiCardPierPlot89, author = {Martin Abadi and Luca Cardelli and Benjamin Pierce and Gordon Plotkin}, title = {{Dynamic Typing in a Statically Typed Language}}, booktitle = {16th } # POPL, year = 1989, pages = {213-227}, topics = {Type Systems}, keywords = {Dynamic Types} } @techreport{AbadiMarti89a, author ="Abadi, Martin and Cardelli, Luca and Pierce, Benjamin C. and Plotkin, Gordon D.", title ={{Dynamic Typing in a Statically Typed Language}}, number ="DEC-SRC-47", institution ="Digital Equipment Corporation, Systems Research Centre", month ="June", year = 1989, scope ="type", sourceURL ="ftp://gatekeeper.dec.com/pub/DEC/SRC/research-reports/SRC-047.ps", documentSize="115.6 kbytes", topics = {Type Systems} } @article{AbadiMarti91, author = {Abadi, Martin and Cardelli, Luca and Pierce, Benjamin C. and Plotkin, Gordon D.}, title = {{Dynamic Typing in a Statically Typed Language}}, journal = {ACM Transactions on Programming Languages and Systems}, year = 1991, sourceURL = {http://www.luca.demon.co.uk/Papers/Dyn.ps}, volume = {13}, number = {2}, pages = {237-268}, month = apr, note = {earlier versions in POPL'89 and as technical report DEC-SRC-47}, topics = {Type Systems}, keywords = {Dynamic Types} } @techreport{AbadiMarti94a, author ="Abadi, Martin and Cardelli, Luca and Pierce, Benjamin and R{\'e}my, Didier", title ={{Dynamic Typing in Polymorphic Languages}}, number ="DEC-SRC-120", institution ="Digital Equipment Corporation, Systems Research Centre", month ="Jan", year = 1994, scope ="type", sourceURL = {http://www.luca.demon.co.uk/Papers/PolyDyn.ps}, documentSize="82.4 kbytes", topics = {Type Systems}, keywords = {Dynamic Types} } @incollection{Abramson86, crossref = {DeGrootLindstrom86}, author = {Harvey Abramson}, title = {{A Prological Definition Of HASL: A Purely Functional Language With Unification-Based Conditional Binding Expressions}}, year = 1986, pages = {73-129}, topics = {Misc. Functional Languages} } @phdthesis{Achten96, author = {Peter Achten}, title = {{Interactive Functional Programs - Models, Methods, and Implementation}}, school = {Nijmegen}, month = feb, year = 1996, sourceURL = {http://www.cs.kun.nl/~peter88/PeterThesisFTP.html}, topics = {FP - Input/Output} } @misc{AchtenPlasmeijer93, author ="Achten, P. and Plasmeijer, R.", title ={{A Framework for Deterministically Interleaved Interactive Programs in the Functional Programming Language Clean}}, year = 1993, scope ="graphics", abstractURL ="ftp://ftp.cs.kun.nl/pub/Clean/papers/interleavedIO.abs", sourceURL ="ftp://ftp.cs.kun.nl/pub/Clean/papers/interleavedIO.ps.Z", topics = {FP - Input/Output,Clean} } @article{AchtenPlasmeijer95a, author = {Peter Achten and Rinus Plasmeijer}, title = {{The Ins and Outs of Clean I/O}}, sourceURL = {ftp://ftp.cs.kun.nl/pub/Clean/papers/ins_outs.ps.Z}, journal = JFP, volume = 5, number = 1, pages = {81-110}, month = jan, year = 1995, abstract = {Functional programming languages have banned assignment because of its undesirable properties. The reward of this rigorous decision is that functional programming languages are side-effect free. There is another side to the coin: because assignment plays a crucial role in Input/Output (I/O), functional languages have a hard time dealing with I/O. Functional programming languages have therefore often been stigmatised as inferior to imperative programming languages because they cannot deal with I/O very well. In this paper we show that I/O can be incorporated in a functional programming language without loss of any of the generally accepted advantages of functional programming languages. This discussion is supported by an extensive account of the I/O system offered by the lazy, purely functional programming language Clean. Two aspects that are paramount in its I/O system make the approach novel with respect to other approaches. These aspects are the technique of explicit multiple environment passing, and the Event I/O framework to program Graphical User I/O in a highly structured and high-level way. Clean file I/O is as powerful and flexible as it is in common imperative languages (one can read, write, and seek directly in a file). Clean Event I/O provides programmers with a high-level frame- work to specify complex Graphical User I/O. It has been used to write applications such as a window-based text editor, an object based drawing program, a relational database, and a spreadsheet program. These graphical interactive programs are completely machine independent, but still obey the look-and-feel of the concrete window environment being used. The specifications are completely functional and make extensive use of uniqueness typing, higher-order functions, and algebraic data types. Efficient implementations are present on the Macintosh, Sun (X Windows under Open Look), and PC (OS/2). }, topics = {FP - Input/Output} } @misc{AchtenPlasmeijer95b, author ="Achten, P. and Plasmeijer, R.", title ={{Concurrent Interactive Processes in a Pure Functional Language}}, year = 1995, scope ="graphics", abstractURL ="ftp://ftp.cs.kun.nl/pub/Clean/papers/achp95-ConcurrIO.abs", sourceURL ="ftp://ftp.cs.kun.nl/pub/Clean/papers/achp95-ConcurrIO.ps.Z", topics = {FP - Nonsequential Execution,FP - Input/Output,Clean} } @inproceedings{AppelMacQueen91, author = {Andrew W. Appel and David B. MacQueen}, title = {{Standard ML of New Jersey}}, booktitle = {{3rd International Symposium on Programming Language Implementation and Logic Programming, LNCS 528}}, sourceURL = {ftp://research.att.com/dist/ml/papers/91-plip-appel.ps}, note = {pp. 1-13}, month = aug, year = 1991, topics = {FP - Implementation,Standard ML} } @techreport{AppelMacQueen94, author = {Andrew W. Appel and David B. MacQueen}, title = {{Separate Compilation for Standard ML}}, institution = {Princeton University}, year = 1994, note = {also in: Proceedings of 1994 ACM Conference on Programming Language Design and Implementation (ACM SIGPLAN Notices vol. 29, number 6), pp. 13-23, June 1994}, sourceURL = {http://ncstrl.cs.princeton.edu:80/TR/PRINCETONCS:TR-452-94}, number = {TR-452-94}, month = mar, topics = {Modules} } @inproceedings{AriolaSabry98, author = {Zena M. Ariola and Amr Sabry}, title = {{Correctness of Monadic State: An Imperative Call-by-Need Calculus}}, booktitle = {14th} # POPL, year = 1998, sourceURL = {http://www.cs.uoregon.edu/~sabry/papers/impcbneed.ps}, publisher = {ACM Press}, address = {New York}, topics = {FP - State,FP - Lambda Calculi} } @inproceedings{AssmannIFL98, title = {{Performance Results for an Implementation of the Process Coordination Language K2}}, author = {Claus A{\ss}mann}, editor = {K. Hammond and A.J.T. Davie and C. Clack}, publisher = {Springer-Verlag}, booktitle = {Implementation of Functional Languages (IFL~'98), London, UK}, series ={LNCS}, volume ={1595}, month = {September}, year = {1998}, pages = {1--19} } @inproceedings{AtkBaiChisCockMorr83a, author = {Atkinson, M.P. and Bailey, P.J. and Chisholm, K.J. and Cockshott, W.P. and Morrison, R.}, title = {{PS-algol: A Language for Persistent Programming}}, booktitle = {{10th Australian National Computer Conference, Melbourne, Australia}}, year = 1983, sourceURL = {ftp://ftp-ppg.dcs.st-and.ac.uk/pub/persistence.papers/ps-algol.ps.gz}, abstractURL = {http://www-fide.dcs.st-and.ac.uk/Publications/1983.html#ps-algol}, pages = {70-79}, topics = {Persistence} } @article{AtkBaiChisCockMorr83b, author = {Atkinson, M.P. and Bailey, P.J. and Chisholm, K.J. and Cockshott, W.P. and Morrison, R.}, title = {{An Approach to Persistent Programming}}, journal = {Computer Journal}, year = 1983, sourceURL = {ftp://ftp-ppg.dcs.st-and.ac.uk/pub/persistence.papers/approach.persistence.ps.gz}, abstractURL = {http://www-fide.dcs.st-and.ac.uk/Publications/1983.html#approach.persistence}, volume = {4}, pages = {360-365}, topics = {Persistence} } @INCOLLECTION{AtkinsonMorrison84, AUTHOR = {Atkinson, M. P. and Morrison, R.}, TITLE = {{Persistent First Class Procedures are Enough}}, EDITOR = {Joseph, M. and Shyamasundar, R.}, BOOKTITLE = {Proceedings of the 4th Conference on Foundations of Software Technology and Theoretical Computer Science}, SERIES = {LNCS}, VOLUME = {181}, PAGES = {223-240}, PUBLISHER = {Springer}, YEAR = 1984, abstractURL = {http://www-fide.dcs.st-and.ac.uk/Publications/1984.html#first.class.procs}, sourceURL = {http://www-fide.dcs.st-and.ac.uk/Publications/PostScript/first.class.procs.ps.gz}, TOPICS = {Persistence,Modules,Data Abstraction} } @book{AtkinsonBunMorr88, editor = {M. P. Atkinson and P. Buneman and R. Morrison}, title = {{Data Types and Persistence}}, publisher = Springer, year = 1988, topics = {Persistence} } @TECHREPORT{AtkinsonMorrison95, AUTHOR={Atkinson, M.P. and Morrison, R.}, TITLE={{Orthogonally Persistent Object Systems}}, sourceURL = {ftp://ftp.dcs.glasgow.ac.uk/pub/fide/reports/fide_95_121.ps.gz}, INSTITUTION=FIDE2INSTITUTION, NUMBER={FIDE/95/121}, YEAR=1995, note={Appeared in VLDB Journal, 4(3):319-401, 1995}, topics={Persistence} } @misc{hbc97, author = {Lennart Augustsson}, title = {{The HBC compiler}}, howpublished = {\url{http://www.cs.chalmers.se/~augustss/hbc/hbc.html}}, month = Jan, year = 1999, sourceURL = {http://www.cs.chalmers.se/~augustss/hbc/hbc.html}, topics = {Haskell,FP - Implementation} } @inproceedings{Augustsson85, author = {Lennart Augustsson}, title = {{Compiling Pattern Matching}}, editor = {Jean-Pierre Jouannaud}, booktitle = {{Conference on Functional Programming Languages and Computer Architecture, Nancy, France, LNCS 201}}, year = 1985, pages = {368-381}, publisher = SPRINGER, topics = {FP - Implementation} } @inproceedings{Augustsson89, author = "L. Augustsson and T. Johnsson", title = "Parallel Graph Reduction with the $<$$\nu$, {G}$>$-Machine", booktitle = "Proceedings of the Conference on Functional Programming Languages and Computer Architecture '89, Imperial College, London", pages = "202--213", publisher = "ACM", address = "New York, NY", year = "1989", keywords = "machine nu", abstract = "We have implemented a parallel graph reducer on a commercially available shared memory multiprocesor (a Sequent Symmetry) that achieves real speedup compared to a fast compiled implementation of the conventional G-machine. Using 15 procesors, this speedup ranges between 5 and 11 depending on the program. Underlying the implementation is an abstract machine called the $<$nu,G$>$-machine. We describe the sequential and the parallel $<$nu,G$>$-machine, and our implementation of them. We provide performance and speedup figures and graphs.", sourceURL = {ftp://ftp.cs.chalmers.se/pub/cs-reports/papers/nu-G.ps.Z}, topics = {FP - Implementation,FP - Nonsequential Execution} } @inproceedings{Augustsson93a, author ={Augustsson, Lennart}, title ={{Implementing Haskell overloading}}, booktitle ={{Functional Programming and Computer Architecture}}, year = 1993, scope ={type}, sourceURL ={http://www.cs.chalmers.se/pub/cs-reports/papers/overload-fpca-93.ps.Z}, documentSize={60.9 kbytes}, topics = {FP - Implementation,Haskell,Type Systems} } @Article{Augustsson93b, title={The interactive {Lazy} {ML} system}, author={Lennart Augustsson}, pages={77--92}, journal=JFP, month=jan, year=1993, volume=3, number=1, abstract = {In this paper we describe an implementation of an interactive version of the purely functional programming language Lazy ML (or LML for short). The most remarkable fact about the interactive system is that it is written in a pure functional style using LML yet the efficiency still compares favourably to other conventional interpretative systems. We describe how the system is designed and also the exception mechanism that was added to facilitate the handling of errors in the system. }, topics = {Programming Environments,FP - Implementation} } @misc{Augustsson98, author = {Lennart Augustsson}, title = {{Cayenne -- Spice up your programming with dependent types}}, howpublished = {\url{http://www.cs.chalmers.se/~augustss/cayenne/paper.ps}}, year = 1998, sourceURL = {http://www.cs.chalmers.se/~augustss/cayenne/paper.ps}, topics = {Misc. Functional Languages} } %% B @article{Backus1978, author ="Backus, J.", title ={{Can Programming be Liberated from the von Neumann Style: A Functional Style and Its Algebra of Programs}}, journal ={{Communications of the ACM}}, number ="8", volume ="21", pages ="613--641", langModel ="func", month ="August", year = 1978, topics = {FP - General,Language Design/Semantics} } @book{Barendregt84, author = {Hendrik Pieter Barendregt}, title = {{The Lambda Calculus -- Its Syntax and Semantics}}, publisher = {North-Holland}, year = 1984, volume = {103}, series = {Studies in Logic and the Foundations of Mathematics}, topics = {FP - Lambda Calculi} } @article{Barendregt91, author = {Henk Barendregt}, title = {{Introduction to generalized type systems}}, journal = {Journal of Functional Programming}, year = 1991, volume = {1}, number = {2}, pages = {125-154}, month = apr, topics = {Type Systems,FP - Lambda Calculi} } @misc{Barendregt96, author = {Henk Barendregt}, title = {{The impact of the lambda calculus in logic and computer science}}, howpublished = {\url{ftp://ftp.cs.kun.nl/pub/CompMath.Found/church.ps.Z}}, month = Oct, year = 1996, sourceURL = {ftp://ftp.cs.kun.nl/pub/CompMath.Found/church.ps.Z}, abstract = {One of the most important contributions of A. Church to logic consists of his invention of the lambda calculus. Of this theory we present its genesis and its two major application areas. These are: 1. the representation of computations and the resulting functional programming languages; and 2. the representation of reasoning and the resulting systems of computer mathematics. }, topics = {FP - Lambda Calculi} } @misc{Barendregt96b, author = {Henk Barendregt}, title = {{Applications of the Lambda Calculus}}, howpublished = {Talk given at the yearly colloquium of the Department of computer science in Kiel}, month = Jun, year = 1996, topics = {FP - Lambda Calculi} } @inproceedings{BarendsenSmetsers95, AUTHOR = {Erik Barendsen and Sjaak Smetsers}, TITLE = {{Uniqueness Type Inference}}, editor = {M. Hermenegildo and S. D. Swierstra}, booktitle = PLILP, sourceURL = {ftp://ftp.cs.kun.nl/pub/CSI/SoftwEng.FunctLang/papers/bare95-unitypeinference.ps.gz}, PUBLISHER = SPRINGER, SERIES = {LNCS}, VOLUME = {982}, YEAR = 1995, abstract = {In this paper we extend the Uniqueness Type System with uniqueness polymorphism. Using a notion of `principal uniqueness variants' the type system is shown to be effective in the sense that a uniqueness variant of a given conventional type can be determined automatically. The presented algorithm serves as a basis for type checking in the language Clean. We illustrate the system by some concrete examples.}, topics = {Type Systems} } @article{BarBuxHarNixStr63, author = {D. W. Barron and J. N. Buxton and D. F. Hartley and E. Nixon and C. Strachey}, title = {{The main features of CPL}}, journal = {Computer Journal}, year = 1963, volume = {6}, number = {2}, pages = {134-143}, month = jul, topics = {History,FP - General} } @article{BelliaLevi86, author = {M. Bellia and G. Levi}, title = {{The Relation Between Logic And Functional Languages: A Survey}}, journal = {Journal of Logic Programming}, year = 1986, number = {3}, pages = {217-236}, topics = {FP - General,LP - General} } @inproceedings{BentonKennedyRussell98, author = {Nick Benton and Andrew Kennedy and George Russell}, title = {{Compiling Standard ML to Java Bytecodes}}, booktitle = {{International Conference on Functional Programming, ICFP'98, Baltimore}}, year = 1998, pages = {129-140}, month = Sep, topics = {FP - Implementation,Standard ML,Java} } @techreport{Berkling76, author = {Berkling, K.J.}, title = {{A Symmetric Complement to the Lambda Calculus}}, institution = GMD, note = {ISF-76-7}, month = {September}, year = 1976, abstract = {"The calculi of Lambda-conversion" introduced by A.Church are complemented by a new operator lambda-bar, which is in some sense the inverse to the lambda-operator. The main advantage of the complemented system is that variables do not have to be renamed. Conversely, any renaming of variables in a formula is possible. Variables may, however, appear with varied numbers of lambda-bars in front of them. Implementations of the lambda calculus representation with the symmetric complement are greatly facilitated. In particular, a renaming of all variables in a formula to the same one is possible. Variables are then distinguished only by the number of preceding lambda-bars. Finally, we give a four symbol representation of the lambda calculus based on the above mentioned freedom in renaming. }, topics = {FP - Lambda Calculi} } @article{BerklingFehr82a, author = {Klaus Berkling and E. Fehr}, title = {{A Consistent Extension of the Lambda Calculus as a Base for Functional Programming Languages}}, journal = {Information and Control}, volume = {55}, number = {1-3}, pages = {89-101}, year = 1982, topics = {FP - Lambda Calculi} } @article{BerklingFehr82b, author = {Klaus Berkling and E. Fehr}, title = {{A modification of the $\lambda$-calculus as a base for functional programming languages}}, journal = LNCS, volume = {140}, pages = {35-47}, year = 1982, topics = {FP - Lambda Calculi} } @inproceedings{Berkling86a, author = {Berkling, K.J.}, title = {{Head Order Reduction: A Graph Reduction Scheme for the Operational Lambda Calculus}}, pages = {26-48}, editor = {J. H. Fasel and R. M. Keller}, booktitle = {Graph Reduction}, series = LNCS, volume = 279, publisher = SPRINGER, year = 1986, topics = {FP - Lambda Calculi} } @inproceedings{Berkling86b, author = {Klaus Berkling}, title = {{Epsilon reduction -- another view of unification}}, booktitle = {{Fifth Generation Computer Architectures}}, year = 1986, editor = {J. V. Wood}, pages = {163-176}, organization = {IFIP}, publisher = {Elsevier Science Publishers B.V. (North-Holland)}, topics = {FP - Lambda Calculi,LP - Unification} } @inproceedings{Berkling94, author = {Klaus Berkling}, title = {{A 'Fast` Representation of the Lambda Calculus}}, booktitle = {{Workshop on Functional Programming JSSST'94}}, year = 1994, topics = {FP - Lambda Calculi} } @Article{ Bird84, author = {R. S. Bird}, title = {{Using Circular Programs To Eliminate Multiple Traversals Of Data}}, journal = {Acta Informatica}, year = 1984, number = {21}, pages = {239-250}, topics = {FP - Programming} } @inproceedings{BBJNSST98, author = {Michael J. Black and Francois Berard and Allan Jepson and William Newman and Eric Saund and Gudrun Socher and Michael J. Taylor}, title = {{The Digital Office: Overview}}, booktitle = {{AAAI Spring Symposium on Intelligent Environments}}, year = 1998, sourceURL = {}, organization = {American Association for Artificial Intelligence}, topics = {Human Computer Interfaces} } @phdthesis{Blott91, author = {Stephen Blott}, title = {{An Approach to Overloading with Polymorphism}}, school = {Department of Computing Science, University of Glasgow}, year = 1992, month = Jun, topics = {Type Systems} } @misc{BoehmDemersWeiser97, author = {Hans-J. Boehm and Alan J. Demers}, title = {{A garbage collector for C and C++}}, howpublished = {\url{http://reality.sgi.com/employees/boehm_mti/gc.html}}, year = 1997, sourceURL = {http://reality.sgi.com/employees/boehm_mti/gc.html}, topics = {Libraries and Tools} } @misc{BosmaCannonMatthews94, author = {Wieb Bosma and John Cannon and Graham Matthews}, title = {{Programming with Algebraic Structures: Design of the Magma Language}}, howpublished = {ISSAC'94}, year = 1994, sourceURL = {http://wwwmaths.anu.edu.au/~graham/issac12.ps}, topics = {Miscellaneous Languages} } @inproceedings{Bothner98, author = {Per Bothner}, title = {{Kawa -- Compiling Dynamic Languages to the Java VM}}, booktitle = {{Usenix conference in New Orleans}}, year = 1998, localURL = {Freenix98.ps}, sourceURL = {http://www.cygnus.com/~bothner/Freenix98/Freenix98.ps.gz}, month = Jun, topics = {FP - Implementation,Java} } @inproceedings{BoucherFeeley96, author= {Dominique Boucher and Marc Feeley}, title= {{Abstract compilation: a new implementation paradigm for static analysis}}, sourceURL = {ftp://ftp.iro.umontreal.ca:/pub/parallele/boucherd/AbstComp95.ps}, booktitle = {{1996 International Conference on Compiler Construction}}, year= 1996, abstract = {For large programs, static analysis can be one of the most time-consuming phases of the whole compilation process. We propose a new paradigm for the implementation of static analyses that is inspired by partial evaluation techniques. Our paradigm does not reduce the complexity of these analyses, but it allows an efficient implementation. We illustrate this paradigm by its application to the problem of control flow analysis of functional programs. We show that the analysis can be sped up by a factor of 2 over the usual abstract interpretation method.}, topics = {Static Analysis} } @article{Brachman83, author = {Ronald J. Brachman}, title = {{What IS-A Is and Isn't: An Analysis of Taxonomic Links in Semantic Networks}}, journal = {IEEE Computer, special issue on knowledge representation}, year = 1983, volume = {16}, number = {10}, pages = {30-36}, month = oct, topics = {Knowledge Representation} } @incollection{Brandes86, crossref = {DeGrootLindstrom86}, author = {Robert G. Brandes}, title = {{Constraining-Unification and the Programming Language UNICORN}}, year = 1986, pages = {397-410}, topics = {LP - Languages,LP - Unification} } @INPROCEEDINGS{edenIFL96, AUTHOR={S. Breitinger and U. Klusik and R. Loogen}, TITLE={{An Implementation of Eden on Top of Concurrent Haskell}}, BOOKTITLE={Implementation of Functional Languages, Bonn 1996}, EDITOR={W. Kluge}, xORGANIZATION={Christian-Albrechts-University Kiel}, Publisher={Springer}, Series={LNCS 1268}, YEAR=1997 } @inproceedings{BronsardReddy90, author = {Francois Bronsard and Uday S. Reddy}, title = {{Axiomatization of a Functional Logic Language}}, booktitle = {{Algebraic and Logic Programming, Nancy, LNCS 463}}, year = 1990, editor = {H. Kirchner and W. Wechler}, pages = {101-116}, publisher = {Springer-Verlag}, topics = {FP - General,LP - General} } @book{Brooks75, author = {Frederick P. Brooks, Jr.}, title = {{the mythical man-month -- Essays on Software-Engineering}}, publisher = ADDWES, year = 1975, topics = {Programming/Software Engineering} } @article{deBruijn72, author = {N. G. de Bruijn}, title = {{Lambda calculus notation with nameless dummies. a tool for automatic formula manipulation with application to the church-rosser theorem}}, journal = {Indagationes Mathematicae}, year = 1972, volume = {34}, pages = {381-392}, topics = {FP - Lambda Calculi} } @article{Brutzman98, author = {Don Brutzman}, title = {{The Virtual Reality Modeling Language and Java}}, journal = CACM, year = 1998, sourceURL = {http://www.stl.nps.navy.mil/~brutzman/vrml/vrmljava.pdf}, volume = {41}, number = {6}, pages = {57-64}, month = Jun, topics = {VRML} } @TechReport{BurstallLampson84, title = {{A Kernel Language for Modules and Abstract Data Types}}, author = {R. Burstall and B. Lampson}, organization = {DEC SRC}, pages = {1--51}, month = sep, number = {1}, year = 1984, sourceURL = {http://www.research.digital.com/SRC/publications/src-rr.html}, abstract = {A small set of constructs can simulate a wide variety of apparently distinct features in modern programming languages. Using a kernel language called Pebble based on the typed lambda calculus with bindings, declarations, and types as first-class values, we show how to build modules, interfaces and implementations, abstract data types, generic types, recursive types, and unions. Pebble has a concise operational semantics given by inference rules.}, annotate = {Programming-language designers have invented a variety of language extensions and special notations to deal with several problems that arise in programming in the large. Some of the differences among such features in Ada, CLU, Euclid, Mesa, ML, Modula, Russell, SML, et al. are superficial; others are fundamental. Without a uniform semantic framework it is difficult to compare and evaluate these features, or to determine which choices are arbitrary and which are tightly constrained. Pebble is a simpler language, intended for the precise description of language constructs. It is used to explain strongly typed module interconnection languages, abstract data types, and procedures that are parameterized with respect to the types of operands. It is based on the typed lambda calculus, extended to encompass the linking together of separately checked modules into a program. Bindings, declarations, and types -- as well as functions -- are all treated as first-class values; the type system includes dependent types. This paper presents an informal overview of why the approach can be expected to work. But the precise definition of the features of existing languages in terms of Pebble is left as ``an exercise for the reader.'' The semantics of Pebble are presented both informally and formally. Representative cases are presented in great detail, to illustrate the workings of the formalism. Jim Horning}, note = {Also in `Semantics of Data Types', Springer LNCS 173; revised version appeared in Information and Computation, Vol. 76, 1988}, orig_keywords = {LINKING, ADA, CLU, EUCLID, MESA, ML, MODULA, RUSSEL, SML, PEBBLE}, topics = {Data Abstraction,Modules} } @article{Burton88, author = {F. W. Burton}, title = {{Nondeterminism with Referential Transparency in Functional Programming Languages}}, journal = {The Computer Journal}, year = 1988, volume = {31}, number = {3}, pages = {243-247}, topics = {FP - General} } @article{Bush45, author = {Vannevar Bush}, title = {{As We May Think}}, journal = {The Atlantic Monthly}, year = 194, sourceURL = {http://www.theatlantic.com/unbound/flashbks/computer/bushf.html}, volume = {176}, number = {1}, pages = {101--108}, month = jul, topics = {History} } @INPROCEEDINGS{BushellDearBrownVaug94, AUTHOR = {Bushell, J. and Dearle, A. and Brown, A.L. and Vaughan, F.}, TITLE = {{Using C as a Compiler Target Language for Native Code Generation in Persistent Systems}}, EDITOR = {}, BOOKTITLE = {{Proc. 6th International Conference on Persistent Object Systems}}, PUBLISHER = SPRINGER, SERIES = {Workshops in Computing}, YEAR = 1994, sourceURL = {http://nezz.cs.stir.ac.uk/~al/abstracts.html#POS6-cgen}, PAGES = {}, abstract = {Persistent programming languages exhibit several requirements that affect the generation of native code, namely: garbage collection; arbitrary persistence of code, data and processes; dynamic binding; and the introduction of new code into a running system. The problems of garbage collection are not unique to persistent systems and are well understood: both code and data may move during a computation if a compacting collector is employed. However, the problems of garbage collection are exacerbated in persistent systems which must support garbage collection of both RAM resident and disk resident data. Some persistent systems support a single integrated environment in which the compiled code and data is manipulated in a uniform manner, necessitating that compiled code be stored in the object store. Furthermore, some systems assume that the entire state of a running program is resident in a persistent store; in these systems it may be necessary to preserve the state of a program at an arbitrary point in its execution and resume it later. Persistent systems must support some dynamic binding in order to accommodate change. Thus code must be capable of binding to arbitrary data at a variety of times. This introduces the additional complexity that code must be able to call code contained in the persistent store produced by another compilation. In this paper native code generation techniques using C as a target language for persistent languages are presented. The techniques described solve all of the problems described above. They may therefore be applied to any language with these or a subset of these features. }, TOPICS = {Persistence} } @INCOLLECTION{BHKPRSS94, AUTHOR = {T. B{\"u}lck and A. Held and W.E. Kluge and S. Pantke and C. Rathsack and S.- B. Scholz and R. Schr{\"o}der}, TITLE = {{Experience with the Implementation of a Concurrent Graph Reduction System on an {\rm nCUBE/2}~Platform}}, EDITOR = {B. Buchberger and J. Volkert}, BOOKTITLE = {{Parallel Processing: CONPAR 94 - VAPP IV}}, SERIES = {LNCS}, VOLUME = {854}, PUBLISHER = {Springer}, YEAR = 1994, sourceURL = {http://www.informatik.uni-kiel.de/~sbs/mypapers/experience-conpar-94.ps.gz}, TOPICS = {FP - Nonsequential Execution,Kiel Reduction Language} } %% C @inproceedings{Cardelli84, author = {Luca Cardelli}, title = {{A Semantics of Multiple Inheritance}}, booktitle = {{Semantics of Data Types, International Symposium, Sophia-Antipolis, France}}, year = 1984, sourceURL = {http://www.luca.demon.co.uk/Papers/Inheritance.A4.ps}, editor = {G. Kahn and D.B. MacQueen and G. Plotkin}, pages = {51-67}, publisher = {Springer-Verlag}, note = {LNCS 173}, topics = {Type Systems,Object-Orientation,Records} } @incollection{CardelliMitchell91, author = {Luca Cardelli and John C. Mitchell}, title = {{Operations on Records}}, booktitle = {{\cite{GunMit94}}}, year = 1994, chapter = {9}, pages = {295-350}, topics = {Type Systems,Records} } @article{CardelliWegner85, AUTHOR = {Luca Cardelli and Peter Wegner}, TITLE = {{On Understanding Types, Data Abstraction, and Polymorphism}}, JOURNAL = {{Computing Surveys}}, sourceURL = {http://www.luca.demon.co.uk/Papers/OnUnderstanding.A4.ps}, PAGES = {471--522}, MONTH = {December}, NUMBER = 4, YEAR = 1985, VOLUME = 17, topics = {Data Abstraction,Type Systems,Modules} } @article{Castagna95, author = {Giuseppe Castagna}, title = {{Covariance and contravariance: conflict without a cause}}, journal = {ACM Transactions on Programming Languages and Systems}, sourceURL = {ftp://ftp.ens.fr/pub/dmi/users/castagna/covariance.dvi.Z}, volume = {17}, number = {3}, pages = {431-447}, month = mar, year = 1995, abstract = {In type theoretic research on object-oriented programming the ``covariance versus contravariance issue'' is a topic of continuing debate. In this short note we argue that covariance and contravariance appropriately characterize two distinct and independent mechanisms. The so-called contravariance rule correctly captures the substitutivity, or subtyping relation (that establishes which sets of codes can replace another given set in every context). A covariant relation, instead, characterizes the specialization of code (i.e., the definition of new code that replaces the old one in some particular cases). Therefore, covariance and contravariance are not opposing views, but distinct concepts that each have their place in object-oriented systems and that both can (and should) be type safely integrated in an object-oriented language. We also show that the independence of the two mechanisms is not characteristic of a particular model but is valid in general, since covariant specialization is present also in record-based models, but is hidden by a deficiency of all calculi that realize this model. As an aside, we show that the lambda&-calculus [CGL94] can be taken as the basic calculus for both an overloading-based and a record-based model. Using this approach, one not only obtains a more uniform vision of object-oriented type theories but, in the case of the record-based approach, one also gains multiple dispatching, a feature that existing record-based models do not capture.}, topics = {Type Systems} } @book{Church51, author = {A. Church}, title = {{The Calculi of Lambda-Conversion}}, series = {Annals of Mathematical Studies}, volume = {6}, note = {(second printing, first appeared 1941)}, publisher = {Princeton University Press}, address = {Princeton}, year = 1951, topics = {FP - Lambda Calculi} } @techreport{ClackClaymanParrott95, AUTHOR = {Chris Clack and Stuart Clayman and David Parrott}, TITLE = {{Dynamic Cyclic Data Structures in Lazy Functional Languages}}, sourceURL = {http://www.cs.ucl.ac.uk/functional/graph.ps}, INSTITUTION = {Dept. of Computer Science, University College London}, YEAR = 1995, topics = {FP - Programming} } @inproceedings{ClaessenVullinghsMeijer97, author = {Koen Claessen and Ton Vullinghs and Erik Meijer}, title = {{Structuring Graphical Paradigms in TkGofer}}, booktitle = {{International Conference on Functional Programming ICFP'97}}, year = 1997, sourceURL = {}, month = jun, topics = {FP - Graphics/Visual} } @techreport{Clamen91, author = {Stewart M. Clamen}, title = {{Persistent Programming Languages - A Survey}}, institution = CMU, year = 1991, sourceURL = {ftp://reports.adm.cs.cmu.edu/usr/anon/1991/CMU-CS-91-155.ps}, abstractURL = {http://www.cs.cmu.edu/afs/cs.cmu.edu/user/clamen/www/work/persistence-abstract.html}, number = {CMU-CS-91-155}, topics = {Persistence} } @techreport{ClingerRees91, key = {ClingerRees91}, editor = {William Clinger and Jonathan Rees}, title = {{Revised(4) Report on the Algorithmic Language Scheme}}, year = 1991, sourceURL = {http://www-swiss.ai.mit.edu/~jaffer/r4rs_toc.html}, topics = {Lisp/Scheme} } @misc{Coen99, author = {Michael H. Coen}, title = {{The Future Of Human-Computer Interaction or How I learned to stop worrying and love My Intelligent Room.}}, howpublished = {to appear, IEEE Intelligent Systems. 1999}, month = {}, year = 1999, sourceURL = {http://www.ai.mit.edu/people/mhcoen/ieee.pdf}, topics = {Human Computer Interfaces} } @inproceedings{Coen98, author = {Michael H. Coen}, title = {{Design Principles for Intelligent Environments}}, booktitle = {{1998 National Conference on Artificial Intelligence (AAAI-98)}}, year = 1998, sourceURL = {http://www.ai.mit.edu/people/mhcoen/aaai98.ps}, month = {}, topics = {Human Computer Interfaces} } @misc{COM, author = {Microsoft}, title = {{Component Object Model (COM)}}, howpublished = {\url{http://www.microsoft.com/com/default.asp}}, month = Jan, year = 1999, sourceURL = {http://www.microsoft.com/com/default.asp}, topics = {Component-Based Programming} } @techreport{CommonLisp94, author = {X3J13}, title = {{ANSI Common Lisp standard}}, year = 1994, sourceURL = {http://www.harlequin.com/books/HyperSpec/}, topics = {Lisp/Scheme} } @incollection{ConnorBrownCuttsDearleMorrisonRosenberg90, author = {Connor, R.C.H. and Brown, A.B. and Cutts, Q.I. and Dearle, A. and Morrison, R. and Rosenberg, J.}, title = {{Type Equivalence Checking in Persistent Object Systems}}, booktitle = {{Implementing Persistent Object Bases}}, publisher = {Morgan Kaufmann}, year = 1990, abstractURL = {http://www-fide.dcs.st-and.ac.uk/Publications/1990.html#type.equiv}, sourceURL = {http://www-fide.dcs.st-and.ac.uk/Publications/PostScript/type.equiv.ps.gz}, editor = {Dearle, A. and Shaw, G.M. and Zdonik, S.B.}, pages = {151-164}, topics = {Persistence,Type Systems} } @InCollection{Cook91, author = {William R. Cook}, title = {{Object-Oriented Programming Versus Abstract Data Types}}, booktitle = {{Foundations of Object-Oriented Languages, REX School/Workshop, Noordwijkerhout, The Netherlands, May/June 1990}}, publisher = {Springer-Verlag}, year = 1991, editor = {J. W. de Bakker and W. P. de Roever and G. Rozenberg}, series = {Lecture Notes in Computer Science}, volume = {489}, pages = {151--178}, address = {New York, N.Y.}, topics = {Data Abstraction} } @inproceedings{CookLaunchbury97, author = {Byron Cook and John Launchbury}, title = {{Disposable Memo Functions}}, booktitle = {{ACM SIGPLAN Haskell Workshop}}, year = 1997, month = jun, topics = {FP - Implementation} } @incollection{Coquand90, author = {Thierry Coquand}, title = {{On the Analogy Between Propositions and Types}}, booktitle = {{}}, note = {English Translation, appeared in \cite{Huet90}}, annote = {Originally appeared in French as ``Sur l'analogie entre les propositions et les types'' in {\em Combinators and Functional Programming Languages}, G. Cousineau, P-L. Curien, and B.Robinet, eds: Lecture Notes in Computer Science, vol. 242, Springer-Verlag, Berlin, 1986. Translation by Walt Hill (Hewlett-Packard Laboratories).}, year = 1990, topics = {Type Systems,Logic/Category Theory} } @inproceedings{CorrensonDurisParigotRoussel98, author = {Loïc Correnson and Etienne Duris and Didier Parigot and Gilles Roussel}, title = {{Generic programming by program composition (position paper)}}, booktitle = {{Workshop on Generic Programming, Marstrand, Sweden, in conjunction with MPC'98}}, year = 1998, sourceURL = {ftp://ftp.inria.fr/INRIA/Projects/oscar/FNC-2/publications/Correnson98a.ps.gz}, month = jun, topics = {Programming/Software Engineering} } @inproceedings{CregutMacQueen94, author ="{C}regut, {P}. and {M}ac{Q}ueen, {D}. ", title ="{A}n implementation of higher-order functors", year = 1994, sourceURL ="ftp://research.att.com/dist/ml/papers/ML94/02-cregut.ps.Z", month ="{J}une", scope ="monads", booktitle ="{ACM} {SIGPLAN} {W}orkshop on {S}tandard {ML} and its {A}pplications", topics = {Modules} } @inproceedings{CroleGordon94, author={Roy L. Crole and Andrew D. Gordon}, title={{A Sound Metalogical Semantics for Input/Output Effects}}, editor={L. Pacholski and J. Tiuryn}, booktitle={{CSL'94 Computer Science Logic, Kazimierz, Poland, September 1994}}, year=1995, volume=933, publisher=SPRINGER, series=LNCS, pages={339--353}, note={Full version submitted to {\em Mathematical Structures in Computer Science}.}, sourceURL={ftp://ftp.cl.cam.ac.uk/papers/adg/csl94.ps.gz}, abstractURL = {ftp://ftp.cl.cam.ac.uk/papers/adg/index.html#csl94}, topics = {FP - Input/Output} } @misc{ConselDanvy93, author = {Charles Consel and Olivier Danvy}, title = {{Partial Evaluation: Principles and Perspectives}}, howpublished = {\url{ftp://ftp.cis.ksu.edu/pub/CIS/Danvy/tutorial-PE.ps.Z}}, year = 1993, sourceURL = {ftp://ftp.cis.ksu.edu/pub/CIS/Danvy/tutorial-PE.ps.Z}, topics = {Partial Evaluation} } @book{CurryFeys58, author = {Haskell B. Curry and Robert Feys}, title = {{Combinatory Logic}}, publisher = {North-Holland Publishing Company, Amsterdam}, year = 1974, volume = {I}, edition = {Third Printing}, topics = {FP - Lambda Calculi,Logic/Category Theory} } %% D @book{DahlDijkstraHoare72, author = {O.-J. Dahl and E.W. Dijkstra and C.A.R. Hoare}, title = {{Structured Programming}}, publisher = {Academic Press}, year = 1972, volume = {8}, series = {A.P.I.C. Studies in Data Processing}, topics = {Programming/Software Engineering} } @article{DahlNygaard66, author = {Ole-Johan Dahl and Kristen Nygaard}, title = {{SIMULA -- an ALGOL-Based Simulation Language}}, journal = CACM, year = 1966, volume = {9}, number = {9}, pages = {671-678}, month = sep, topics = {Simula} } @techreport{DahlMyhrhaugNygaard70, author = {Ole-Johan Dahl and Bj{\o}rn Myhrhaug and Kristen Nygaard}, title = {{SIMULA - Common Base Language}}, institution = {Norwegian computing center, Oslo}, year = 1970, number = {S-22}, note = {revised edition of S-2}, month = oct, topics = {Object-Orientation,Simula} } @phdthesis{Dami94, author = {Laurent Dami}, title = {{Software Composition: Towards an Integration of Functional and Object-Oriented Approaches}}, school = {Facult{\'e} des sciences {\'e}conomiques et sociales de l'Universit{\'e} de Gen{\`e}ve}, year = 1994, sourceURL = {ftp://cui.unige.ch/pub/dami/}, topics = {FP - Lambda Calculi,FP - Programming} } @techreport{Dami96a, author = {Laurent Dami}, title = {{Functional Programming with Dynamic Binding}}, institution = {Centre Universitaire d'Informatique, University of Geneva}, year = 1996, sourceURL = {ftp://cui.unige.ch/OO-articles/TechnicalReports/96/dynBind.ps.Z}, note = {(in: Object Applications, D. Tsichritzis (Ed.))}, month = aug, abstract = {Dynamic binding is a runtime operation which looks up some names in some environments: examples are "quote" and "eval" in LISP or object-oriented message passing. We present a functional language, in the spirit of ML or Haskell, which supports dynamic binding. At the surface level, the language supports constructs such as extensible records, variants, extensible case selection, quoted terms, and can encode various forms of objects. The underlying execution model is a lambda-calculus with name-based (labels, keywords) parameter passing. The type system supports subtyping, through an extension of Hindley-Milner type inference with recursively constrained types.}, topics = {FP - General} } @article{Dami97a, author = {Laurent Dami}, title = {{A Lambda-Calculus with Dynamic Binding}}, journal = {to appear in Theoretical Computer Science 192(2), special issue on Coordination, Feb 1998}, year = 1997, sourceURL = {ftp://cui.unige.ch/pub/dami/dynBind.ps.Z}, abstract = {Dynamic binding denotes a runtime lookup operation which extracts values corresponding to some ``names'' from some ``environments'' (finite, unordered associations of names and values). Many situations related with flexible software assembly involve dynamic binding: first-class modules, mobile code, object-oriented message passing. This paper proposes a compact extension of the lambda-calculus to model dynamic binding, where variables are labelled by names, and where arguments are passed to functions along named channels. The resulting formalism preserves familiar properties of the lambda-calculus, has a Curry-styletype inference system, and has a formal notion of compatibility for reasoning about extensible environments. It can encode record and record extensions, as well as first-class contexts with context-filling operations, and therefore provides a basic framework for expressing awide range of name-based coordination mechanisms. }, topics = {FP - Lambda Calculi} } @incollection{Dami97b, author = {Laurent Dami}, title = {{A Comparison of Record- and Name-Calculi}}, booktitle = {{Objects at Large}}, publisher = {Centre Universitaire d'Informatique, University of Geneva}, year = 1997, sourceURL = {http://cuiwww.unige.ch/OSG/publications/OO-articles/TechnicalReports/97/rec.ps.gz}, editor = {D. Tsichritzis}, pages = {71-83}, month = jul, topics = {Records} } @incollection{DarlingtonFieldPull86, crossref = {DeGrootLindstrom86}, author = {J. Darlington and A.J. Field and H. Pull}, title = {{The Unification Of Functional And Logic Languages}}, year = 1986, pages = {37-70}, topics = {FP - General,LP - General} } @inproceedings{DavieHammond96, author = {Tony Davie and Kevin Hammond}, title = {{Functional Hypersheets}}, booktitle = {1996 } # IFL, year = 1996, editor = {Werner Kluge}, pages = {39-48}, abstract = {We propose to integrate lazy functional programming, hyperprogramming and persistence into a program development environment that permits value and program construction. The views of the system that users will see will be via generalised spreadsheets containing formulae for the development of values of any type. These hypersheets will constitute a local or distributed network of hyperlinks.}, topics = {Persistence,Programming Environments} } @misc{DCOM97, author = {Software AG}, title = {{EntireX DCOM Release}}, howpublished = {\url{http://www.softwareag.com/corporat/solutions/entirex/}}, month = Jan, year = 1999, sourceURL = {http://http://www.softwareag.com/corporat/solutions/entirex/}, topics = {Component-Based Programming} } @book{DeGrootLindstrom86, editor = {Doug DeGroot and Gary Lindstrom}, title = {{Logic Programming, Functions, Relations and Equations}}, publisher = {Prentice Hall, Englewood Cliffs, NJ}, year = 1986, topics = {LP - General} } @book{Delong70, author = {Howard Delong}, title = {{A profile of mathematical logic}}, publisher = ADDWES, year = 1970, series = {Addison-Wesley Series in Mathematics}, topics = {Logic/Category Theory} } @inproceedings{DeMichielGabriel87, author = {L. G. DeMichiel and R. P. Gabriel}, title = {The Common Lisp Object System: An Overview}, pages = {151--170}, booktitle = {Proceedings of the European Conference on Object-Oriented Programming (ECOOP)}, series = {Lecture Notes in Computer Science}, volume = {276}, year = {1987}, publisher = {Springer-Verlag}, address = {Berlin, Heidelberg, New York, Tokyo}, abstract = {The Common Lisp Object System is an object-oriented system that is based on the concepts of generic functions, multiple inheritances of classes that form an extension to the Common Lisp type system. The Common Lisp Object System is based on a meta-object protocol that renders it possible to alter the fundamental structure of the Object System itself. The Common Lisp Object System has been proposed as a standard for ANSI Common Lisp and has been tentatively endorsed by X3J13}, ISBN = {3-540-18353-1}, topics = {Lisp/Scheme,Object-Orientation} } @article{DeRemerKron76, author = {Frank DeRemer and Hans H. Kron}, title = {{Programming-in-the-Large Versus Programming-in-the-Small}}, journal = {IEEE Transactions on Software Engineering}, year = 1976, volume = {SE-2}, number = {2}, pages = {80-76}, month = jun, topics = {Modules} } @article{Dershowitz85a, author = {Nachum Dershowitz}, title = {{Computing with Rewrite Systems}}, journal = {Information and Control}, year = 1985, number = {65}, pages = {122-157}, topics = {Rewrite Systems} } @inproceedings{Dershowitz85b, author = {Nachum Dershowitz and David A. Plaisted}, title = {{Logic Programming cum Applicative Programming}}, booktitle = {{IEEE Symposium on Logic Programming}}, year = 1985, pages = {54-66}, topics = {FP - General,LP - General,Rewrite Systems} } @incollection{DershowitzJouannaud90, author = {Nachum Dershowitz and Jean-Pierre Jouannaud}, title = {{Rewrite Systems}}, booktitle = {{Handbook of Theoretical Computer Science}}, chapter = {6}, pages = {243-320}, publisher = {North-Holland}, address = {Amsterdam}, year = 1990, sourceURL = {http://www-sal.cs.uiuc.edu/~nachum/papers/survey-draft.ps}, annote = {(the online version is a draft only)}, volume = {B: Formal Models and Semantics}, editor = {J. van Leeuwen}, topics = {Rewrite Systems} } @inproceedings{DershowitzLindenstrauss90, author = {Nachum Dershowitz and Naomi Lindenstrauss}, title = {{An Abstract Concurrent Maschine for Rewriting}}, booktitle = {{Algebraic and Logic Programming, LNCS 463}}, year = 1990, pages = {318-331}, publisher = {Springer-Verlag}, topics = {Rewrite Systems} } @misc{Dershowitz93, author = {Nachum Dershowitz}, title = {{A Taste of Rewrite Systems}}, note = {Repaired version of {\em Functional Programming, Concurrency, Simulation and Automated Reasoning}, Lecture Notes in Computer Science 693, 199-228 (1993)}, year = 1993, sourceURL = {http://www-sal.cs.uiuc.edu/~nachum/papers/taste-fixed.ps}, abstract = {This survey of the theory and applications of rewriting with equations discusses the existence and uniqueness of normal forms, the Knuth-Bendix completion procedure and its variations, as well as rewriting-based (functional and logic) programming and (equational, first-order, and inductive) theorem proving. Ordinary, associative-commutative, and conditional rewriting are covered. Current areas of research are summarized and an extensive bibliography is provided. }, topics = {Rewrite Systems} } @article{Dijkstra68, author = {Edsger W. Dijkstra}, title = {{The Structure of ``THE'' Multiprogramming System}}, journal = CACM, year = 1968, volume = {11}, number = {5}, pages = {341-346}, month = may, topics = {Programming/Software Engineering} } @article{Dijkstra72, author = {Edsger W. Dijkstra}, title = {{The Humble Programmer}}, journal = CACM, year = 1972, volume = {15}, number = {10}, pages = {859-866}, month = {October}, topics = {Programming/Software Engineering} } @article{DincbasHentenryck87, author = {M. Dincbas and P. van Hentenryck}, title = {{Extended Unification Algorithms For The Integration Of Functional Programming Into Logic Programming}}, journal = {Journal of Logic Programming}, year = 1987, number = {4}, pages = {199-227}, topics = {FP - General,LP - General,LP - Unification} } @article{DonahueDemers85, author = {James Donahue and Alan Demers}, title = {{Data Types Are Values}}, journal = {ACM Transactions on Programming Languages and Systems}, year = 1985, volume = {7}, number = {3}, pages = {426-445}, month = jul, topics = {Data Abstraction,Type Systems} } @inproceedings{Dornan98, author = {Chris Dornan}, title = {{Tcl + Haskell = TclHaskell}}, booktitle = {{Glasgow FP Group Workshop, Pitlochry, Scotland}}, note = {see also \url{http://www.dcs.gla.ac.uk/~nww/TkHaskell/TkHaskell.html}}, year = 1998, month = Sep, topics = {FP - Graphics/Visual} } @inproceedings{DurandIrne1991, author ={Durand, Ir{\`{e}}ne and Sherman, David J. and Strandh, Robert I.}, title ={Optimization of equational programs using partial evaluation}, booktitle ={Proceedings of the ACM/IFIP Symposium on Partial Evaluation and Semantics-Based Program Manipulation}, year =1991, abstractURL ={http://www.labri.u-bordeaux.fr/~david/papers/DurSheStr-pepm91.html}, sourceURL ={http://www.labri.u-bordeaux.fr/~david/papers/DurSheStr-pepm91.ps.gz}, topics = {Partial Evaluation} } %% E @misc{Elliott97, author = {Conal Elliott}, title = {{Composing Reactive Animations}}, howpublished = {\url{http://www.research.microsoft.com/~conal/fran/tutorial.htm}}, year = 1997, sourceURL = {http://www.research.microsoft.com/~conal/fran/tutorial.htm}, note = {FRAN tutorial}, topics = {FP - Graphics/Visual} } @misc{Elsman95, author = {Martin Elsman}, title = {{Implementation Dependent Compilation of Standard ML by Unfolding Modules}}, month = jul, year = 1995, sourceURL = {http://www.diku.dk/research-groups/topps/personal/mael/mypapers/unfolding_modules.dvi.Z}, institution = {DIKU TOPPS}, annote = {This paper describes how the Modules language of Standard ML may be compiled into a simple typed lambda language by unfolding Modules. }, topics = {Modules} } @inproceedings{Evans68, author = {Arthur Evans, Jr.}, title = {{PAL -- a language designed for teaching programming linguistics}}, booktitle = {{Proceedings of the 23rd ACM National Conference}}, year = 1968, pages = {395-403}, publisher = {Brandin Systems Press}, address = {Princeton, New Jersey}, topics = {Language Design/Semantics} } %% F @misc{FFI98, author = {The Haskell FFI Team}, title = {{A primitive foreign function interface (draft specification)}}, howpublished = {Follow the link to the ``Primitive FFI design document'' on \url{http://www.dcs.gla.ac.uk/fp/software/hdirect/}}, month = jun, year = 1998, sourceURL = {http://www.dcs.gla.ac.uk/fp/software/hdirect/}, topics = {Haskell,Foreign Function Interfaces} } @misc{FIDEII, key = {FIDEII}, title = {{ESPRIT Basic Research Action FIDE II}}, note = {(FIDE: Fully Integrated Data Environment, PAS: Persistent Application Systems)}, year = 1992, howpublished = {WWW home page: \url{http://www.dcs.gla.ac.uk/fide/default.html}}, sourceURL = {http://www.dcs.gla.ac.uk/fide/default.html}, topics = {Persistence} } @inproceedings{FinneLeijenMeijerPeytonJones98, author = {Sigbjorn Finne and Daan Leijen and Erik Meijer and Simon Peyton Jones}, title = {{H/Direct: A Binary Foreign Language Interface for Haskell}}, booktitle = {{International Conference on Functional Programming, ICFP'98, Baltimore}}, year = 1998, sourceURL = {http://research.microsoft.com/Users/simonpj/Papers/hdirect.ps.gz}, topics = {FP - Implementation} } @inproceedings{FinnePeytonJones95a, author = {Sigbjorn Finne and Simon Peyton Jones}, title = {{Composing Haggis}}, publisher = SPRINGER, booktitle = {{Proceedings of the Fifth Eurographics Workshop on Programming Paradigms for Computer Graphics}}, month = sep, year = 1995, sourceURL = {http://www.dcs.gla.ac.uk/~sof/haggis/composing-haggis.ps.gz}, topics = {FP - Input/Output,FP - Graphics/Visual} } @inproceedings{FinnePeytonJones95b, author = {Sigbjorn Finne and Peyton Jones}, title = {{Pictures: A simple structured graphics model}}, source_URL = {http://www.dcs.gla.ac.uk/fp/authors/Sigbjorn_Finne/picture.ps.gz}, booktitle = {}, year = 1995, topics = {FP - Input/Output,FP - Graphics/Visual} } @book{Flannagan97, author = {David Flannagan}, title = {{Java in a Nutshell}}, publisher = {O'Reilly}, year = 1997, edition = {2nd}, month = may, topics = {Java} } @misc{Fokker95, author = {Jeroen Fokker}, title = {Functional Parsers}, note = {Lecture notes of the Bastad Spring School on functional programming}, month = may, year = 1995, topics = {FP - Programming,Syntax} } @article{Fokkinga94, author = {Fokkinga, Maarten M.}, institution = {University of Twente}, title = {{Expressions that talk about themselves}}, sourceURL = {ftp://ftp.cs.utwente.nl/pub/doc/Parlevink/fokkinga/mmf94b.ps.Z}, journal = {The Computer Journal}, year = {1996}, number = {5}, pages = {408--412}, comment = {Previous version: Memoranda Informatica, Nr 94-29, June 1994.}, topics = {Reflection/Meta-Programming} } @misc{Forest, key = {Forest}, title = {{The Forest Project}}, note = {Sun Microsystems Laboratories}, howpublished = {\url{http://www.sunlabs.com/research/forest/}}, year = 1995, sourceURL = {http://www.sunlabs.com/research/forest/}, topics = {Persistence,Java} } @misc{Fox94, author = {Robert Harper and Peter Lee}, title = {{Advanced Languages for Systems Software: The Fox Project in 1994}}, year = 1994, sourceURL = {http://www.cs.cmu.edu/afs/cs.cmu.edu/project/fox/mosaic/papers/renewal.ps}, note = {(Carnegie Mellon)}, topics = {Groups and Projects} } @misc{Fox, author = {Eric Cooper and Robert Harper and Peter Lee}, title = {{The Fox Project: Advanced Development of Systems Software}}, year = 1991, sourceURL = {http://www.cs.cmu.edu/afs/cs.cmu.edu/project/fox/mosaic/papers/cooper-fox.ps}, note = {(Carnegie Mellon)}, topics = {Groups and Projects} } @misc{FrankMedak97, author = {Andrew U. Frank and Damir Medak}, title = {{Executable Axiomatic Specifications Using Functional Language -- Case Study: Base Ontology For A Spatio-Temporal Database}}, howpublished = {EMail}, year = 1997, topics = {} } @article{Frenkel93, author = {Karen A. Frenkel}, title = {{An interview with Robin Milner}}, journal = {Communications of the ACM}, year = 1993, abstractURL = {http://www.acm.org/pubs/citations/journals/cacm/1993-36-1/p90-frenkel/}, sourceURL = {http://www.acm.org/pubs/articles/journals/cacm/1993-36-1/p90-frenkel/p90-frenkel.pdf}, note = {(Turing-Award interview)}, volume = {36}, number = {1}, pages = {90-97}, month = Jan, topics = {History,Standard ML} } @incollection{FriedmanWise76, author = {D. P. Friedman and D. S. Wise}, title = {{CONS should not evaluate its arguments}}, booktitle = {{Automata, Languages and Programming}}, publisher = {Edinburgh University Press}, year = 1976, editor = {Michaelson and Milner}, topics = {FP - General} } @misc{FuncProgArchive, author = {Jon Hill}, title = {{Functional Programming Archive}}, sourceURL = {http://www.lpac.ac.uk/SEL-HPC/Articles/FuncArchive.html}, topics = {FP - General} } %% G @misc{Gabriel94, author = {Richard P. Gabriel}, title = {{Lisp: Good News, Bad News, How to Win Big}}, howpublished = {\url{http://www.ai.mit.edu/articles/good-news/good-news.html}}, month = jan, year = 1994, sourceURL = {http://www.ai.mit.edu/articles/good-news/good-news.html}, topics = {Lisp/Scheme} } @article{GabrielWhiteBobrow91, author = {Richard P. Gabriel and Jon L. White and Daniel G. Bobrow}, title = {{CLOS: Integrating Object-Oriented and Functional Programming}}, journal = CACM, year = 1991, volume = {34}, number = {9}, pages = {28-38}, month = Sep, topics = {Lisp/Scheme,Object-Orientation} } @phdthesis{Gaertner91, author = {G{\"a}rtner, D.}, title = {{\pired$^+$: ein interaktives codeausf{\"u}hrendes Reduktionssystem zur vollst{\"a}ndigen Realisierung eines angewandten $\lambda$--Kalk{\"u}ls}}, school = ifi, year = 1991, topics = {Kiel Reduction Language,FP - Implementation} } @article{GaKlu96, key = {GaKlu}, author = {G{\"a}rtner, D. and Kluge, W.E.}, title = {{\pired$^+$: An interactive compiling graph reduction system for an applied $\lambda$-calculus}}, journal = JFP, volume = {6}, number = {5}, month = Sep, year = 1996, topics = {Kiel Reduction Language} } @article{Gallaire85, author = {H. Gallaire}, title = {{Logic Programming: Further Developments}}, journal = {IEEE Symposium on Logic Programming}, year = 1985, pages = {88-96}, topics = {LP - General} } @techreport{GasterJones96, author = {Benedict R. Gaster and Mark P. Jones}, title = {{A Polymorphic Type System for Extensible Records and Variants}}, institution = {Department of Computer Science, University of Nottingham}, year = 1996, abstractURL = {http://www.cse.ogi.edu/~mpj/pubs/polyrec.html}, sourceURL = {ftp://ftp.cs.nott.ac.uk/techreports/96/3.ps.gz}, number = {NOTTCS-TR-96-3}, month = nov, topics = {Records,Type Systems} } @inproceedings{Gaster97, author = {Benedict R. Gaster}, title = {{Polymorphic Extensible Records for Haskell}}, sourceURL = {http://www.cs.nott.ac.uk/~brg/pubs/haskwork97.ps.gz}, booktitle = {Haskell Workshop}, year = 1997, month = {June}, topics = {Records}, } @misc{Gaster98, author = {Benedict R. Gaster}, title = {{A categorical semantics for qualified types}}, howpublished = {In preparation for ICFP'98}, month = apr, year = 1998, sourceURL = {}, topics = {Type Systems,Logic/Category Theory,Semantics} } @inproceedings{GelernterJagLon87, author = {David Gelernter and Suresh Jagannathan and Thomas London}, title = {{Environments as First Class Objects}}, booktitle = {14th } # POPL, year = 1987, pages = {98-110}, topics = {Modules} } @article{GeschkeMitchell75, author = {Charles M. Geschke and James G. Mitchell}, title = {{On the Problem of Uniform References to Data Structures}}, journal = {IEEE Transactions on Software Engineering}, year = 1975, volume = {SE-1}, number = {2}, pages = {207-219}, month = jun, topics = {Data Abstraction} } @article{GeschkeMorrisSatterthwaite77, author = {Charles M. Geschke and James H. {Morris Jr.} and Edwin H. Satterthwaite}, title = {{Early Experience with Mesa}}, journal = CACM, year = 1977, volume = {20}, number = {8}, pages = {540-553}, month = aug, topics = {Modules,Data Abstraction} } @misc{GHC, key = {GHC}, author = {}, title = {{GHC -- The Glasgow Haskell Compiler}}, howpublished = {\url{http://www.dcs.gla.ac.uk/fp/software/ghc/}}, month = Jan, year = 1999, sourceURL = {http://www.dcs.gla.ac.uk/fp/software/ghc/}, topics = {FP - Implementation} } @techreport{GilmoreKirliWalton97, author = {Stephen Gilmore and Dilsun K{\'i}rl{\'i} and Christopher Walton}, title = {{Dynamic ML without Dynamic Types}}, institution = {LFCS, Department of Computer Science, The University of Edinburgh}, year = 1997, sourceURL = {http://www.dcs.ed.ac.uk/home/stg/dynamic.ps.gz}, type = {Technical Report}, number = {ECS-LFCS-97-378}, month = Dec, topics = {Modules} } @article{Goguen89, author = {Joseph A. Goguen}, title = {{A Categorical Manifesto}}, journal = {Mathematical Structures in Computer Science}, year = 1989, sourceURL = {http://www-cse.ucsd.edu/users/goguen/ps/manif.ps.gz}, volume = {1}, number = {1}, pages = {49-67}, month = mar, abstract = {This paper tries to explain why and how category theory is useful in computing science, by giving guidelines for applying seven basic categorical concepts: category, functor, natural transformation, limit, adjoint, colimit and comma category. Some examples, intuition, and references are given for each concept, but completeness is not at- tempted. Some additional categorical concepts and some suggestions for further research are also mentioned. The paper concludes with some philosophical discussion.}, topics = {Logic/Category Theory} } @inproceedings{Goguen96, author = {Joseph A. Goguen}, title = {{Parameterized Programming and Software Architecture}}, booktitle = {{Fourth International Conference on Software Reuse, Orlando, Florida}}, note = {keynote address}, year = 1996, sourceURL = {http://www-cse.ucsd.edu/users/goguen/ps/orlando96.ps.gz}, editor = {}, pages = {2-11}, organization = {IEEE Computer Society}, publisher = {IEEE CS Press}, address = {}, month = apr, topics = {Modules} } @book{GoldbergRobson83, author = {Adele Goldberg and David Robson}, title = {{SmallTalk-80 The Language and its Implementation}}, publisher = ADDWES, year = 1983, topics = {SmallTalk} } @book{Gordon98, author = {Rob Gordon}, title = {{Essential JNI: Java Native Interface}}, publisher = {Prentice Hall PTR}, year = 1998, sourceURL = {http://www.phptr.com/http://www.phptr.com/ptrbooks/ptr_0136798950.html}, note = {ISBN 0-13-679895-0}, month = mar, topics = {Java,Foreign Function Interfaces} } @phdthesis{Gordon92, author ={Gordon, Andrew}, title ={{Functional Programming and Input/Output}}, school ={University of Cambridge}, month ={Aug}, year = 1992, scope ={impmonads}, topics = {FP - Input/Output} } @inproceedings{Gordon93, author = {Andrew D. Gordon}, title = {{An Operational Semantics for I/O in a Lazy Functional Language}}, booktitle = {{FPCA'93: Conference on Functional Programming Languages and Computer Architecture, Copenhagen, pages 136--145. ACM Press}}, sourceURL = {ftp://ftp.cl.cam.ac.uk/papers/adg/fpca93.ps.gz}, year = 1993, abstract = { I/O mechanisms are needed if functional languages are to be suitable for general purpose programming and several implementations exist. But little is known about semantic methods for specifying and proving properties of lazy functional programs engaged in I/O. As a step towards formal methods of reasoning about realistic I/O we investigate three widely implemented mechanisms in the setting of teletype I/O: synchronised-stream (primitive in Haskell), continuation-passing (derived in Haskell) and Landin-stream I/O (where programs map an input stream to an output stream of characters). Using methods from Milner's CCS we give a labelled transition semantics for the three mechanisms. We adopt bisimulation equivalence as equality on programs engaged in I/O and give functions to map between the three kinds of I/O. The main result is the first formal proof of semantic equivalence of the three mechanisms, generalising an informal argument of the Haskell committee. }, topics = {FP - Input/Output}} @book{Gordon94, author = {Andrew D. Gordon}, title = {{Functional Programming and Input/Output}}, publisher = {Cambridge University Press}, year = 1994, abstractURL = {http://www.cl.cam.ac.uk/users/adg/fpio.html}, series = {Distinguished Dissertations in Computer Science}, topics = {FP - Input/Output} } @inproceedings{Gordon95a, author={Andrew D. Gordon}, title={{A Tutorial on Co-induction and Functional Programming}}, sourceURL = {ftp://ftp.cl.cam.ac.uk/papers/adg/fp94.ps.gz}, abstractURL = {ftp://ftp.cl.cam.ac.uk/papers/adg/index.html#fp94}, booktitle = {{Functional Programming, Glasgow 1994}}, publisher=SPRINGER, series={Workshops in Computing}, year=1995, pages={78--95}, topics = {FP - General} } @inproceedings{GordonHammond95, author = {Andrew Gordon and Kevin Hammond}, title = {{Monadic I/O in Haskell 1.3}}, booktitle = {{Proc. of the Haskell Workshop, La Jolla, California}}, month = jun, year = 1995, note = {( Yale University Research Report YALEU/DCS/RR-1075, 1995)}, abstractURL = {ftp://ftp.cl.cam.ac.uk/papers/adg/index.html#haskell95}, sourceURL = {http://www.cl.cam.ac.uk/users/adg/haskell95/io-tutorial.dvi.gz}, abstract = {We describe the design and use of monadic I/O in Haskell 1.3, the latest revision of the lazy functional programming language Haskell. Haskell 1.3 standardises the monadic I/O mechanisms now available in many Haskell systems. The new facilities allow more sophisticated text-based application programs to be written portably in Haskell. Apart from the use of monads, the main advances over standard Haskell 1.2 are: character I/O based on handles (analogous to ANSI C file pointers), an error handling mechanism, terminal interrupt handling and a POSIX interface. The standard also provides implementors with a flexible framework for extending Haskell to incorporate new language features. In addition to a tutorial description of the new facilities this paper includes a worked example: a monad for combinator parsing which is based on the standard I/O monad. }, topics = {FP - Input/Output} } @techreport{Graham95, author = {T. C. Nicholas Graham}, title = {{Declarative Development of Interactive Systems}}, institution = {GMD}, year = 1995, sourceURL = {http://www.cs.yorku.ca/People/graham/ddis.html}, number = {243}, topics = {FP - Input/Output} } @article{Greenberger64, author = {Martin Greenberger}, title = {{The Computers of Tomorrow}}, journal = {The Atlantic Monthly}, year = 1964, sourceURL = {http://www.theatlantic.com/unbound/flashbks/computer/greenbf.html}, volume = {213}, number = {5}, pages = {63--67}, month = may, topics = {History} } @misc{GreenCard98, author = {The Green Card Team}, title = {{The Green Card Manual (version 2.0)}}, howpublished = {\url{http://www.dcs.gla.ac.uk/fp/software/green-card/}}, month = Jan, year = 1999, sourceURL = {http://www.dcs.gla.ac.uk/fp/software/green-card/}, topics = {Haskell,Foreign Function Interfaces} } @inproceedings{Grosch95, author = {Franz-Josef Grosch}, title = {{Eine typisierte, rein funktionale Modulsprache f{\"u}r das Programmieren-im-Gro{\ss}en}}, booktitle = {{Proc. 12. Workshop GI-Fachgruppe 2.1.4, Alternative Konzepte f{\"u}r Sprachen und Rechner, Bad Honnef, Germany, May 1995}}, year = 1995, sourceURL = {ftp://ftp.ips.cs.tu-bs.de/pub/local/softech/papers/badhonnef.ps.gz}, topics = {Modules} } @book{GunMit94, editor = {Carl A. Gunter and John C. Mitchell}, title = {{Theoretical Aspects of Object-Oriented Programming: Types, Semantics, and Language Design}}, series = {Foundations of Computing}, publisher = {MIT Press}, year = 1994, topics = {Type Systems,Records} } @article{Guttag77, author = {John Guttag}, title = {{Abstract Data Types and the Development of Data Structures}}, journal = CACM, year = 1977, volume = {20}, number = {6}, pages = {396-404}, month = jun, topics = {Data Abstraction} } %% H @article{HallHammondPeytonJonesWadler96, author = {Cordelia V. Hall and Kevin Hammond and Simon L. Peyton Jones and Philip L. Wadler}, title = {{Type classes in Haskell}}, journal = {ACM Transactions on Programming Languages and Systems}, year = 1996, abstractURL = {http://www.acm.org/pubs/citations/journals/toplas/1996-18-2/p109-hall/}, sourceURL = {http://www.acm.org/pubs/articles/journals/toplas/1996-18-2/p109-hall/p109-hall.pdf}, volume = {18}, number = {2}, pages = {109-138}, month = Mar, topics = {Type Systems} } @misc{Hamburg, author = {miscellaneous authors}, title = {{DBIS (Hamburg) Research Group Publications}}, sourceURL = {http://idom-www.informatik.uni-hamburg.de/Paper/pub-list.html}, topics = {Persistence} } @inproceedings{HammondMcNallySansomTrinder92, author = {Kevin Hammond and Dave McNally and Patrick M. Sansom and Phil Trinder}, title = {{Improving Persistent Data Manipulation for Functional Languages}}, booktitle = {{Glasgow FP Workshop}}, year = 1992, sourceURL = {ftp://ftp.dcs.glasgow.ac.uk/pub/glasgow-fp/authors/Patrick_Sansom/1992_persistent-data_GLASGOWFP.ps.gz}, editor = {J. Launchbury and P.M. Sansom}, pages = {72-84}, publisher = SPRINGER, topics = {Persistence} } @misc{Hanus97a, author = {Michael Hanus}, title = {{Functional Logic Programming}}, howpublished = {\url{http://www-i2.informatik.rwth-aachen.de/hanus/FLP/}}, month = {}, year = 1997, sourceURL = {http://www-i2.informatik.rwth-aachen.de/hanus/FLP/}, topics = {FP - General,LP - General} } @inproceedings{Hanus97b, author = {Michael Hanus}, title = {{A Unified Computation Model for Functional and Logic Programming}}, booktitle = {24th } # POPL, year = 1997, sourceURL = {http://www-i2.informatik.rwth-aachen.de/~hanus/publications/papers/POPL97.html}, pages = {80-93}, abstract = {We propose a new computation model which combines the operational principles of functional languages (reduction), logic languages (non-deterministic search for solutions), and integrated functional logic languages (residuation and narrowing). This computation model combines efficient evaluation principles of functional languages with the problem-solving capabilities of logic programming. Since the model allows the delay of function calls which are not sufficiently instantiated, it also supports a concurrent style of programming. We provide soundness and completeness results and show that known evaluation principles of functional logic languages are particular instances of this model. Thus, our model is a suitable basis for future declarative programming languages. } , topics = {FP - General,LP - General} } @misc{Hanus99, author = {Michael Hanus (ed.)}, title = {{Curry: An Integrated Functional Logic Language (Version 0.5 of January 13, 1999)}}, howpublished = {\url{http://www-i2.informatik.rwth-aachen.de/~hanus/curry/report.html}}, month = Jan, year = 1999, sourceURL = {http://www-i2.informatik.rwth-aachen.de/~hanus/curry/report.html}, topics = {FP - General,LP - General} } @article{Harel88, author = {David Harel}, title = {{On Visual Formalisms}}, journal = CACM, year = 1988, volume = {31}, number = {5}, pages = {514--530}, month = apr, topics = {} } @techreport{HarperLillibridge94, author = {Robert Harper and Mark Lillibridge}, title = {{A Type-Theoretic Approach to Higher-Order Modules with Sharing}}, sourceURL = {http://www.cs.cmu.edu:8001/afs/cs/user/rwh/public/papers/sharing.ps}, number = {CMU-CS-FOX-93-04}, institution = CMU, note = {published in Proc. 21st } # POPL, month = Jan, year = 1994, abstract = {The design of a module system for constructing and maintaining large programs is a difficult task that raises a number of theoretical and practical issues. A fundamental issue is the management of the flow of information between program units at compile time via the notion of an interface. Experience has shown that fully opaque interfaces are awkward to use in practice since too much information is hidden, and that fully transparent interfaces lead to excessive interdependencies, creating problems for maintenance and separate compilation. The ``sharing'' specifications of Standard ML address this issue by allowing the programmer to specify equational relationships between types in separate modules, but are not expressive enough to allow the programmer complete control over the propagation of type information between modules. These problems are addressed from a type-theoretic viewpoint by considering a calculus based on Girard's system F! . The calculus differs from those considered in previous studies by relying exclusively on a new form of weak sum type to propagate information at compile-time, in contrast to approaches based on strong sums which rely on substitution. The new form of sum type allows for the specification of equational, as well as type and kind, information in interfaces. This provides complete control over the propagation of compile- time information between program units and is sufficient to encode in a straightforward way most uses of type sharing specifications in Standard ML. Modules are treated as ``first-class'' citizens, and therefore the system supports higher-order modules and some object-oriented programming idioms; the language may be easily restricted to ``second-class'' modules found in ML-like languages.}, topics = {Modules,Type Systems} } @techreport{HarperMacQueenMilner86, author = {Robert E. Harper and David MacQueen and Robin Milner}, title = {{Standard ML}}, note = {(ECS-LFCS-86-2)}, institution = EDCS, month = mar, year = 1986, topics = {Standard ML} } @misc{HarperMitchell96, author = {Robert Harper and John C. Mitchell}, title = {{ML and Beyond}}, note = {position statement from the `Workshop on Strategic Directions in Computing Research'}, howpublished = {ACM Computing Surveys, Volume 28A(4)}, sourceURL = {http://www.medg.lcs.mit.edu/sdcr/28A/PL/HarperPL/paper.ps}, month = dec, year = 1996, abstract = {ML is a successful programming language that reconciles theoretical principles with pragmatic requirements. However, there are many shortcomings of the current language and implementations. This short note outlines some promising directions for future work. }, topics = {Standard ML} } @inproceedings{HarperMitchellMoggi90, title = {{Higher Order Modules and the Phase Distinction}}, author = {Robert Harper and John C. Mitchell and Eugenio Moggi}, sourceURL = {http://www.cs.cmu.edu:8001/afs/cs/user/rwh/public/papers/phase.ps}, booktitle = {17th } # POPL, year = 1990, note = {(expanded)}, abstract = { Typed $\lambda$-calculus is an important tool in programming language research because it provides an extensible framework for studying language features both in isolation and in their relation to each other. In earlier work we introduced a predicative function calculus, XML, for modeling several aspects of the Standard ML type system. Following MacQueen, our study focused on the use of dependent types to represent the modularity constructs of Standard ML. In addition to shedding some light on the trade-offs between language features, our analysis suggested that the first-order modules system of ML could be naturally extended to higher orders. However, whereas ML maintains a clear distinction between compile-time and run-time in both its implementation and formal semantics, the XML calculus blurs this distinction. Since static type checking is, in our view, essential to the practical utility of ML, we introduce a refinement of the XML calculus for which type checking is decidable at compile time. This calculus is based on a refinement of our earlier treatment of universes, and employs a non-standard equational theory of modules and signatures inspired by a category-theoretic account of the phase distinction. }, topics = {Modules} } @techreport{Harper86, author = {Robert E. Harper}, title = {{Modules and Persistence in Standard ML}}, note = {(ECS-LFCS-86-11)}, institution = EDCS, month = sep, year = 1986, topics = {Modules,Persistence,Standard ML} } @techreport{HarperLee94, AUTHOR = {Robert Harper and Peter Lee}, TITLE = {{Advanced Languages fo Systems Software: The Fox Project in 1994}}, sourceURL = {http://www.cs.cmu.edu/afs/cs.cmu.edu/project/fox/mosaic/papers/renewal.ps}, INSTITUTION = {Carnegie Mellon University, Pittsburgh}, NUMBER = {CMU-CS-94-104}, YEAR = 1994, topics = {Standard ML,ML2000} } @techreport{Haskell98, author = {S.~P.~Jones and J.~Hughes and L.~Augustsson and D.~Barton and B.~Boutel and W.~Burton and J.~Fasel and K.~Hammond and R.~Hinze and P.~Hudak and T.~Johnsson and M.~Jones and J.~Launchbury and E.\ Meijer and J.~Peterson and A.~Reid and C.~Runciman and P.~Wadler}, title = {{Haskell 98: A Non-strict, Purely Functional Language}}, year = 1999, note = {Available at \url{http://www.haskell.org}}, sourceURL = {}, month = feb, topics = {Haskell} } @techreport{Haskell98libraries, author = {S.~P.~Jones and J.~Hughes and L.~Augustsson and D.~Barton and B.~Boutel and W.~Burton and J.~Fasel and K.~Hammond and R.~Hinze and P.~Hudak and T.~Johnsson and M.~Jones and J.~Launchbury and E.~Meijer and J.~Peterson and A.~Reid and C.~Runciman and P.~Wadler}, title = {{Standard Libraries for Haskell 98}}, year = 1999, note = {available at \url{http://www.haskell.org}}, sourceURL = {}, month = feb, topics = {Haskell} } @article{Heering85, author = {Jan Heering and Paul Klint}, title = {{Towards Monolingual Programming Environments}}, journal = {ACM Transactions on Programming Languages and Systems}, year = 1985, volume = {7}, number = {2}, pages = {183--213}, month = apr, topics = {Programming Environments} } @incollection{Henderson82, crossref = {DarlingtonHendersonTurner82}, author = {Peter Henderson}, title = {{Purely Functional Operating Systems}}, year = 1980, pages = {177-192}, topics = {FP - General,FP - Input/Output,FP - Nonsequential Execution} } @book{DarlingtonHendersonTurner82, editor = {J. Darlington and P. Henderson and D.A. Turner}, booktitle = {{Functional programming and its applications}}, publisher = {Cambridge University Press}, year = 1982, topics = {FP - General} } @book{Henderson80, author = {Peter Henderson}, title = {{Functional Programming -- Application and Implementation}}, publisher = {Prentice/Hall International}, year = 1980, series = {Series in Computer Science}, topics = {FP - General,FP - Implementation} } @inproceedings{HendersonMorris76, author = {Peter Henderson and James H. Morris, Jr.}, title = {{A Lazy Evaluator}}, booktitle = {3rd } # POPL, year = 1976, pages = {95-103}, topics = {FP - Implementation} } @article{Henglein93, author = {Fritz Henglein}, title = {{Type inference with polymorphic recursion}}, journal = {ACM Transactions on Programming Languages and Systems}, year = 1993, sourceURL = {http://www.acm.org/pubs/articles/journals/toplas/1993-15-2/p253-henglein/p253-henglein.pdf}, volume = {15}, number = {2}, pages = {253-289}, month = Apr, topics = {Type Systems} } @techreport{Hill94, author ={Hill, Jonathan M. D. and Clarke, Keith}, title ={{An introduction to category theory, category theory monads, and their relationship to functional programming}}, number ={QMW-DCS-681}, institution ={Department of Computer Science, Queen Mary and Westfield College}, month = Aug, year = 1994 , scope ={monads}, abstractURL ={http://www.dcs.qmw.ac.uk/publications/reports/qmw681/qmw681.html}, sourceURL ={ftp://ftp.dcs.qmw.ac.uk/cpc/jon_hill/qmw681.ps.Z}, documentSize={59.1 kbytes}, orig_keywords ={Monads; Category theory; Kleisli triple; Imperative functional programming}, topics = {FP - Monads,Logic/Category Theory} } @book{HindleySeldin86, author = {J. Roger Hindley and Jonathan P. Seldin}, title = {{Introduction to Combinators and $\lambda$-calculus}}, publisher = {Cambridge University Press}, year = 1986, volume = {1}, series = {London Mathematical Society -- Student Texts}, topics = {FP - Lambda Calculi} } @incollection{Hoare66, author = {C. A. R. Hoare}, title = {{Record Handling}}, booktitle = {{Programming Languages, NATO Advanced Study Institute}}, note = {(proceedings of a Summer School held in Villard-de-Lans, 1966)}, publisher = {Academic Press, London}, year = 1968, editor = {F. Genuys}, pages = {291-347}, topics = {Records} } @techreport{HolyerCarter95, author = {Ian Holyer and David Carter}, title = {{Deterministic Concurrency}}, institution = {Department of Computer Science, University of Bristol}, year = 1995, abstractURL = {http://www.cs.bris.ac.uk/%7Eian/Functional/conc-paper.html}, sourceURL = {http://www.cs.bris.ac.uk/%7Eian/Functional/conc-paper.ps.gz}, number = {CSTR-95-015}, month = Jun, topics = {FP - Nonsequential Execution} } @misc{HolyerDaviesDornan95, author = {I Holyer and N Davies and C Dornan}, title = {{The Brisk Project: Concurrent and Distributed Functional Systems}}, month = jun, year = 1995, abstractURL = {http://www.cs.bris.ac.uk/Tools/Reports/Abstracts/1995-holyer.html}, sourceURL = {http://www.cs.bris.ac.uk/Tools/Reports/Ps/1995-holyer.ps.gz}, note = {(Bristol Functional Programming Research)}, topics = {FP - Nonsequential Execution,Groups and Projects} } @misc{HookSheard, author = {James Hook and Tim Sheard}, title = {{A Semantics of Compile-time Reflection}}, howpublished = {\url{http://www.cse.ogi.edu/~sheard/papers/crmlsemantics.dvi}}, year = {19??}, sourceURL = {http://www.cse.ogi.edu/~sheard/papers/crmlsemantics.dvi}, topics = {Reflection/Meta-Programming} } @incollection{Howard69, author = {W. A. Howard}, title = {{The Formulae-As-Types Notion Of Construction}}, booktitle = {{To H. B. Curry: Essays on Combinatory Logic, Lambda Calculus and Formalism}}, publisher = {Academic Press, Inc.}, year = 1980, localURL = {}, sourceURL = {}, editor = {J. P. Seldin and J. R. Hindley}, pages = {479--490}, address = {New York, N.Y.}, topics = {Type Systems,History,FP - Lambda Calculi} } @misc{Howe97, author = {Denis Howe}, title = {{Free On-line Dictionary of Computing}}, howpublished = {\url{http://wombat.doc.ic.ac.uk/foldoc/index.html}}, year = 1997, sourceURL = {http://wombat.doc.ic.ac.uk/foldoc/index.html}, topics = {} } @article{Hudak89, author = {Paul Hudak}, title = {{Conception, Evolution, and Application of Functional Programming Languages}}, journal = {ACM Computing Surveys}, year = 1989, volume = {21}, number = {3}, pages = {359-411}, month = sep, topics = {FP - General} } @techreport{HudakPeytonJonesWadler92, key = {Haskell 1.2}, editor = {P. Hudak and S. Peyton Jones and P. Wadler}, title = {{Report on the Programming Language Haskell A Non-strict, Purely Functional Language (Version 1.2)}}, institution = {Haskell comittee}, url = {http://www.informatik.uni-kiel.de/~haskell/report-1.2.dvi.gz}, month = mar, year = 1992 , topics = {Haskell} } @inproceedings{HudakSmith86, author = {Paul Hudak and Lauren Smith}, title = {{Para-Functional Programming: A Paradigm for Programming Multiprocessor Systems}}, booktitle = {13th } # POPL, year = 1986, pages = {243--254}, organization = {ACM}, topics = {FP - Nonsequential Execution} } @techreport{Hudak93, author = {Paul Hudak}, institution = {Yale University, Dept. of Computer Science}, sourceURL = {ftp://nebula.systemsz.cs.yale.edu/pub/yale-fp/papers/madt.ps.Z}, key = {}, title = {{Mutable Abstract Datatypes or How to Have Your State and Munge It Too}}, year = 1993, topics = {Data Abstraction,FP - State} } @TechReport{HudakJones94, author = {P. Hudak and M. P. Jones}, email = {{hudak-paul,jones-mark}@cs.yale.edu}, title = {{Haskell vs. Ada vs.\ C++ vs.\ Awk vs.\ \ldots An Experiment in Software Prototyping Productivity}}, institution = {Yale}, month = jul, year = 1994, sourceURL = {ftp://nebula.cs.yale.edu/pub/yale-fp/papers/NSWC/jfp.ps}, pages = {17}, abstract = {We describe the results of an experiment in which several conventional programming languages, together with the functional language Haskell, were used to prototype a Naval Surface Warfer Center (NSWC) requirement for a {\em Geometric Region Server}. The resulting programs and development metrics were reviewed by a committe chosen by the Navy. The results indicate that the Haskell prototype took significantly less time to develop and was considerably more concise and easier to understand than the corresponding prototypes written in several different imperative languages, including Ada and C++.}, topics = {FP - General} } @techreport{HudakPetersonFasel97, author = {Paul Hudak and John Peterson and Joseph H. Fasel}, title = {{A Gentle Introduction to Haskell}}, year = 1997, sourceURL = {ftp://haskell.org/pub/tutorial/tutorial.ps.gz}, type = {Tutorial}, month = Mar, topics = {Haskell} } @techreport{HudakRabin93, author = {Paul Hudak and Dan Rabin (eds.)}, institution = {}, sourceURL = {ftp://nebula.cs.yale.edu/pub/yale-fp/papers/state-bib.ps.gz}, title = {{State in Functional Languages - An Annotated Bibliography Version 0.0}}, year = 1993, topics = {FP - State} } @techreport{HudakSundaresh89, author = {Paul Hudak and Raman S. Sundaresh}, title = {{On The Expressiveness of Purely Functional I/O Systems}}, institution = {Dept. of Computer Science, Yale University}, sourceURL = {ftp://nebula.cs.yale.edu/pub/yale-fp/papers/io_tr.ps.Z}, year = 1989, topics = {FP - Input/Output} } @book{Huet90, editor = {G{\'{e}}rard Huet}, title = {{Logical Foundations of Functional Programming}}, publisher = ADDWES, year = 1990, series = {University of Texas at Austin Year of Programming Series}, topics = {FP - General,FP - Lambda Calculi,Type Systems} } @article{Huet97, author = {Gerard Huet}, title = {{Functional Pearl: The Zipper}}, journal = {Journal of Functional Programming}, year = 1997, volume = {7}, number = {5}, pages = {549-554}, month = sep, topics = {FP - Programming} } @InProceedings{Hughes82, author = {R. J. M. Hughes}, title = {Super combinators - a new implementation technique for applicative languages}, booktitle = {ACM Symposium on Lisp and functional programming}, location = {Pittsburgh}, month = aug, year = 1982, orig_keywords = {FP, SKI, functional programming, lambda lifting}, note = {see also Oxford PRG-28}, topics = {FP - Implementation} } @incollection{Hughes90, author = {John Hughes}, title = {{Why functional programming matters}}, booktitle = {{Research Topics in Functional Programming}}, publisher = ADDWES, year = 1990, topics = {FP - General} } @article{Hughes1989, author ={Hughes, John}, title ={{Why Functional Programming Matters}}, journal ={{The Computer Journal}}, number ={2}, volume ={32}, month ={February}, year = 1989, scope ={pearls}, abstractURL ={http://www.cs.chalmers.se/~rjmh/Papers/whyfp.html}, sourceURL ={http://www.cs.chalmers.se/~rjmh/Papers/whyfp.ps}, orig_keywords ={higher order functions lazy evaluation modularity tutorial}, topics = {FP - General} } @misc{Hughes96, author = {John Hughes}, title = {{Type Specialisation for the Lambda-calculus; or, A New Paradigm for Partial Evaluation based on Type Inference}}, sourceURL = {http://www.cs.chalmers.se/~rjmh/TypedPE/revision.ps}, note = {Dagstuhl Seminar "Partial Evaluation"}, year = 1996, topics = {Partial Evaluation,Type Systems} } @misc{Hughes97, key = {John Hughes}, author = {John Hughes (Chair of the Standard Haskell Committee)}, title = {{Standard Haskell}}, howpublished = {\url{http://www.cs.chalmers.se/~rjmh/Haskell/}}, year = 1998, sourceURL = {http://www.cs.chalmers.se/~rjmh/Haskell/}, topics = {Haskell} } @misc{Hugs, key = {Hugs}, title = {{Hugs Home Page}}, howpublished = {\url{http://www.haskell.org/hugs/}}, month = Jan, year = 1999, sourceURL = {http://www.haskell.org/hugs/}, topics = {FP - Implementation} } @article{Hutton92, author = {Graham Hutton}, title = {Higher-Order Functions for Parsing}, journal = {Journal of Functional Programming}, volume = 2, number = 3, pages = {323--343}, month = jul, year = 1992, topics = {FP - Programming,Syntax} } @techreport{HuttonMeijer96, author = {Graham Hutton and Erik Meijer}, title = {{Monadic parser combinators}}, institution = {Department of Computer Science, University of Nottingham}, year = 1996, sourceURL = {http://www.cs.nott.ac.uk/Department/Staff/gmh/monparsing.ps}, number = {NOTTCS-TR-96-1}, topics = {FP - Monads,FP - Programming} } @article{HuttonMeijer97, author = {Graham Hutton and Erik Meijer}, title = {{Monadic parser combinators}}, journal = JFP, sourceURL = {http://www.cs.nott.ac.uk/Department/Staff/gmh/pearl.ps}, annote = {condensed version of HuttonMeijer96 as a functional pearl}, year = 1996, topics = {FP - Monads,FP - Programming} } @misc{Hutton97, editor = {Graham Hutton}, title = {{Frequently Asked Questions for comp.lang.functional}}, howpublished = {\url{http://www.cs.nott.ac.uk/Department/Staff/gmh/faq.html}}, month = aug, year = 1997, sourceURL = {http://www.cs.nott.ac.uk/Department/Staff/gmh/faq.html}, topics = {FP - General} } @misc{Hutton98, author = {Graham Hutton}, title = {{Fold and Unfold for Program Semantics}}, howpublished = {\url{http://www.cs.nott.ac.uk/Department/Staff/gmh/semantics.ps}}, month = sep, year = 1997, abstractURL = {http://www.cs.nott.ac.uk/Department/Staff/gmh/bib.html#semantics}, sourceURL = {http://www.cs.nott.ac.uk/Department/Staff/gmh/semantics.ps}, topics = {Semantics,FP - General,FP - Programming} } %% I @Proceedings{icfp96, key = {ICFP96}, editor = {}, booktitle = {Proceedings of the {ACM SIGPLAN '96 International Conference on Functional Programming (ICFP '96), May 24--26, 1996}}, title = {Proceedings of the {ACM SIGPLAN '96 International Conference on Functional Programming (ICFP '96), May 24--26, 1996}}, volume = {31(5)}, publisher = {ACM Press}, address = {New York, NY, USA}, pages = {vi + 273}, month = jun, year = 1996, series = {ACM SIG{\-}PLAN Notices}, topics = {FP - General} } @proceedings{ifl96, editor = {Werner Kluge}, title = {{Implementation of Functional Languages, 8th International Workshop, Bad Godesberg, Germany, September 1996, Selected Papers}}, publisher = {Springer Verlag}, series = {Lecture Notes in Computer Science}, number = {1268}, year = 1997, abstractURL = {http://www.informatik.uni-kiel.de/inf/Kluge/calendar/lncs/}, topics = {FP - General} } @inproceedings{Ingalls78, author = {Daniel H. H. Ingalls}, title = {{The Smalltalk-76 Programming System Design and Implementation}}, booktitle = {5th } # POPL, year = 1978, pages = {9-15}, topics = {Object-Orientation,SmallTalk} } %% J @inproceedings{Jagannathan1994, author ={Jagannathan, Suresh}, title ={{Dynamic Modules in Higher-Order Languages}}, publisher ={IEEE}, booktitle ={{International Conference on Computer Languages}}, year = 1994, sourceURL ={ftp://ftp.nj.nec.com/pub/pls/iccl94.ps}, topics = {Modules} } @misc{Jay98b, author = {Jay, C.B.}, title = {{Poly-dimensional regular arrays in FISh}}, year = {1998}, month = {{A}pril}, note = {submitted to ICFP'98}, topics = {} } @misc{JavaMS, key = {JavaMS}, title = {{Microsoft Technologies for Java Home Page}}, howpublished = {\url{http://www.microsoft.com/java/}}, month = Jan, year = 1999, sourceURL = {http://www.microsoft.com/java/}, topics = {Java} } @misc{Java, key = {Java}, title = {{Java Technology Home Page}}, howpublished = {\url{http://java.sun.com/}}, month = Jan, year = 1999, sourceURL = {http://java.sun.com/}, topics = {Java} } @misc{JavaSpecs, key = {Java}, title = {{Java Documentation Page}}, howpublished = {\url{http://java.sun.com/docs/}}, year = 1998, sourceURL = {http://java.sun.com/docs/}, topics = {Java} } @misc{JDK12, author = {JavaSoft}, title = {{Java Development Kit, Version 1.2}}, howpublished = {\url{http://java.sun.com/products/jdk/1.2/}}, note = {See the online documentation. JDK 1.2 was released in December 1998 as Java 2}, month = Jan, year = 1999, sourceURL = {http://java.sun.com/products/jdk/1.2/}, topics = {Java} } @misc{JNI97, author = {JavaSoft}, title = {{Java Native Interface Specification, Release 1.1 (Revised May, 1997)}}, note = {For later modifications, see documentation of JDK1.2betaX}, howpublished = {\url{ftp://ftp.javasoft.com/docs/jdk1.1/jni.ps}}, month = may, year = 1997, sourceURL = {ftp://ftp.javasoft.com/docs/jdk1.1/jni.ps}, topics = {Java,Foreign Function Interfaces} } @misc{JavaNativeMS98, author = {Microsoft}, title = {{Integrating Java and COM}}, howpublished = {Follow links ``Technical Information'' and ``Technical Articles'' at \cite{JavaMS}}, month = Jan, year = 1999, sourceURL = {http://www.microsoft.com/java/resource/techart.htm}, topics = {Java,Foreign Function Interfaces} } @techreport{JefferyHendersonSomogyi98, author = {David Jeffery, Fergus Henderson and Zoltan Somogyi}, title = {{Type classes in Mercury}}, institution = {Department of Computer Science, University of Melbourne, Melbourne, Australia}, year = 1998, sourceURL = {http://www.cs.mu.oz.au/research/mercury/information/papers/mu_98_13.ps.gz}, number = {98/13}, month = Sep, topics = {Type Systems,LP - Languages} } @inproceedings{JefferyDowdSomogyi99, author = {David Jeffery, Tyson Dowd and Zoltan Somogyi}, title = {{MCORBA: A CORBA Binding for Mercury}}, booktitle = {{Practical Aspects of Declarative Languages: First International Workshop}}, year = 1999, sourceURL = {http://www.cs.mu.oz.au/research/mercury/information/papers/mcorba_padl99.ps.gz}, publisher = {Springer Verlag}, month = Jan, topics = {Component-Based Programming,LP - Languages} } @inproceedings{Johnsson84, author = {Thomas Johnsson}, title = {{Efficient Compilation of Lazy Evaluation}}, booktitle = {{SIGPLAN '84 Symposium on Compiler Construction}}, year = 1984, sourceURL = {http://www.cs.chalmers.se/~johnsson/Papers/efficient-compilation-lazy-evaluation.ps.gz}, note = {(also as part C of author's thesis)}, topics = {FP - Implementation} } @phdthesis{Johnsson87, author = {Thomas Johnsson}, title = {{Compiling Lazy Functional Languages: An Introduction}}, school = {Department of Computer Science, Chalmers University, Sweden}, year = 1987, note = {This is part A of the thesis, parts B, C, and D are \cite{Johnsson85,Johnsson84,Johnsson86a}}, sourceURL = {http://www.cs.chalmers.se/~johnsson/Papers/diss-intro.ps.gz}, topics = {FP - Implementation} } @inproceedings{Johnsson85, author = {Thomas Johnsson}, title = {{Lambda Lifting: Transforming Programs to Recursive Equations}}, booktitle = {{Proceedings 1985 Conference on Functional Programming Languages and Computer Architecture, Nancy, France, LNCS 201}}, year = 1985, sourceURL = {http://www.cs.chalmers.se/~johnsson/Papers/lambda-lifting.ps.gz}, note = {(also as part B of author's thesis)}, publisher = SPRINGER, topics = {FP - Implementation} } @inproceedings{Johnsson86a, author = {Thomas Johnsson}, title = {{Target code Generation from G-machine code}}, booktitle = {{Workshop on Graph Reduction, Santa Fe, LNCS 279}}, year = 1986, sourceURL = {http://www.cs.chalmers.se/~johnsson/Papers/code-generation-from-g-code.ps.gz}, publisher = SPRINGER, note = {(also as part D of author's thesis)}, month = sep, topics = {FP - Implementation} } @inproceedings{Johnsson86b, author = {Thomas Johnsson}, title = {{Attribute Grammars as a Functional Programming Paradigm}}, booktitle = {{Conference on Functional Programming Languages and Computer Architecture, Portland, Oregon, U.S.A., LNCS 274}}, year = 1987, sourceURL = {http://www.cs.chalmers.se/~johnsson/Papers/attribute-grammars.ps.gz}, publisher = SPRINGER, month = sep, topics = {FP - Programming,Attribute Grammars} } @article{JonesSinclair89, author = {S.B. Jones and A.F. Sinclair}, title = {{Functional Programs and Operating Systems}}, journal = {The Computer Journal}, year = 1989, volume = {32}, number = {2}, pages = {162-174}, topics = {FP - Input/Output} } @InProceedings{Jones92a, author = {Jones, Mark P.}, title = {{A theory of qualified types}}, address = {Rennes, France}, booktitle = {{European symposium on programming, ESOP '92}}, publisher = {Springer Verlag LNCS 582}, sourceURL = {http://www.cse.ogi.edu/~mpj/pubs/esop92.html}, month = {February}, year = 1992, topics = {Type Systems} } @book{Jones92b, author = {Mark P. Jones}, title = {{Qualified Types: Theory and Practice}}, publisher = {Cambridge University Press}, year = 1995, series = {Distinguished Dissertations in Computer Science}, month = jan, abstract = {Qualified types can be viewed as a generalization of type classes in the functional language Haskell and the theorem prover Isabelle. These in turn are extensions of equality types in Standard ML. Other applications of qualified types include extensible records and subtyping. This book describes the use of qualified types to provide a general framework for the combination of polymorphism and overloading. Using a general formulation of qualified types, the author extends the Damas/Milner type inference algorithm to support qualified types. In addition, he describes a new technique for establishing suitable coherence conditions that guarantee the same semantics for all possible translations of a given term. Practical issues that arise in concrete implementations are also discussed, concentrating in particular on the implementation of overloading in Haskell and Gofer, a small functional programming system developed by the author. This book will be suitable for advanced graduate students and researchers in computer science. }, topics = {Type Systems} } @article{Jones93, author = {Mark P. Jones}, title = {{A system of constructor classes: overloading and implicit higher-order polymorphism}}, sourceURL = {http://www.cse.ogi.edu/~mpj/pubs/fpca93.html}, year = 1993, abstract = {This paper describes a flexible type system which combines overloading and higher-order polymorphism in an implicitly typed language using a system of constructor classes -- a natural generalization of type classes in Haskell. We present a wide range of examples which demonstrate the usefulness of such a system. In particular, we show how constructor classes can be used to support the use of monads in a functional language. The underlying type system permits higher-order polymorphism but retains many of many of the attractive features that have made the use of Hindley/Milner type systems so popular. In particular, there is an effective algorithm which can be used to calculate principal types without the need for explicit type or kind annotations. A prototype implementation has been developed providing, amongst other things, the first concrete implementation of monad comprehensions known to us at the time of writing. }, topics = {Type Systems} } @TECHREPORT{JonesDuponcheel93, AUTHOR = {M.P. Jones and L. Duponcheel}, TITLE = {{Composing monads}}, INSTITUTION = {Yale University}, ADDRESS = {New Haven, CT, USA}, TYPE = {YALEU/DCS/RR}, NUMBER = {1004}, YEAR = 1993, abstractURL = {http://www.cse.ogi.edu/~mpj/pubs/composing.html}, sourceURL = {ftp://nebula.cs.yale.edu/pub/yale-fp/reports/RR-1004.ps.Z}, TOPICS = {FP - Monads} } @techreport{JonesHudak93, author ={Jones, Mark and Hudak, Paul}, title ={{Implicit and Explicit Parallel Programming in Haskell}}, number ={YALEU/DCS/RR-982}, institution ={Department of Computer Science, Yale University}, month ={Aug}, year = 1993, scope ={parallel}, sourceURL ={ftp://ftp.cs.nott.ac.uk/nott-fp/reports/yale/RR-982.dvi.gz}, abstractURL = {http://www.cse.ogi.edu/~mpj/pubs/par.html}, documentSize={115.4 kbytes}, orig_keywords ={monads, imperative functional programming, concurrency}, topics = {FP - Nonsequential Execution,Haskell} } @phdthesis{Jones94a, author = {Mark P. Jones}, title = {{Qualified Types: Theory and Practice}}, school = {Distinguished Dissertations in Computer Science. Cambridge University Press}, year = 1994, abstractURL = {http://www.cse.ogi.edu/~mpj/pubs/thesis.html}, topics = {Type Systems} } @inproceedings{Jones94b, author = {Mark P. Jones}, title = {{Dictionary-free Overloading by Partial Evaluation}}, booktitle = {{ACM SIGPLAN Workshop on Partial Evaluation and Semantics-Based Program Manipulation}}, year = 1994, sourceURL = {ftp://ftp.cs.nott.ac.uk/nott-fp/papers/pepm94.dvi.gz}, abstractURL = {http://www.cse.ogi.edu/~mpj/pubs/pepm94.html}, month = jun, topics = {Type Systems} } @article{Jones95a, author = {Mark P. Jones}, title = {{A system of constructor classes: overloading and implicit higher-order polymorphism}}, journal = JFP, year = 1995, volume = {5}, number = {1}, pages = {1--35}, month = jan, topics = {Type Systems} } @inproceedings{Jones95b, author = {Mark P. Jones}, title = {{Simplifying and Improving Qualified Types}}, booktitle = {{FPCA'95: Conference on Functional Programming Languages and Computer Architecture, La Jolla, CA}}, year = 1995, sourceURL = {ftp://nebula.cs.yale.edu/pub/yale-fp/reports/RR-1040.ps.Z}, abstracURL = {http://www.cse.ogi.edu/~mpj/pubs/improve.html}, month = jun, topics = {Type Systems} } @inproceedings{Jones95c, author ="Jones, Mark P.", title ={{From Hindley-Milner Types to First-Class Structures}}, address ="La Jolla, California", publisher ="Yale University Research Report YALEU/DCS/RR-1075", booktitle ={{Proceedings of the Haskell Workshop}}, month ="June", year = 1995, scope ="imptype", abstractURL ={http://www.cse.ogi.edu/~mpj/pubs/haskwork95.html}, sourceURL ="ftp://ftp.cs.nott.ac.uk/nott-fp/papers/haskwork95.dvi.gz", orig_keywords ="extensions of Hindley-Milner type system to support higher-order polymorphism and first-class structures", topics = {Type Systems,Modules} } @inproceedings{Jones96, author ="Jones, Mark P.", title ={{Using Parameterized Signatures to Express Modular Structure}}, address ="St. Petersburg Beach, Florida", booktitle ={{Proceedings of the Twenty Third Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages}}, month ="January 21-24", year = 1996, abstractURL ={http://www.cse.ogi.edu/~mpj/pubs/paramsig.html}, sourceURL ="ftp://ftp.cs.nott.ac.uk/nott-fp/papers/paramsig.dvi.gz", topics = {Type Systems,Modules} } @inproceedings{Jones97a, author = {Mark P. Jones}, title = {{First-class Polymorphism with Type Inference}}, booktitle = {{Proceedings of the Twenty Fourth Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages}}, address = {Paris, France}, year = 1997, abstractURL = {http://www.cse.ogi.edu/~mpj/pubs/fcp.html}, sourceURL = {ftp://ftp.cs.nott.ac.uk/nott-fp/papers/popl97-fcp.dvi.gz}, editor = {}, pages = {}, month = {January 15-17}, topics = {Type Systems} } @misc{Jones97b, author = {Mark P. Jones}, title = {{A prototype implementation of extensible records for Hugs}}, howpublished = {Part of the documentation for Hugs, which is available at \url{http://www.haskell.org/hugs/}}, month = mar, year = 1997, sourceURL = {http://haskell.org/hugs/docs/TREX}, topics = {FP - Implementation,Records} } @misc{Jones98a, author = {Mark P. Jones}, title = {{A technical summary of the new features in Hugs 1.3c}}, howpublished = {Part of the documentation for Hugs 1.3c}, month = mar, year = 1997, topics = {FP - Implementation} } @misc{JonesPeterson99, author = {Mark P. Jones and John C. Peterson}, title = {{Hugs 98 -- A functional programming system based on Haskell 98}}, howpublished = {Available via \url{http://www.haskell.org/hugs/}}, month = may, year = 1999, sourceURL = {http://www.cse.ogi.edu/~mpj/Hugs98/hugs.pdf}, topics = {Haskell} } %% K @InProceedings{Kaes:esop:1988, author = {Stefan Kaes}, title = {{Parametric overloading in polymorphic programming languages}}, editor = {H. Ganzinger}, booktitle = {{Proceedings of the European Symposium on Programming}}, publisher = {Springer Verlag}, series = {Lecture Notes in Computer Science}, volume = {300}, year = {1988}, pages = {131--144}, abstract = {The introduction of unrestricted overloading in languages with type systems based on implicit parametric polymorphism generally destroys the principal type property: namely that the type of every expression can uniformly be represented by a single type expression over some set of type variables. As a consequence, type inference in the presence of unrestricted overloading can become a NP-complete problem. In ths paper we define the concept of parametric overloading as a restricted form of overloading which is easily combined with parametric polymorphism. Parametric overloading preserves the principal type property, thereby allowing the design of efficient type inference algorithms. We present sound type deduction systems, both for predefiend and programmer defined overloading. Finally we state that parametric overloading can be resolved either statically, at compile time, or dynamically, during program execution.}, topics = {Type Systems} } @inproceedings{Kahrs94, author = {Stefan Kahrs}, title = {{First-class polymorphism for ML}}, editor = {Donald Sannella}, sourceURL = {http://www.dcs.ed.ac.uk/%7Esmk/SML/modules.ps.Z}, volume = {788}, series = LNCS, pages = {333--347}, booktitle = {Programming Languages and Systems -- European Symposium on Programming 1994}, year = 1993, publisher = {Springer-Verlag}, month = apr, topics = {Type Systems,Modules} } @incollection{KaminReddy94, author = {Samuel N. Kamin and Uday S. Reddy}, title = {{Two Semantic Models of Object-Oriented Languages}}, booktitle = {{Theoretical Aspects of Object-Oriented Programming}}, publisher = {MIT Press}, year = 1994, editor = {Carl A. Gunter and John C. Mitchell}, chapter = {13}, pages = {463-495}, topics = {Object-Orientation} } @misc{Kamin97, author = {Samuel Kamin}, title = {{Building program generators the easy way (extended abstract)}}, howpublished = {\url{http://www-sal.cs.uiuc.edu/~kamin/pubs/ml-meta-extabs.ps}}, year = 1997, sourceurl = {http://www-sal.cs.uiuc.edu/~kamin/pubs/ml-meta-extabs.ps}, topics = {FP - Programming,Reflection/Meta-Programming} } @InProceedings{Kamin98, author = {Samuel Kamin}, title = {{Language implementation as a functional tool-building exercise}}, booktitle = {{(submitted for publication)}}, year = 1998, sourceurl = {http://www-sal.cs.uiuc.edu/~kamin/pubs/pldi98.ps}, topics = {FP - Programming,Reflection/Meta-Programming} } @inproceedings{KaplanWileden96, author = {Alan Kaplan and Jack C. Wileden}, title = {{Toward Painless Polylingual Persistence}}, booktitle = {{Seventh International Workshop on Persistent Object Systems, Cape May, NJ}}, year = 1996, note = {Also as CMPSCI Technical Report 96-83, University of Massachusetts}, sourceURL = {ftp://ftp.cs.umass.edu/pub/techrept/techreport/1996/UM-CS-1996-083.ps}, month = jun, topics = {Persistence} } @inproceedings{Karczmarczuk99, author = {Jerzy Karczmarczuk}, title = {{Geometric Modelling in Functional Style}}, booktitle = {{3rd Latin-American Conference on Functional Programming}}, year = 1999, sourceURL = {http://www.di.ufpe.br/~clapf99/paper_06.zip}, month = Mar, topics = {FP - Graphics/Visual} } @inproceedings{KatoOhori92, author = {Kauhiko Kato and Atsushi Ohori}, title = {{An approach to multilanguage persistent type system}}, booktitle = {{Proc. Hawaii International Conference on System Science}}, year = 1992, sourceURL = {http://www.kurims.kyoto-u.ac.jp/~ohori/kato92hicss.dvi}, pages = {810-819}, topics = {Persistence,Type Systems} } @misc{Kay1995, author = {Alan Kay}, title = {{Powerful Ideas Need Love Too!}}, howpublished = {\url{http://www.research.apple.com/people/features/congress_speech.html}}, note = {written remarks to Joint Hearing on Educational Technology in the 21st Century, Science Committee and the Economic and Educational Opportunities Committee, US House of Representatives, Oct. 12, 1995, Washington D.C.}, month = oct, year = 1995, sourceURL = {http://www.research.apple.com/people/features/congress_speech.html}, topics = {} } @book{Keene89, key = {Keene}, author = {Sonya E. Keene}, title = {Object-Oriented Programming in Common Lisp}, publisher = {Addison Wesley}, address = {Reading, Mass.}, year = {1989}, annote = {Guide to the CLOS object-oriented extension. }, topics = {Lisp/Scheme,Object-Orientation} } @techreport{Kelso94, author = {Joel Kelso}, title = {{A Visual Representation for Functional Programs}}, institution = {}, year = 1994, sourceURL = {ftp://babbage.cs.murdoch.edu.au/pub/papers/reports/cs9501.ps}, type = {}, number = {cs9501}, address = {}, month = dec, topics = {FP - Graphics/Visual} } @Book{KernighanRitchie88, author = {Brian W. Kernighan and Dennis M. Ritchie}, title = {The {C} Programming Language}, publisher = {Pren{\-}tice-Hall}, address = {Englewood Cliffs, NJ 07632, USA}, edition = {Second}, pages = {xii + 272}, year = {1988}, ISBN = {0-13-110362-8}, topics = {Miscellaneous Languages} } @article{KfouryTiurynUrzyczyn93, author = {A. J. Kfoury and J. Tiuryn and P. Urzyczyn}, title = {{Type reconstruction in the presence of polymorphic recursion}}, journal = {ACM Transactions on Programming Languages and Systems}, year = 1993, sourceURL = {http://www.acm.org/pubs/articles/journals/toplas/1993-15-2/p290-kfoury/p290-kfoury.pdf}, volume = {15}, number = {2}, pages = {290-311}, month = Apr, topics = {Type Systems} } @book{KiczalesRivieresBobrow91, author = {Gregor Kiczales and Jim des Rivi{\`{e}}res and and Daniel G. Bobrow}, title = {{The Art of the Metaobject Protocol}}, publisher = {MIT Press}, year = 1991, abstractURL = {http://www.parc.xerox.com/spl/groups/eca/pubs/abstracts/Kiczales:AMOP.html}, topics = {Language Design/Semantics,Lisp/Scheme,Object-Orientation} } @inproceedings{Kiczales92, author = {Gregor Kiczales}, title = {{Towards a New Model of Abstraction in the Engineering of Software}}, booktitle = {{IMSA'92 Workshop on Reflection and Meta-level Architectures}}, year = 1992, abstractURL = {http://www.parc.xerox.com/spl/groups/eca/pubs/abstracts/Kiczales:IMSA92.html}, topics = {Programming/Software Engineering} } @techreport{AOP97, author = {Gregor Kiczales and John Lamping and Anurag Mendhekar and Chris Maeda and Cristina Lopes and Jean-Marc Loingtier and John Irwin}, title = {{Aspect-Oriented Programming}}, institution = {Xerox Palo Alto Research Center}, year = 1997, sourceURL = {http://www.parc.xerox.com/spl/projects/aop/tr-aop.htm}, number = {SPL97-008 P9710042}, month = Feb, topics = {Programming/Software Engineering} } @article{KieburtzLaunchbury95, author = {Richard Kieburtz and John Launchbury}, title = {{Encapsulated Effects}}, year = 1995, sourceURL = {ftp://cse.ogi.edu/pub/pacsoft/papers/encapsulate.ps}, abstract = {Side effects in imperative programming languages are ubiquitous, which makes it difficult to reason about programs in other than operational terms. Functional programming languages, on the other hand, claim the advantage that equational logics are sufficient for reasoning, but at the that often useful effects, such as interactive input, exceptions, and explicit updates of state cannot be accommodated. This paper shows a way to bring these two worlds of programming style closer together, by neatly encapsulating the effects-producing semantics features that one wishes to use to design useful and efficient programs. }, topics = {FP - State} } @article{KieburtzLaunchbury96, author = {Richard B. Kieburtz and John Launchbury }, title = {{Towards Algebras of Encapsulated Effects}}, journal = {(submitted to POPL'97)}, year = 1996, sourceURL = {ftp://cse.ogi.edu/pub/pacsoft/papers/effects.ps}, abstract = {Side effects in imperative programming languages are ubiquitous, which makes it difficult to reason about programs in other than operational terms. Functional programming languages, on the other hand, claim the advantage that equational logics are sufficient for reasoning, but at the price that useful effects, such as interactive input, exceptions, and explicit updates of state cannot be accommodated. This paper shows a way to bring these two worlds of programming style closer together, by characterizing the effects-producing semantics features that one wishes to use to design useful and efficient programs as algebras, whose axioms are given by sets of first-order equations whose variables range over program terms. }, topics = {FP - State} } @INPROCEEDINGS{KingWadler92, AUTHOR = {D.J. King and P.Wadler}, TITLE = {{Combining Monads}}, BOOKTITLE = {{Proc. of the Fifth Annual Glasgow Workshop on Functional Programming}}, PUBLISHER = {Springer Verlag}, YEAR = 1992, abstractURL = {http://cm.bell-labs.com/cm/cs/who/wadler/topics/monads.html#combining-monads}, sourceURL = {http://cm.bell-labs.com/cm/cs/who/wadler/papers/monadscomb/monadscomb.ps.gz}, TOPICS = {FP - Monads} } @techreport{KirbyConnorMorrisonStemple96, author = {G.N.C. Kirby and R.C.H. Connor and R. Morrison and D. Stemple}, title = {{Using Reflection to Support Type-Safe Evolution in Persistent Systems}}, institution = {University of St. Andrews}, year = 1996, sourceURL = {http://www-fide.dcs.st-and.ac.uk/Publications/PostScript/reflection.evolution.ps.gz}, abstractURL = {http://www-fide.dcs.st-and.ac.uk/Publications/1996.html#reflection.evolution}, number = {CS/96/10}, topics = {Reflection/Meta-Programming,Persistence} } @techreport{KirbyMorrison97, author = {G.N.C. Kirby and R. Morrison}, title = {{Orthogonal Persistence as an Implementation Platform for Software Development Environments}}, institution = {University of St. Andrews}, year = 1997, sourceURL = {http://www-fide.dcs.st-and.ac.uk/Publications/PostScript/sde.ps.gz}, abstractURL = {http://www-fide.dcs.st-and.ac.uk/Publications/1997.html#sde}, number = {CS/97/6}, topics = {Persistence,Programming Environments} } @INCOLLECTION{KRS95, AUTHOR = {W. E. Kluge and C. Rathsack and S.-B. Scholz}, EMAIL = {}, TITLE = {{U}sing $\pi$-{\sc red} as a {T}eaching {T}ool for {F}unctional {P}rogramming and {P}rogram {E}xecution}, EDITOR = {P. H. Hartel and M. J. Plasmeijer}, BOOKTITLE = {{FPLE'95}}, SERIES = {LNCS}, VOLUME = {1022}, PUBLISHER = {Springer}, YEAR = 1995, PAGES = {231-250}, NOTE = {}, FTP = {}, KEYWORDS = {}, CONTENTS = {}, sourceURL = {http://www.informatik.uni-kiel.de/~sbs/mypapers/teaching-tool-fple95.ps.gz}, TOPICS = {Kiel Reduction Language} } @InCollection{Klop90, author = {Jan Willem Klop}, year = 1990, title = {{Term Rewriting Systems}}, booktitle = {Handbook of Logic in Computer Science}, editor = {S. Abramsky and D. M. Gabbay and T. S. E. Maibaum}, publisher = {Oxford University Press}, address = {Oxford}, topics = {Rewrite Systems} } @InProceedings{KlugeSchmittgen86, author = {W. Kluge and C. Schmittgen}, title = {Reduction Languages and Reduction Systems}, pages = {153--184}, ISBN = {3-540-18203-9}, editor = {M. Vanneschi and P. Treleaven}, booktitle = {Proceedings of the Advanced Course on Future Parallel Computers}, address = {Pisa, Italy}, month = jun, year = 1986, series = {LNCS}, volume = {272}, publisher = {Springer}, topics = {Kiel Reduction Language} } @BOOK{Kluge92, AUTHOR = {W.E. Kluge}, TITLE = {{The Organization of Reduction, Data Flow and Control Flow Systems}}, PUBLISHER = {MIT Press}, YEAR = 1992, NOTE = {ISBN 0-262-61081-7}, TOPICS = {FP - General} } @techreport{Kluge94, author = {Werner E. Kluge}, title = {{A User's Guide for the Reduction System {$\pi$-RED$^+$}}}, url = {http://www.informatik.uni-kiel.de/inf/Kluge/KiR/manna.ps.gz}, institution = ifi, number = 9419, month = Dec, year = 1994, topics = {Kiel Reduction Language} } @article{Knight89, author = {Kevin Knight}, title = {{Unification: A Multidisciplinary Survey}}, journal = {ACM Computing Surveys}, year = 1989, volume = {21}, number = {1}, pages = {93-124}, month = mar, topics = {LP - Unification} } @article{Knuth74, author = {Donald E. Knuth}, title = {{Structured Programming with go to Statements}}, journal = {ACM Computing Surveys}, year = 1974, note = {(reprinted in \cite{Wasserman80})}, volume = {6}, number = {4}, pages = {261-301}, month = dec, topics = {Programming/Software Engineering} } @inproceedings{Knuth90, author = {Donald E. Knuth}, title = {{The genesis of attribute grammars}}, booktitle = {{WAGA conference proceedings, Paris 1990}}, note = {Lecture Notes in Computer Science 461}, year = 1990, localURL = {gag.dvi}, sourceURL = {http://www-cs-staff.Stanford.EDU/~knuth/papers/gag.tex.gz}, pages = {1--12}, publisher = {Springer-Verlag}, topics = {History,Attribute Grammars} } %% L @inproceedings{Lamping90, author = {John Lamping}, title = {{An Algorithm for Optimal Lambda Calculus Reduction}}, booktitle = {17th } # POPL, year = 1990, pages = {16-30}, topics = {FP - Implementation} } @article{Landin63, author = {P. J. Landin}, title = {{The mechanical evaluation of expressions}}, journal = {Computer Journal}, year = 1963, volume = {6}, number = {4}, pages = {308-320}, topics = {FP - Lambda Calculi,FP - Implementation} } @article{Landin65, author = {P. J. Landin}, title = {{A Correspondence Between ALGOL 60 and Church's Lambda-Notation: Parts I/II}}, journal = CACM, year = 1965, volume = {8}, number = {2/3}, pages = {89-101:158-165}, month = {February/March}, topics = {FP - General} } @article{Landin66, author = {P. J. Landin}, title = {{The Next 700 Programming Languages}}, journal = CACM, year = 1966, volume = {9}, number = {3}, pages = {157-166}, month = {March}, topics = {Language Design/Semantics} } @inproceedings{LauferOdersky93, author = {Konstantin L{\"a}ufer and Martin Odersky}, title = {{Self-Interpretation and Reflection in a Statically Typed Language}}, booktitle = {{OOPSLA'93 Workshop on Reflection and Metalevel Architectures}}, year = 1993, sourceURL = {http://www.math.luc.edu/~laufer/ftp/papers/reflection.ps.gz}, abstractURL = {http://www.math.luc.edu/~laufer/ftp/papers/abstracts/reflection.txt}, organization = {ACM}, month = sep, topics = {Reflection/Meta-Programming} } @InProceedings{Laufer94, author = "L{\"a}ufer, K.", title = {{Combining Type Classes and Existential Types}}, booktitle = {{Proc. Latin American Informatics Conf. (PANEL)}}, year = 1994, organization = "ITESM-CEM", address = "Mexico", month = sep, sourceURL = "ftp://ftp.math.luc.edu/pub/laufer/papers/tycl-and-extypes.ps.gz", email = "laufer@math.luc.edu", abstract = { This paper demonstrates that the novel combination of type classes and existential types adds significant expressive power to a language, requiring only a minor syntactic change. We explore this combination in the context of higher-order functional languages with static typing, parametric polymorphism, algebraic data types, and Hindley-Milner type inference. Since we have examined the underlying type-theoretic issues already, this paper focuses on the practical aspects of our extension. We first examine limitations of existing functional and object-oriented languages. We then give examples to demonstrate how our first-class abstract types with user-defined interfaces address those limitations. Finally, we give an informal description of the translation from our language to a target language without type classes. Our extension equally applies to other languages with similar type systems and is independent of strictness considerations. It has been implemented in the Chalmers Haskell B. system, and all examples from this paper have been developed using this system. }, topics = {Data Abstraction,Type Systems} } @inproceedings{Launchbury93, author ="Launchbury, John", title ={{Lazy Imperative Programming}}, booktitle ={{ACM SigPlan Workshop on State in Prog. Langs.}}, month ="June", year = 1993, scope ="monads", sourceURL ="ftp://ftp.dcs.gla.ac.uk/pub/glasgow-fp/papers/lazy-imperative-programming.ps.Z", documentSize="62.0 kbytes", abstract = { In this paper we argue for the importance of lazy state, that is, sequences of imperative (destructive) actions in which the actions are delayed until their results are required. This enables state-based computations to take advantage of the control power of lazy evaluation. We provide some examples of its use, and describe a possible implementation within Glasgow Haskell. }, topics = {FP - State} } @inproceedings{LaunchburyPeytonJones1994, author ="Launchbury, J. and Peyton Jones, S.", title ={{Lazy Functional State Threads}}, address ="Orlando", publisher ="ACM Press", booktitle ={{Programming Languages Design and Implementation}}, year = 1994, scope ="impmonads", abstractURL ="http://www.cse.ogi.edu/~jl/biblio.html", sourceURL ="http://www.cse.ogi.edu/~jl/Papers/stateThreads.ps", abstract = { Some algorithms make critical internal use of updatable state, even though their external specification is purely functional. Based on earlier work on monads, we present a way of securely encapsulating stateful computations that manipulate multiple, named, mutable objects, in the context of a non-strict, purely-functional language. The security of the encapsulation is assured by the type system, using parametricity. Intriguingly, this parametricity requires the provision of a (single) constant with rank-2 polymorphic type. }, topics = {FP - State} } @inproceedings{LaunchburyPeytonJones1995, author ="Launchbury, J. and Peyton Jones, S.", title ={{State in Haskell}}, year = 1995, scope ="impmonads", sourceURL ="ftp://ftp.dcs.glasgow.ac.uk/pub/glasgow-fp/drafts/state-lasc.ps.gz", annote = {This is a 50-page elaboration of "Lazy functional state threads"}, topics = {FP - State} } @inproceedings{LaunchburySabry97, author = {John Launchbury and Amr Sabry}, title = {{Monadic State: Axiomatization and Type Safety}}, booktitle = {{Proceedings of the 1997 ACM SIGPLAN International Conference on Functional Programming}}, year = 1997, sourceURL = {http://www.cse.ogi.edu:80/~jl/Papers/typeST.ps}, pages = {227-238}, month = jun, topics = {FP - State} } @techreport{Leavens93, author = {Gary T. Leavens}, title = {{Introduction to the Literature On Programming Language Design}}, institution = {Department of Computer Science, Iowa State University}, year = 1993, sourceURL = {ftp://ftp.cs.iastate.edu/pub/techreports/TR93-01/TR.ps.Z}, number = {TR 93-01b}, month = {January}, note = {revised January 1994 and February 1996}, abstract = {This is an introduction to the literature on programming language design and related topics. It is intended to cite the most important work, and to provide a place for students to start a literature search.}, topics = {Language Design/Semantics} } @inproceedings{LeoneLee96a, author ={Leone, Mark and Lee, Peter}, title ={{A Declarative Approach to Run-Time Code Generation}}, booktitle ={{Workshop on Compiler Support for System Software (WCSSS)}}, month =feb, year =1996, scope ={implemen}, sourceURL ={http://www.cs.cmu.edu/afs/cs.cmu.edu/user/mleone/papers/declarative-rtcg.ps}, orig_keywords ={run-time code generation, dynamic optimization, specialization, partial evaluation}, topics = {Partial Evaluation} } @inproceedings{LeeLeone96b, author= {Peter Lee and Mark Leone}, title= {{Optimizing ML with Run-Time Code Generation}}, sourceURL = {http://www.cs.cmu.edu/afs/cs.cmu.edu/user/mleone/papers/ml-rtcg.ps}, abstractURL = {http://www.cs.cmu.edu/afs/cs.cmu.edu/user/mleone/papers/ml-rtcg.abstract}, booktitle = {{ACM SIGPLAN '96 Conference on Programming Language Design and Implementation}}, month = May, year= 1996, topics = {Standard ML,FP - Implementation}, } @inproceedings{Leroy94, author = {Xavier Leroy}, title = {Manifest types, modules, and separate compilation}, booktitle = {{Proc. 21st symp. Principles of Programming Languages}}, sourceURL = {ftp://ftp.inria.fr/INRIA/Projects/cristal/Xavier.Leroy/manifest-types.dvi.gz}, year = 1994, publisher = {ACM press}, pages = {109--122}, abstract = { This paper presents a variant of the SML module system that introduces a strict distinction between abstract types and manifest types (types whose definitions are part of the module specification), while retaining most of the expressive power of the SML module system. The resulting module system provides much better support for separate compilation. }, topics = {Type Systems,Modules} } @inproceedings{Leroy95, author = {Xavier Leroy}, title = {{Applicative functors and fully transparent higher-order modules}}, booktitle = {{Proc. 22nd symp. Principles of Programming Languages}}, sourceURL = {ftp://ftp.inria.fr/INRIA/Projects/cristal/Xavier.Leroy/applicative-functors.dvi.gz}, year = 1995, pages = {142--153}, publisher = {ACM Press}, abstract = { We present a variant of the Standard ML module system where parameterized abstract types (i.e. functors returning generative types) map provably equal arguments to compatible abstract types, instead of generating distinct types at each application as in Standard ML. This extension solves the full transparency problem (how to give syntactic signatures for higher-order functors that express exactly their propagation of type equations), and also provides better support for non-closed code fragments. }, topics = {Type Systems,Modules} } @inproceedings{LiangHudakJones95, author = {Sheng Liang and Paul Hudak and Mark P. Jones}, title = {Monad Transformers and Modular Interpreters}, booktitle = {22rd } # POPL # {, San Francisco, CA}, publisher = {ACM}, month = jan, year = 1995, sourceURL = {http://www.cse.ogi.edu/~mpj/pubs/modinterp.html}, topics = {FP - Programming} } @misc{Lillibridge96, author = {Mark Lillibridge}, title = {{Translucent Sums: A Foundation for Higher-Order Module Systems}}, howpublished = {\url{http://www.research.digital.com/SRC/personal/Mark_Lillibridge/Papers/Thesis/summary.PS}}, note = {PhD thesis summary}, month = dec, year = 1996, sourceURL = {http://www.research.digital.com/SRC/personal/Mark_Lillibridge/Papers/Thesis/summary.PS}, topics = {Type Systems,Modules} } @phdthesis{Lillibridge97, author = {Mark Lillibridge}, title = {{Translucent Sums: A Foundation for Higher-Order Module Systems}}, school = {School of Computer Science, Carnegie Mellon University}, note = {CMU-CS-97-122}, year = 1997, sourceURL = {http://www.research.digital.com/SRC/personal/Mark_Lillibridge/Papers/Thesis/thesis.PS}, month = may, topics = {Type Systems,Modules} } @inproceedings{Lindstrom85, author = {Gary Lindstrom}, title = {{Functional Programming And The Logical Variable}}, booktitle = {12th } # POPL # { New Orleans}, year = 1985, pages = {266-280}, month = jan, topics = {FP - General} } @inproceedings{Lindstrom86, author = {Gary Lindstrom}, title = {{Implementing Logical Variables On A Graph Reduction Architecture}}, booktitle = {{Graph Reduction, Santa Fe, New Mexico, LNCS 279}}, year = 1986, pages = {382-400}, publisher = {Springer-Verlag}, month = {September/October}, topics = {FP - Implementation} } @inproceedings{Liskov87, author = {Barbara Liskov}, title = {{Data Abstraction and Hierarchy}}, booktitle = {{Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA), Addendum to the Proceedings}}, journal = {SIGPLAN Notices}, volume = {23}, number = {5}, year = 1987, pages = {17-34}, month = oct, topics = {Data Abstraction,Object-Orientation} } @techreport{Liskov92, author = {Barbara Liskov}, title = {{A History of CLU}}, institution = {Laboratory for Computer Science, MIT}, year = 1992, sourceURL = {ftp://ftp.lcs.mit.edu:/pub/pclu/clu-history.PS}, month = apr, topics = {Data Abstraction} } @article{LiskovZilles74, author = {Barbara Liskov and Stephen Zilles}, title = {{Programming With Abstract Data Types}}, journal = {SIGPLAN Notices}, year = 1974, volume = {9}, number = {4}, pages = {50-59}, topics = {Data Abstraction} } @inproceedings{Lloyd94, author = {J. W. Lloyd}, title = {{Practical Advantages of Declarative Programming}}, booktitle = {{Joint Conference on Declarative Programming}}, year = 1994, sourceURL = {}, topics = {FP - General} } @misc{Locke97, author = {Nikki Locke}, title = {{Available C++ libraries FAQ}}, howpublished = {submitted to \verb|comp.lang.c++|, also online at \url{http://www.trmphrst.demon.co.uk/cpplibs1.html}}, year = 1997, sourceURL = {http://www.trmphrst.demon.co.uk/cpplibs1.html}, topics = {Libraries and Tools} } @article{Low78, author = {James R. Low}, title = {{Automatic Data Structure Selection: An Example and Overview}}, journal = CACM, year = 1978, volume = {21}, number = {5}, pages = {376-385}, month = may, topics = {Data Abstraction} } %% M @incollection{MacQueen85, author = {D. MacQueen}, title = {{Modules for Standard ML}}, booktitle = {{Standard ML \cite{HarperMacQueenMilner86}}}, year = 1985, topics = {Modules,Standard ML} } @inproceedings{MacQueen86, author = {David MacQueen}, title = {{Using Dependent Types to Express Modular Structure}}, booktitle = {13th } # POPL, year = 1986, pages = {277-286}, topics = {Modules,Type Systems} } @inproceedings{MacQueenTofte94, author = {David B. MacQueen and Mads Tofte}, title = {{A Semantics for Higher-order Functors}}, booktitle = {{5th European Symposium on Programming, LNCS 788}}, sourceURL = {ftp://research.att.com/dist/ml/papers/94-esop-macqueen.ps}, note = {pp. 409-423}, month = apr, year = 1994, topics = {Modules} } @inproceedings{MacQueen92, AUTHOR = {David B. MacQueen}, TITLE = {{Reflections on Standard ML}}, editor = {}, booktitle = {{Functional Programming, Concurrency, Simulation and Automated Reasoning}}, PUBLISHER = SPRINGER, SERIES = {LNCS}, VOLUME = {693}, sourceURL = {ftp://ftp.research.att.com/dist/ml/papers/92-lncs-macqueen.ps}, YEAR = 1992, topics = {Standard ML} } @incollection{Maes88, author = {Pattie Maes}, title = {{Issues in Computational Reflection}}, booktitle = {{Meta-Level Architectures and Reflection}}, publisher = {Elsevier Science Publishers B.V. (North-Holland)}, year = 1988, editor = {P. Maes and D. Nardi}, pages = {21-35}, topics = {Reflection/Meta-Programming} } @inproceedings{Martin-Loef82, author = {Per Martin-L{\"o}f}, title = {{Constructive Mathematics and Computer Programming}}, booktitle = {{6th International Congress of Logic, Methodology and Philosophy of Science, Hannover}}, year = 1979, editor = {L.J. Cohen and J. Los and H. Pfeiffer and K.-P. Podewski}, pages = {153-??}, publisher = {North-Holland}, topics = {Type Systems} } @inproceedings{McPheeDeMoor96, author = {R. McPhee and O. de Moor}, title = {{Compositional Logic Programming}}, booktitle = {{Proceedings of the JICSLP'96 post-conference workshop: Multi-paradigm logic programming,}}, year = 1996, sourceURL = {http://www.comlab.ox.ac.uk/oucl/users/oege.demoor/papers/compositional.ps.gz}, editor = {M. Chakravarty and Y. Guo and T. Ida}, pages = {115--127}, publisher = {Report 96-28, Technische Universitaet Berlin}, topics = {LP - General} } @misc{MLJ98, author = {Nick Benton and Andrew Kennedy and George Russell}, title = {{The Persimmon MLJ Compiler}}, howpublished = {\url{http://research.persimmon.co.uk/mlj/}}, month = Oct, year = 1998, sourceURL = {http://research.persimmon.co.uk/mlj/index.html}, topics = {FP - Implementation,Standard ML,Java} } @techreport{MMS94, key= {MMS94}, author= {Matthes, F. and M\"u{\ss}ig, S. and Schmidt, J.W}, title= {{Persistent Polymorphic Programming in Tycoon: An Introduction}}, type= fiderep, number= {FIDE/94/106}, institution= fidecoord, year= 1994, month= aug, documentdirectory= {1994/MMS94}, abstract= { This text provides an introduction to Tycoon (Typed Communicating Objects in Open Environments), an open persistent polymorphic programming environment. The Tycoon language TL is based on expressive and orthogonal naming, typing and binding concepts as they are required, for example, in advanced data-intensive applications. The characteristic language mechanisms of TL are first-class functions and modules, parametric and subtype polymorphism extended to a fully higher-order type system. Tycoon programs are statically typed but may include explicit dynamic type variables which can be inspected at run-time.}, topics = {Persistence} } @inproceedings{MatthesSchmidt93, author= {Matthes, F. and Schmidt, J.W.}, title= {{System Construction in the Tycoon Environment: Architectures, Interfaces and Gateways}}, booktitle= {{Proc. of Euro-Arch'93 Congress}}, publisher= SPRINGER, month= oct, year= 1993, documentdirectory= {1993/euro-arch/MaSc93a}, abstract= {This paper outlines the basic concepts and the system architecture of the Tycoon environment. Tycoon is designed for the construction of persistent object systems intended to be available on multiple software and hardware platforms.\\ Tycoon's contribution to system portability and scalability is achieved by strictly separating concerns of data modelling, data manipulation, and data storage into three distinct system layers each of which is based on state-of-the-art system technology (polymorphic programming languages, portable code representations, persistent object stores). Much emphasis is being placed on supporting interoperability between Tycoon applications and off-the-shelf tools and systems, such as database systems, user interface managers, and optimizing code generators.\\ We illustrate how higher-order functions, polymorphic typing and transparent persistence management reduce the amount of repetitive and type-unsafe programming in typical persistent object systems.}, topics = {Persistence} } @techreport{MatthesSchmidt92, author = {F. Matthes and J.W. Schmidt}, title = {{Definition of the Tycoon Language - A Preliminary Report}}, institution = {Fachbereich Informatik, Universit{\"a}t Hamburg, Germany}, year = 1992, note = {(Revised 17-aug-1995)}, sourceURL = {http://www.sts.tu-harburg.de/papers/1992/MaSc92/}, type = {Informatik Fachbericht}, number = {FBI-HH-B-160/92}, month = Oct, topics = {Persistence} } @techreport{MathiskeMatthesMuessig93, author = {B. Mathiske F. Matthes and S. M{\"u}{\ss}ig}, title = {{The Tycoon System and Library Manual}}, institution = {Fachbereich Informatik, Universit{\"a}t Hamburg, Germany}, year = 1993, note = {(Revised 19-jan-1996)}, sourceURL = {http://www.sts.tu-harburg.de/papers/1993/MMM93/}, type = {DBIS Tycoon Report}, number = {212-93}, month = Dec, topics = {Persistence} } @article{Matthews85, author = {David C. J. Matthews}, title = {{Poly and Standard ML}}, journal = {SIGPLAN Notices}, year = 1985, volume = {20}, number = {9}, pages = {52-76}, month = sep, topics = {Type Systems,Data Abstraction,Modules,Poly} } @incollection{Matthews88, author = {D. C. J. Matthews}, title = {{An Overview of the Poly Programming Language}}, booktitle = {{Data Types and Persistence}}, publisher = Springer, year = 1988, topics = {Persistence,Poly} } @techreport{Matthews95, author = {D. C. J. Matthews}, title = {{Papers on Poly/ML}}, institution = EDCS, year = 1995, sourceURL = {http://www.dcs.ed.ac.uk/lfcsreps/EXPORT/95/ECS-LFCS-95-335/index.html}, type = {LFCS Technical Report}, number = {ECS-LFCS-95-335}, month = Oct, topics = {Persistence,Poly} } @article{McCarthy60, author ={McCarthy, John}, title ={{Recursive Functions of Symbolic Expressions and their Computation by Machine (Part I)}}, journal ={Communications of the ACM}, number ={4}, volume ={3}, pages ={184--195}, year =1960, sourceURL ={http://www-formal.stanford.edu/jmc/recursive.dvi}, annote ={original paper on LISP}, topics = {Lisp/Scheme} } @Book{McCarthy66, key = {McCarthy, {\em et al.}}, author = {John McCarthy and Paul W. Abrahams and Daniel J. Edwards and Timothy P. Hart and Michael I. Levin}, title = {{LISP 1.5 Programmer's Manual}}, note = {second edition}, year = 1966, address = {Cambridge, Mass.}, publisher = {The MIT Press}, topics = {Lisp/Scheme} } @incollection{McCarthy81, author ={McCarthy, John}, title ={{History of Lisp}}, publisher ={Academic Press}, editor ={Wexelblat, Richard}, booktitle ={History of Programming Languages}, year ={1981}, sourceURL ={http://www-formal.stanford.edu/jmc/history/lisp.dvi}, topics = {Lisp/Scheme,History} } @article{McNallyDavie91, author ="McNally, David J. and Davie, Antony J. T.", title ={{Two Models for Integrating Persistence and Lazy Functional Languages}}, journal ={{ACM SIGPLAN Notices}}, volume = 26, number = 5, month = May, year = 1991, topics = {Persistence} } @phdthesis{McNally93, author = {McNally, D}, title = {{Models for Persistence in Lazy Functional Programming Systems}}, school = {Dept. of Computer Science, University of St Andrews}, year = 1993, note = {Technical Report CS/93/9}, abstractURL = {http://www.dcs.st-and.ac.uk/~staple/publications.html#lazy.persistence}, sourceURL = {ftp://ftp.dcs.st-and.ac.uk/pub/staple/lazy-persistence.ps.Z}, topics = {Persistence} } @inproceedings{Meijer92, author = {Erik Meijer}, title = {{More advice on proving a compiler correct: Improve a correct compiler}}, booktitle = {{PHOENIX Seminar and workshop on declarative programming}}, note = {Volume 91 of Workshops in Computer Science}, year = 1992, sourceURL = {http://www.cs.ruu.nl/~erik/advice.ps}, publisher = SPRINGER, abstract = {As an alternative to the classical approach to the compiler correctness problem where a given compiler is proved correct from scratch, we propose a method for deriving correct compilers from a denotational semantics via a series of refinements. Each such optimization step corresponds to an efficiency improvement in the corresponding compiler. Our technique combines the standard initial algebra semantics approach with aspects of Action Semantics. Instead of expressing semantic functions as homomorphisms from the initial algebra (syntax) to some semantic domain, they are factored through an algebra of actions. Compilers can then be obtained by viewing semantic functions as translations from the source language to the initial action algebra. We illustrate our method by deriving several compilers for a language of arithmetic expressions. Though simple, this example shows all the steps necessary to deal with more realistic languages. }, topics = {FP - Implementation} } @inproceedings{MeijerJeuring95, author = {Meijer, E. and Jeuring, J.}, title = {Merging monads and folds for functional programming}, booktitle = {Advanced Functional Programming}, abstractURL = {http://www.cs.chalmers.se/~johanj/mmfabstract.html}, sourceURL = {http://www.cs.chalmers.se/~johanj/mmf.ps}, editor = {J. Jeuring and E. Meijer}, series = {Lecture {N}otes in {C}omputer {S}cience 925}, pages = {228--266}, publisher = {Springer-Verlag}, year = {1995}, topics = {FP - Programming} } @misc{MeijerDijkClaessenYzendoorn97, author = {Erik Meijer and Joost van Dijk and Koen Claessen and Arjan van Yzendoorn}, title = {{The Design and Implementation of Mondrian}}, howpublished = {\url{http://tibet.cse.ogi.edu/Personal/Papers/mondrian.ps}}, year = 1997, sourceURL = {http://tibet.cse.ogi.edu/Personal/Papers/mondrian.ps}, topics = {Misc. Functional Languages} } @inproceedings{MeyerReinhold86, author = {Albert R. Meyer and Mark B. Reinhold}, title = {{'Type` Is Not A Type: Preliminary Report}}, booktitle = {13th } # POPL, year = 1986, pages = {287-295}, topics = {Type Systems} } @inproceedings{Menzies91, author = {Menzies, T.J.}, title = {{IS-A Object PART-OF Knowledge Representation (part 2)}}, booktitle = {{Tools 4: Proc. of the third International Technology of Object-Oriented Languages \& Systems conference 1991, Sydney, Australia}}, year = 1991, sourceURL = {http://www.sd.monash.edu.au/~timm/pub/docs/tools91.ps.Z}, topics = {Knowledge Representation} } @article{Milner78, author = {Robin Milner}, title = {{A Theory of Type Polymorphism in Programming}}, journal = {Journal of Computer and System Sciences}, year = 1978, volume = {17}, pages = {348-375}, topics = {Standard ML,Type Systems} } @book{MilnerTofteHarper90, author = {Robin Milner and Mads Tofte and Robert Harper}, title = {{The Definition of Standard ML}}, publisher = {MIT}, year = 1990, note = {ISBN 0-262-63132-6}, topics = {Standard ML} } @book{MilnerTofte91, author = {Robin Milner and Mads Tofte}, title = {{Commentary on Standard ML}}, publisher = {MIT}, year = 1991, note = {ISBN 0-262-63137-7}, topics = {Standard ML} } @article{Milner93, author = {Robin Milner}, title = {{Elements of Interaction}}, journal = CACM, year = 1993, volume = {36}, number = {1}, pages = {78-89}, month = jan, topics = {Concurrency} } @TechReport{Minsky74, author = {M. L. Minsky}, title = {{A Framework for Representing Knowledge}}, institution = {Massachusetts Institute of Technology, A.I. Lab.}, address = {Cambridge, Massachusetts}, type = {Report}, number = {A. I. MEMO 306}, note = {McGraw-Hill, P. H. Winston (Ed.), ``Psychology of Computer Vision'', 1975}, month = jun, year = {1974}, topics = {Knowledge Representation} } @inproceedings{MitchellPlotkin85, author = {John C. Mitchell and Gordon D. Plotkin}, title = {{Abstract types have existential type}}, booktitle = POPL, year = 1985, topics = {Data Abstraction,Type Systems} } @incollection{Mitchell90, key = {Mitchell}, author = {John C. Mitchell}, title = {Type systems for programming languages}, booktitle = {Handbook of Theoretical Computer Science}, chapter = {8}, pages = {365--458}, volume = {B: Formal Models and Semantics}, editor = {J. van Leeuwen}, publisher = {North-Holland}, address = {New York, N.Y.}, year = 1990, topics = {Type Systems} } @article{Mitchell93, author ={Mitchell, J.C}, Title ={On abstraction and the expressive power of programming languages}, Year ={1993}, sourceURL = {ftp://theory.stanford.edu/pub/jcm/papers/expressiveness.dvi.Z}, journal={Science of Computer Programming}, Volume ={212}, pages ={141--163}, Note ={Preliminary version appeared {\it Proc. Theor. Aspects of Computer Software,} Springer LNCS 526, September 1991, pages 750--770.}, abstract = { This paper presents a tentative theory of programming language expressiveness based on reductions (language translations) that preserve observational equivalence. These are called "abstraction-preserving" reductions because of a connection with a def- inition of "abstraction" or "information-hiding" mechanism. If there is an abstraction- preserving reduction from one language to another, then (essentially) every function on natural numbers that is definable in the first is also definable in the second. Moreover, an abstraction-preserving reduction must map every abstraction construct in the source language to a construct that hides analogous distinctions in the target language. Sev- eral examples and counter-examples to abstraction-preserving reductions are given. It is not known whether any language is universal with respect to abstraction-preserving reduction.}, topics = {Language Design/Semantics} } @inproceedings{MitchellMeldalMadhav91, author = {J. C. Mitchell and S. Meldal and N. Madhav}, title = {{An extension of Standard ML modules with subtyping and inheritance}}, booktitle = {18th } # POPL, year = 1991, sourceURL = {ftp://theory.stanford.edu/pub/jcm/papers/modules-subtypes-popl91.dvi.Z}, pages = {270-278}, month = jan, topics = {Type Systems,Modules} } @article{Moggi91, author = {Moggi, E.}, title = {{A category-theoretic account of program modules}}, journal = {{Mathematical Structures in Computer Science}}, volume = 1, year = 1991, sourceURL = {http://theory.doc.ic.ac.uk:80/tfm/papers/MoggiE/mscs91.dvi.gz}, abstract = { The type-theoretic explanation of modules proposed to date (for programming languages like ML) is unsatisfactory, because it does not capture that evaluation of type-expressions is \i{independent} from evaluation of program-expressions. We propose a new explanation based on ``programming languages as indexed categories'' and illustrates how ML can be extended to support higher order modules, by developing a category-theoretic semantics for a calculus of modules with dependent types. The paper outlines also a methodology, which may lead to a modular approach in the study of programming languages.}, topics = {Modules} } @inproceedings{Moggi89a, author ={Moggi, E}, title ={{Computational lambda-calculus and monads}}, booktitle ={Proceedings of the Logic in Computer Science Conference}, year = 1989, scope ={monads}, sourceURL ={http://theory.doc.ic.ac.uk/papers/Moggi/lics89.dvi.gz}, documentSize={20.8 kbytes}, topics = {FP - Monads,Logic/Category Theory} } @TechReport{Moggi89b, Author= {Moggi, E.}, Title= {An Abstract View of Programming Languages}, Institution= {Edinburgh Univ., Dept. of Comp. Sci.}, Number= {ECS-LFCS-90-113}, Note= {Lecture Notes for course CS 359, Stanford Univ.}, sourceURL= {http://www.disi.unige.it/person/MoggiE/ftp/abs-view.dvi.gz}, Year= 1989, month= Jun, topics= {FP - Monads,Logic/Category Theory} } @misc{Moor99, author = {Oege de Moor}, title = {First-class Attribute Grammars}, month = Feb, year = 1999, topics = {FP - Programming,Attribute Grammars,Syntax} } @article{Morris73, author = {James H. {Morris Jr.}}, title = {{Protection in Programming Languages}}, journal = CACM, year = 1973, volume = {16}, number = {1}, pages = {15-21}, month = jan, topics = {Programming/Software Engineering} } @phdthesis{Morrison79, author = {Ronald Morrison}, title = {{ON THE DEVELOPMENT OF ALGOL}}, school = {Department of Computational Science, University of St Andrews}, year = 1979, sourceURL = {ftp://ftp-ppg.dcs.st-and.ac.uk/pub/persistence.papers/thesis.rm.ps.gz}, abstractURL = {http://www-fide.dcs.st-and.ac.uk/Publications/1979.html#thesis.rm}, month = Dec, topics = {Language Design/Semantics} } @article{MorrisonConnorCuttsKirbyStemple93, author = {Morrison, R. and Connor, R.C.H. and Cutts, Q.I. and Kirby, G.N.C. and Stemple, D. }, title = {{Mechanisms for Controlling Evolution in Persistent Object Systems}}, journal = {Journal of Microprocessors and Microprogramming }, year = 1993, abstractURL = {http://www-fide.dcs.st-and.ac.uk/Publications/1993.html#evolution.mechanisms}, sourceURL = {http://www-fide.dcs.st-and.ac.uk/Publications/PostScript/evolution.mechanisms.ps.gz}, volume = {17}, number = {3}, pages = {173-181}, topics = {Persistence,Type Systems} } @inproceedings{MorrisonConnorKirbyMunro96, author = {R. Morrison and R.C.H. Connor and G.N.C. Kirby and D.S. Munro}, title = {{Can Java Persist?}}, booktitle = {{1st International Workshop on Persistence for Java, Glasgow (1996)}}, year = 1996, sourceURL = {http://www-fide.dcs.st-and.ac.uk/Publications/PostScript/java.persistence.ps.gz}, abstractURL = {http://www-fide.dcs.st-and.ac.uk/Publications/1996.html#java.persistence}, pages = {34-41}, topics = {Persistence,Java} } %% N @misc{Napier88H, key = {Napier88}, title = {{Napier88}}, howpublished = {\url{http://www-fide.dcs.st-and.ac.uk/Info/Napier88.html}}, year = 1988, sourceURL = {http://www-fide.dcs.st-and.ac.uk/Info/Napier88.html}, topics = {Persistence} } @techreport{Napier88, author = {Morrison, R. and Brown, A.L. and Connor, R.C.H. and Cutts, Q.I. and Dearle, A. and Kirby, G.N.C. and Munro, D.S.}, title = {{Napier88 Reference Manual (Release 2.2.1)}}, institution = {University of St Andrews}, year = 1996, sourceURL = {http://www-fide.dcs.st-and.ac.uk/Publications/PostScript/napier.ref.man.221.ps.gz}, topics = {Persistence} } @incollection{Naur63, author = {Peter Naur (ed.) and J.W. Backus and F.L. Bauer and J. Green and C. Katz and J. McCarthy and A.J. Perlis and H. Rutishauser and K. Samelson and B. Vaquois and J.H. Wegstein and A. van Wijngaarded and M. Woodger}, title = {{Revised Report on the Algorithmic Language Algol 60}}, booktitle = {{Algol-like Languages}}, publisher = {Birkh{\"a}user}, year = 1997, editor = {Peter O'Hearn and Robert D. Tennent}, chapter = {1}, pages = {19-49}, note = {First appeared in Communications of the ACM 6(1):1-17, The Computer Journal 5:349-67, and Numerische Mathematik 4:420-53, 1963}, topics = {History} } @misc{NECResearch95, author = {Suresh Jagannathan and James Philbin and Richard Kelsey and Henry Cejtin and Mark Reinhold and Jan Edler and Andrew Wright}, title = {{A Research Prospectus for Advanced Software Systems}}, month = apr, year = 1995, abstractURL = {http://www.neci.nj.nec.com/tr/neci-abstract-95-1.html}, sourceURL = {http://www.neci.nj.nec.com/tr/neci-tr-95-1.ps}, note = {(NEC Software Systems Research)}, topics = {Groups and Projects} } @inproceedings{NettlesWing91, author = {Scott M. Nettles and Jeannette M. Wing}, title = {{Persistence + Undoability = Transactions}}, booktitle = {{Hawaii International Conference on Systems Science 25}}, year = 1992, note = {(also CMU-CS-91-173, August 1991)}, sourceURL = {http://www.cs.cmu.edu/afs/cs.cmu.edu/project/venari/papers/hicss92/hicss92.ps}, month = Jan, topics = {Persistence} } @book{vonNeumann66, author = {John von Neumann}, note = {edited and completed by Arthur W. Burks}, title = {{Theory of self-reproducing automata}}, publisher = {University of Illinois Press}, year = 1966, topics = {History} } @misc{nhc13, author = {Niklas Rojemo}, title = {{nhc13 from York}}, howpublished = {\url{http://www.cs.york.ac.uk/fp/nhc13/}}, year = 1998, sourceURL = {http://www.cs.york.ac.uk/fp/nhc13/}, topics = {Haskell,FP - Implementation} } @inproceedings{NicklischPeytonJones96, author = {J. Nicklisch and S.L. Peyton Jones}, title = {{An Exploration of Modular Programs}}, booktitle = {{Proceedings of the 1996 Glasgow Workshop on Functional Programming}}, year = 1996, sourceURL = {http://ftp.dcs.glasgow.ac.uk/fp/workshops/fpw96/Nicklisch.ps.gz}, editor = {Phil Trinder}, month = oct, topics = {Modules} } @misc{NievergeltXX, author = {Jurg Nievergelt}, title = {{Issues in the Design of Human-Computer Interfaces}}, howpublished = {???}, month = {}, year = 0, topics = {Human Computer Interfaces} } @inproceedings{NobleRunciman95, AUTHOR = {Rob Noble and Colin Runciman}, TITLE = {{Gadgets: Lazy Functional Components for Graphical User Interfaces}}, abstractURL = {http://dcpu1.cs.york.ac.uk:6666/~rjn/plilpabs.html}, sourceURL = {http://dcpu1.cs.york.ac.uk:6666/~rjn/plilppap.ps.gz}, editor = {M. Hermenegildo and S. D. Swierstra}, booktitle = PLILP, PUBLISHER = SPRINGER, SERIES = {LNCS}, VOLUME = {982}, YEAR = 1995, topics = {FP - Input/Output,FP - Graphics/Visual} } @phdthesis{Noble95, author = {Rob Noble}, title = {{Lazy Functional Components for Graphical User Interfaces}}, school = {Department of Computer Science, University of York}, year = 1995, abstractURL = {http://Dcpu1.cs.york.ac.uk:6666/rjn/thesis.html}, sourceURL = {http://Dcpu1.cs.york.ac.uk:6666/rjn/thesis.ps.gz}, month = Nov, topics = {FP - Input/Output,FP - Graphics/Visual} } @inproceedings{NygaardDahl78, author = {Kristen Nygaard and Ole-Johan Dahl}, title = {{SIMULA Session}}, booktitle = {{History of Programming Languages}}, year = 1981, editor = {Richard L. Wexelblat}, pages = {439-493}, publisher = {Academic Press}, topics = {History,Object-Orientation,Simula} } %% O @article{OBrien97, author = {Patrick O'Brien}, title = {{Making Java Objects Persistent}}, journal = {Java Report}, year = 1997, sourceURL = {http://www.sigs.com/publications/docs/java/9701/obrien.html}, month = jan, topics = {Persistence,Java} } @techreport{Odersky91, author = {Martin Odersky}, title = {{Objects and Subtyping in a Functional Perspective}}, institution = {IBM}, year = 1991, sourceURL = {http://wwwipd.ira.uka.de/~odersky/papers/objfun.dvi.gz}, number = {RC 16423}, month = mar, topics = {Type Systems} } @inproceedings{OderskyLaeufer96, author = {Martin Odersky and Konstantin L{\"a}ufer}, title = {{Putting Type Annotations to Work}}, booktitle = {23rd } # POPL, year = 1996, abstractURL = {http://www.math.luc.edu/~laufer/ftp/papers/abstracts/type-annotations.txt}, sourceURL = {http://www.math.luc.edu/~laufer/ftp/papers/type-annotations.ps.gz}, month = Jan, topics = {Type Systems} } @misc{OderskyWadler98, author = {Martin Odersky and Philip Wadler}, title = {{Leftover Curry and reheated Pizza: How functional programming nourishes software reuse}}, howpublished = {Keynote address, IEEE Fifth International Conference on Software Reuse}, month = jun, year = 1998, sourceURL = {http://cm.bell-labs.com/cm/cs/who/wadler/papers/reuse/reuse.ps.gz}, topics = {FP - General,Java} } @article{ODonnell85, author = {John T. O'Donnell}, title = {{Dialogues: A Basis for Constructing Programming Environments}}, journal = {SIGPLAN Notices}, year = 1985, note = {Proceedings of the 1985 Symposium on Language Issues in Programming Environments}, volume = {20}, number = {7}, pages = {19-27}, topics = {FP - Input/Output} } @article{OHearn1996, title = {Note on {Algol} and conservatively extending functional programming}, author = {Peter W. O'Hearn}, pages = {171--180}, journal = JFP, month = jan, year = 1996, volume = 6, number = 1, abstract = {A simple Idealized Algol is considered, based on Reynolds's "essence of Algol". It is shown that observational equivalence in this language conservatively extends observational equivalence in its assignment-free functional sublanguage. }, topics = {Language Design/Semantics} } @misc{OMG98, author = {Object Management Group}, title = {{OMG Home Page}}, howpublished = {\url{http://www.omg.org/}}, year = 1999, sourceURL = {http://www.omg.org/}, topics = {Component-Based Programming} } @article{Ophel95, author = {John Ophel}, title = {{A Polymorphic Language With First-Class Modules}}, journal = {{Australian Computer Science Communications}}, sourceURL = {http://www.cs.latrobe.edu.au/~johno/bib/first-class-modules.ps}, volume = 17, number = 1, pages = {422-430}, month = feb, year = 1995, topics = {Modules,Records,Type Systems} } @inproceedings{OrlareyFoberLetzBilton94, author = {Orlarey Y. and Fober D. and Letz S. and Bilton M.}, title = {{Lambda Calculus and Music Calculi}}, booktitle = {{Proceedings of the ICMC, ICMA, San Francisco}}, year = 1994, sourceURL = {ftp://ftp.grame.fr/pub/Documents/LambdaCalc.ps.Z}, pages = {243-250}, topics = {FP - Lambda Calculi} } %% P @techreport{ParcTabMCS93, author = {Bill N. Schilit and Norman Adams and Rich Gold and Michael Tso and Roy Want }, title = {{The PARCTAB Mobile Computing System}}, institution = {Xerox Palo Alto Research Center, Computer Science Lab}, year = 1993, sourceURL = {http://www.ubiq.com/parctab/wwos-93-schilit.ps.Z}, abstractURL = {http://www.ubiq.com/parctab/csl9320-abstract.html}, type = {Technical Report}, number = {CSL-93-20}, month = oct, topics = {Ubiquitous Computing} } @techreport{ParcTabUCE95, author = {Roy Want and Bill N. Schilit and Norman I. Adams and Rich Gold and Karin Petersen and David Goldberg and John R. Ellis and Mark Weise}, title = {{The PARCTAB Ubiquitous Computing Experiment}}, institution = {Xerox Palo Alto Research Center, Computer Science Lab}, year = 1995, sourceURL = {http://www.ubiq.com/parctab/csl9501.ps.Z}, abstractURL = {http://www.ubiq.com/parctab/csl9501-abstract.html}, type = {Technical Report}, number = {CSL-95-1}, month = mar, topics = {Ubiquitous Computing} } @article{Parnas72a, author = {D. L. Parnas}, title = {{A Technique for Software Module Specification with Examples}}, journal = CACM, year = 1972, volume = {15}, number = {5}, pages = {330--336}, month = May, topics = {Modules} } @article{Parnas72b, author = {D. L. Parnas}, title = {{On the Criteria To Be Used in Decomposing Systems into Modules}}, journal = CACM, year = 1972, sourceURL = {http://www.acm.org/classics/may96/}, volume = {15}, number = {12}, pages = {1053--1058}, month = Dec, topics = {Modules} } @inproceedings{Parnas84, author = {D. L. Parnas and P. C. Clements and D. M. Weiss}, title = {{The Modular Structure of Complex Systems}}, booktitle = {{7th International Conference on Software Engineering}}, year = 1984, publisher = {Computer Society Press}, pages = {408--417}, organization = {IEEE}, topics = {Modules} } @phdthesis{Perry91, author = {Nigel Perry}, title = {{The Implementation of Practical Functional Programming Languages}}, school = {Imperial College, London}, sourceURL = {ftp://smis-asterix.massey.ac.nz/pub/ResearchPapers/thesis/}, year = 1991, topics = {FP - Input/Output,Hope} } @inproceedings{Perry92, author = {Perry, Nigel}, title = {{Towards a Concurrent Object/Process Oriented Functional Language (Short Version)}}, booktitle = {{15th Australian Computer Science Conference}}, volume = {14(1)}, series = {Australian Computer Science Communications}, sourceURL = {gopher://smis-asterix.massey.ac.nz:70/44ftp%3apub%3aResearchPapers%3aACSC15_C-OO-FP.ps.Z}, month = {January}, year = 1992, abstract = {In this paper we first define the programming methodology continuation passing style (CSP), which originates from tail functions and upon which result continuations are based, and then give an introduction to functional language I/O and inter-language working. We then show how the result continuation mechanism can be extended to support coroutine programming, and then use this to define remote function call (RPC) and object style systems. Next we show how concurrent functional programming can be supported using the result continuation mechanism, this work stems from our sketch of a functional operating system described in Perry. In conclusion we describe how this paper lays the groundwork for the development of concurrent functional and object/process-oriented programming paradigms and support non-determinism. A semantics for result continuations, functional coroutines, remote function calls, and concurrent functional programming is being developed. The semantics are defined using a version of the $\pi$-calculus and enable concurrent functional programs to be reasoned about. This reasoning can either be at two levels; using standard functional notation ($\lambda$-calculus) reasoning for the individual processes and $\pi$-calculus style reasoning for the concurrent communication, treating each process as a ``black box''; or at a single level by implementing the $\lambda$-calculus in the $\pi$-calculus.}, orig_keywords = {Continuation Passing, Non-Determinism, Concurrent Objects, Parallel Semantics}, topics = {FP - Nonsequential Execution,FP - Input/Output} } %%% Petri Nets, CPN (start) @phdthesis{Petri62, author = {Carl Adam Petri}, title = {{Kommunikation mit Automaten.}}, school = {Bonn: Institut f{\"u}r Instrumentelle Mathematik, Schriften des IIM Nr. 2}, note = {Second Edition:, New York: Griffiss Air Force Base, Technical Report RADC-TR-65--377, Vol.1, 1966, Pages: Suppl. 1, English translation}, year = 1962, topics = {Petri Nets} } @misc{PetriNetsHome, author = {}, title = {{World of Petri Nets: Homepage of the International Petri Net Community}}, howpublished = {\url{http://www.daimi.aau.dk/PetriNets/}}, year = 1999, sourceURL = {http://www.daimi.aau.dk/PetriNets/}, topics = {Petri Nets} } @misc{CPN, author = {K.~Jensen}, title = {{Recommended Books and Papers on Coloured Petri Nets}}, howpublished = {\url{http://www.daimi.aau.dk/~kjensen/papers_books/rec_papers_books.html}}, note = {Includes links to online articles covering introductions, theory, and practice}, year = 1999, sourceURL = {http://www.daimi.aau.dk/~kjensen/papers_books/rec_papers_books.html}, topics = {Petri Nets} } @misc{DesignCPN, author = {CPN group at the University of Aarhus in Denmark}, title = {{Design/CPN -- Computer Tool for Coloured Petri Nets}}, howpublished = {\url{http://www.daimi.aau.dk/designCPN/}}, year = 1999, sourceURL = {http://www.daimi.aau.dk/designCPN/}, topics = {Petri Nets} } @misc{Renew, author = {{Theoretical Foundations Group, Department for Informatics, University of Hamburg}}, title = {{Renew -- The Reference Net Workshop}}, howpublished = {\url{http://www.renew.de/}}, year = 1999, sourceURL = {http://www.renew.de/}, topics = {Petri Nets} } @book{Reisig85, author = {W.~Reisig}, title = {{Petri Nets, An Introduction}}, publisher = SPRINGER, year = 1985, series = {EATCS, Monographs on Theoretical Computer Science}, topics = {Petri Nets} } @book{Jensen97, author = {K.~Jensen}, title = {Coloured Petri Nets. Basic Concepts, Analysis Methods and Practical Use}, note = {Three Volumes}, publisher = SPRINGER, year = 1997, topics = {Petri Nets} } @incollection{Jensen94, author = {K.~Jensen}, title ={{An Introduction to the Theoretical Aspects of Coloured Petri Nets}}, booktitle ={A Decade of Concurrency}, editor ={J.W.~de Bakker and W.-P.~de Roever and G.~Rozenberg}, publisher =SPRINGER # {, LNCS vol.~803}, year =1994, pages ={230-272}, topics = {Petri Nets} } %%% Petri Nets, CPN (end) @BOOK{PeytonJones87, AUTHOR = {S.L.~Peyton Jones}, TITLE = {{The Implementation of Functional Programming Languages}}, SERIES = {Series in Computer Science}, PUBLISHER = {Prentice-Hall International}, YEAR = 1987, NOTE = {ISBN 0-13-453325-9}, TOPICS = {FP - General} } @article{PeytonJone92a, author ={Peyton Jones, Simon L.}, title ={{Implementing lazy functional languages on stock hardware: the Spineless Tagless G-machine}}, journal ={Journal of Functional Programming}, number ={2}, volume ={2}, pages ={127--202}, month ={July}, year = 1992, scope ={implemen}, sourceURL ={ftp://ftp.dcs.gla.ac.uk/pub/glasgow-fp/papers/spineless-tagless-gmachine.ps.Z}, documentSize={211.2 kbytes}, abstract = {The Spineless Tagless G-Machine is an abstract machine designed to support higher-order functional languages. This presentation of the machine falls into three parts. Firstly, we give a general discussion of the design issues involved in implementing non-strict functional languages. Next, we present the {\em STG language\/}, an austere but recognizably-functional language, which as well as a {\em denotational\/} meaning has a well-defined {\em operational\/} semantics. The STG language is the ``abstract machine code'' for the Spineless Tagless G-machine. Lastly, we discuss the mapping of the STG language onto stock hardware. The success of an abstract machine model depends largely on how efficient this mapping can be made, though this topic is often relegated to a short section. Instead, we give a detailed discussion of the design issues and the choices we have made. Our principal target is the C language, treating the C compiler as a portable assembler.}, orig_keywords = {Parallel Graph Reduction, Abstract Machine}, topics = {Haskell,FP - Implementation} } @inproceedings{PeytonJonesWadler93, author={Peyton Jones, S.~L. and Wadler, P.}, title={{Imperative Functional Programming}}, booktitle={{Proc.~20th Symp.~on Principles of Programming Languages}}, sourceURL = {http://cm.bell-labs.com/cm/cs/who/wadler/papers/imperative/imperative.ps.gz}, organization={ACM}, month=Jan, year=1993, topics = {FP - Input/Output,FP - State,FP - Monads} } @inproceedings{PeytonJones96a, author = {S.L.~Peyton Jones}, title = {{Compiling Haskell by program transformation: a report from the trenches}}, booktitle = {{European Symposium on Programming (ESOP'96)}}, month = apr, year = 1996, abstract = {Many compilers do some of their work by means of correctness-preserving, and hopefully performance-improving, program transformations. The Glasgow Haskell Compiler (GHC) takes this idea of ``compilation by transformation'' as its war-cry, trying to express as much as possible of the compilation process in the form of program transformations. This paper reports on our practical experience of the transformational approach to compilation, in the context of a substantial compiler. }, topics = {FP - General} } @incollection{PeytonJonesGordonFinne96, author="Simon L.~{Peyton Jones} and Andrew D.~Gordon and Sigbj{\"o}rn Finne", title={{Concurrent Haskell}}, booktitle={{Conference Record of the Twenty Third }} # POPL, abstractURL = {ftp://ftp.cl.cam.ac.uk/papers/adg/index.html#popl96-ch}, sourceURL = {ftp://ftp.cl.cam.ac.uk/papers/adg/popl96-ch.ps.gz}, publisher={ACM}, year=1996, pages="295--308", topics = {FP - Nonsequential Execution,FP - Input/Output} } @inproceedings{PeytonJones96b, author = {Simon Peyton Jones}, title = {{Bulk types with class}}, booktitle = {{Proceedings of the 1996 Glasgow Workshop on Functional Programming}}, year = 1996, sourceURL = {http://ftp.dcs.glasgow.ac.uk/fp/workshops/fpw96/PeytonJones.ps.gz}, editor = {Phil Trinder}, month = oct, topics = {Type Systems} } @misc{PeytonJonesJones96c, author = {Simon Peyton Jones and Mark Jones}, title = {{First-class modules for component-based programming}}, howpublished = {\url{http://research.microsoft.com/Users/simonpj/Papers/first-class-modules.ps.gz}}, annote = {project proposal - project started in late 1997}, month = apr, year = 1996, sourceURL = {http://research.microsoft.com/Users/simonpj/Papers/first-class-modules.ps.gz}, topics = {Modules} } @inproceedings{PeytonJonesJonesMeijer97, author = {Simon Peyton Jones and Mark Jones and Erik Meijer}, title = {{Type Classes: an exploration of the design space}}, booktitle = {{ACM SIGPLAN Haskell Workshop}}, year = 1997, sourceURL = {http://research.microsoft.com/Users/simonpj/Papers/multi.ps.gz}, month = Jun, topics = {Type Systems} } @misc{PeytonJones97, author = {Simon Peyton Jones}, title = {{Declarative systems architecture: a quantitative approach (AQUA) - Final Report}}, howpublished = {\url{http://research.microsoft.com/Users/simonpj/Papers/aqua-final.ps.gz}}, month = jan, year = 1997, sourceURL = {http://research.microsoft.com/Users/simonpj/Papers/aqua-final.ps.gz}, topics = {Groups and Projects} } @inproceedings{PeytonJonesMeijerLeijen98, author = {Simon Peyton Jones and Erik Meijer and Daan Leijen}, title = {{Scripting COM components in Haskell}}, booktitle = {{Fifth International Conference on Software Reuse, Victoria, British Columbia}}, year = 1998, sourceURL = {http://research.microsoft.com/Users/simonpj/Papers/com.ps.gz}, month = Jun, topics = {FP - Programming} } @techreport{Peterson94, author = {John Peterson}, title = {{Dynamic Typing in Haskell}}, institution = {Dept.~of Computer Science, Yale University}, year = 1994, type = {Research Report}, number = {YALEU/DCS/RR-1022}, month = may, topics = {Type Systems}, keywords = {Dynamic Types} } @techreport{PetersonHammond96, key = {Haskell 1.3}, author = {John Peterson and Kevin Hammond}, title = {{Report on the Programming Language Haskell A Non-strict, Purely Functional Language (Version 1.3)}}, institution = {Haskell comittee}, month = may, year = 1996, topics = {Haskell} } @techreport{PetersonHammond97, key = {Haskell 1.4}, editor = {John Peterson and Kevin Hammond}, title = {{Haskell 1.4, A Non-strict, Purely Functional Language}}, institution = {Haskell comittee}, note = {Available at \url{http://haskell.org}}, month = apr, year = 1997, topics = {Haskell} } @techreport{haskell-libs97, key = {Haskell 1.4}, editor = {John Peterson and Kevin Hammond}, title = {{The Haskell Library Report, Version 1.4}}, institution = {Haskell comittee}, note = {Available at \url{http://haskell.org}}, month = apr, year = 1997, topics = {Haskell} } @inproceedings{Pfenning96, author = {Frank Pfenning}, title = {{The Practice of Logical Frameworks}}, booktitle = {{CAAP'96 - Colloquium on Trees in Algebra and Programming, Link{\"o}ping, Sweden}}, year = 1996, sourceURL = {http://www.cs.cmu.edu/~fp/papers/caap96.ps.gz}, editor = {H{\'{e}}l{\`{e}}ne Kirchner}, pages = {119-134}, publisher = {Springer-Verlag, LNCS 1059}, month = apr, topics = {Theorem Proving/Logical Frameworks} } @inproceedings{Pil96, author = {Marco Pil}, title = {{First Class File I/O}}, booktitle = {1996 } # IFL, year = 1996, editor = {Werner Kluge}, pages = {341-349}, sourceURL = {http://www.cs.kun.nl/~marcop/fileIO.ps.gz}, abstractURL = {http://www.cs.kun.nl/~marcop/fileIOAbstract.html}, topics = {Persistence,Type Systems,FP - Input/Output} } @misc{PilProject97, author = {Rinus Plasmeijer and Marco Pil}, title = {{Project 803-09: The specification and implementation of a distributed operating system in a lazy, purely functional language}}, howpublished = {A project status page at the Computing Science Institute Nijmegen \url{http://www.cs.kun.nl/csi/projects/803-09.html}}, month = {}, year = 1997, sourceURL = {http://www.cs.kun.nl/csi/projects/803-09.html}, topics = {Type Systems,FP - Input/Output} } @misc{PJava, key = {PJava}, title = {{The PJava Project, Orthogonal Persistence for Java}}, howpublished = {\url{http://www.dcs.gla.ac.uk/pjava/}}, year = 1996, sourceURL = {http://www.dcs.gla.ac.uk/pjava/}, topics = {Persistence,Java} } @misc{PJW1, key = {PJW1}, title = {{First International Workshop on Persistence and Java(tm) (PJW1)}}, howpublished = {\url{http://www.sunlabs.com/research/forest/UK.Ac.Gla.Dcs.PJW1.pj1.html}}, note = {Drymen, Scotland}, month = Sep, year = 1996, sourceURL = {http://www.sunlabs.com/research/forest/UK.Ac.Gla.Dcs.PJW1.pj1.html}, topics = {Persistence,Java} } @misc{PJW2, key = {PJW2}, title = {{Second International Workshop on Persistence and Java(tm) (PJW2)}}, howpublished = {\url{http://www.sunlabs.com/research/forest/COM.Sun.Labs.Forest.PJava.PJW2.pjw2.html}}, note = {Half Moon Bay, San Francisco Bay Area, California}, month = Aug, year = 1997, sourceURL = {http://www.sunlabs.com/research/forest/COM.Sun.Labs.Forest.PJava.PJW2.pjw2.html}, topics = {Persistence,Java} } @techreport{PlasmeijervanEekelen96, author = {Rinus Plasmeijer and Marko van Eekelen}, title = {{The Concurrent Clean Language Report (version 1.1)}}, institution = {University of Nijmegen}, year = 1996, sourceURL = {ftp://ftp.cs.kun.nl/pub/Clean/Clean11/doc/refman11.pdf.gz}, month = {March}, topics = {Clean} } @techreport{PlasmeijervanEekelen97, author = {Rinus Plasmeijer and Marko van Eekelen}, title = {{The Concurrent Clean Language Report -- version 1.2 (draft)}}, institution = {HILT -- High Level Software Tools B.V.~and University of Nijmegen}, year = 1997, sourceURL = {ftp://ftp.cs.kun.nl/pub/Clean/Clean12/doc/refman12.pdf.gz}, month = {March}, topics = {Clean} } @article{Plotkin75, author = {G.~D.~Plotkin}, title = {{Call-by-name, call-by-value and the $\lambda$-calculus}}, journal = {Theoretical Computer Science}, year = 1975, volume = {1}, pages = {125-159}, topics = {FP - Lambda Calculi} } @book{Pollack72, author = {Bary W.~Pollack}, title = {{Compiler techniques}}, publisher = {Auerbach publishers}, year = 1972, series = {Auerbach Computer Science Series}, topics = {History} } %% Q %% R @phdthesis{Rathsack97, author = {Carsten Rathsack}, title = {{}}, note = {forthcoming}, school = ifi, year = 1997, topics = {Kiel Reduction Language} } @inproceedings{Reddy85, author = {Uday S.~Reddy}, title = {{Narrowing As The Operational Semantics Of Functional Languages}}, booktitle = {{IEEE Symposium on Logic Programming}}, year = 1985, pages = {138-151}, topics = {FP - General} } @incollection{Reddy86a, crossref = {DeGrootLindstrom86}, author = {Uday S.~Reddy}, title = {{On the Relationship between Logic and Functional Languages}}, year = 1986, pages = {3-36}, topics = {FP - General,LP - General} } @inproceedings{Reddy86b, author = {Uday S.~Reddy}, title = {{Functional Logic Languages: Part I}}, booktitle = {{Graph Reduction, Santa F{\'e}, New Mexico, USA (LNCS 279)}}, year = 1986, editor = {J.~H.~Fasel and R.~M.~Keller}, publisher = {Springer-Verlag}, topics = {FP - General,LP - General} } @techreport{Reekie94, author = {H.~John Reekie}, title = {{Visual Haskell: A first attempt}}, institution = {Key Centre for Advanced Computing Sciences, University of Technology, Sidney}, year = 1994, sourceURL = {http://ptolemy.eecs.berkeley.edu/~johnr/papers/postscript/visual-haskell.ps.gz}, abstractURL = {http://ptolemy.eecs.berkeley.edu/~johnr/papers/visual.html}, type = {Research Report}, number = {94.5}, address = {}, month = aug, topics = {Haskell,FP - Graphics/Visual} } @inproceedings{Remy94, author ="Didier R{\'e}my", title = {{Programming Objects with ML-ART: An extension to ML with Abstract and Record Types}}, address ="Sendai, Japan", publisher ="Springer-Verlag", editor ="Hagiya, Masami and Mitchell, John C.", pages ="321--346", booktitle ={{International Symposium on Theoretical Aspects of Computer Software}}, month ="April", year = 1994, scope ="defin", sourceURL = {ftp://ftp.inria.fr/INRIA/Projects/cristal/Didier.Remy/tacs94.dvi.Z}, documentSize="53.7 kbytes", topics ={Data Abstraction,Records} } @inproceedings{Remy92, author = {Didier R{\'e}my}, title = {{Typing Record Concatenation for Free}}, booktitle = {19th } # POPL, year = 1992, sourceURL = {ftp://ftp.inria.fr/INRIA/Projects/cristal/Didier.Remy/taoop2.ps.gz}, pages = {166-176}, note = {also in \cite{GunMit94}}, topics = {Records,Type Systems} } %% inline copy of Reinke.bib - START @mastersthesis{Reinke91, AUTHOR = "Claus Reinke", TITLE = {{Elemente einer kombinierten funktionalen/logischen Sprache (Ein Konzept f{\"u}r die Erweiterung einer Reduktionssprache)}}, note = {in German}, SCHOOL = {Institut f{\"u}r Informatik und praktische Mathe\-matik, Universit{\"a}t Kiel}, MONTH = May, YEAR = 1991, sourceURL = {http://www.cs.ukc.ac.uk/people/staff/cr3/publications/msc.html}, topics = {FP - General,LP - General} } @inproceedings{Reinke95a, AUTHOR = {Claus Reinke}, TITLE = {{Functions, Frames, and Interactions}}, EDITOR = {T.~Johnsson}, BOOKTITLE = {{Proceedings of the Workshop on the Implementation of Functional Languages, B{\aa}stad, Sweden, 1995}}, PUBLISHER = {Chalmers University}, month = Sep, YEAR = 1995, PAGES = {157--172}, sourceURL = {http://www.cs.ukc.ac.uk/people/staff/cr3/publications/ffi.html#FFI95a}, abstract = { This paper describes some proposals for improving the reduction language KiR with respect to data abstraction, modularization and input/output. Rather than adding specialized language elements for each purpose, an attempt is made to provide the desired functionality by way of only two extensions. These are frames (record-like data structures) and interactions (constructs describing communications with the program's runtime environment). The main topic is the unified treatment of language elements for programming-in-the-large within the framework of an untyped, purely functional language. Both modules and data abstraction are modeled as first class data structures. }, TOPICS = {FFI,FP - General,FP - Input/Output,Modules,Persistence} } @inproceedings{Reinke95b, AUTHOR = {Claus Reinke}, TITLE = {{F}unctions, {F}rames, and {I}nteractions (advocating first class modules)}, EDITOR = {Tiziana Margaria}, BOOKTITLE = {{Proceedings of the Colloquium `Grundlagen der Programmierung', Alt-Reichenau, Germany, 1995}}, PUBLISHER = {Passau University}, month = Oct, YEAR = 1995, PAGES = {15--21}, sourceURL = {http://www.cs.ukc.ac.uk/people/staff/cr3/publications/ffi.html#FFI95b}, abstract = {Combining modules as first class data structures with explicit input/output-operations for arbitrary expressions in a purely functional programming language brings the flexibility of integrated programming environments under control of the functional language. Compared to conventional module systems, the proposed solution provides enhanced functionality in a simpler framework, using the functional language as an unrestricted module language and the extended input/output-facilities to make modules persistent. }, TOPICS = {FFI,FP - General,FP - Input/Output,Modules,Persistence} } @phdthesis{Reinke97, author = {Claus Reinke}, title = {{Functions, Frames, and Interactions -- completing a $\lambda$-calculus-based purely functional language with respect to programming-in-the-large and interactions with runtime environments}}, school = {Faculty of Engineering, Christian-Albrechts-University of Kiel}, note = {Technical Report 9804, Institute of Computer Science, May 1998}, month = Aug, year = 1997, sourceURL = {http://www.cs.ukc.ac.uk/people/staff/cr3/publications/phd.html}, topics = {FFI,FP - Input/Output,Modules,FP - General,Language Design/Semantics} } @techreport{Reinke97b, author = {Claus Reinke}, title = {{On functional programming, language design, and persistence}}, institution = {Nottingham Department of Computer Science}, number = {NOTTCS-TR-98-2}, annote = {An early draft version was presented at the Workshop on the Implementation of Functional Languages, September 1997, St.~Andrews}, month = Jul, year = 1998, sourceURL = {http://www.cs.ukc.ac.uk/people/staff/cr3/publications/fpldp.html}, abstract = {Functional programming languages and their implementations are basically well-understood, and research is drifting towards topics that are not specific to functional languages. Several questions arise from this changed situation: Is there any reason to prefer functions as units of programming over other forms, such as predicates, relations, objects, processes, etc.? Will functional programming become just one of many alternatives in hybrid programming languages of the future, or are there any special properties that make functional programming particularly attractive? In the present paper, we argue that most of the virtues attributed to the functional style of programming and to functional languages are not at all specific to the use of functions as the basic units of programming. In particular, we propose to view the $\lambda$-calculus not as a calculus of functions, but as a calculus of abstractions, abstractions which can be used uniformly over different basic units of programming. Their support for a general scheme of abstraction is one of the major attractions of functional languages. Support for abstraction is also a major topic of the language design methods based on semantic principles, as collected by Tennent and Morrison in the late 1970s. We find that functional languages are, in many respects, designed according to these principles, and we show how the principles can also aid the design of extensions to functional languages, e.g., to support input/output or modular programming. This approach leads to a language design with `first-class modules' and support for persistence while keeping the overall language simple and general, much in the style of the functional core. }, topics = {Language Design/Semantics,FP - General,Persistence} } @inproceedings{Reinke98, author = {Claus Reinke}, title = {{Towards a Haskell/Java connection}}, booktitle = {{Implementation of Functional Languages (IFL~'98), London, UK}}, editor = {K.~Hammond and A.J.T.~Davie and C.~Clack}, series = {LNCS}, volume = {1595}, pages = {203--219}, publisher = {{Springer Verlag}}, month = {}, year = 1999, isbn = {ISBN 3-540-66229-4}, sourceURL = {http://www.cs.ukc.ac.uk/people/staff/cr3/publications/JNI.html}, abstract = { This paper reports on preliminary work on a connection between Haskell and Java, with the goal of making software components written in Java available to Haskell programmers. We discuss several approaches, but find the Java platform surprisingly closed against other languages. We decide to use an indirect approach, based on proposed native interfaces for Haskell and Java, and describe this in more detail. A side-by-side overview of Hugs and the Java Virtual Machine highlights some similarities of the implementation designs. Both systems also have similar problems and solutions with respect to foreign language interfaces. Finally, we relate the proposed connection between Haskell and Java to other recent work on component-based programming in Haskell. }, topics = {FP - Implementation,Java} } @inproceedings{KlugeHielscherUrbzatReinke98, author = {W.~Hielscher and L.~Urbszat and C.~Reinke and W.~Kluge}, title = {{On Modelling Train Traffic in a Model Train System}}, booktitle = {{Proceedings of the Workshop and Tutorial on Practical Use of Coloured Petri Nets and Design/CPN, Aarhus, Denmark}}, annote = {Available online at \url{http://www.daimi.aau.dk/CPnets/workshop98/}}, publisher = {Technical Report PB-532, Department of Computer Science, University of Aarhus}, month = Jun, year = 1998, sourceURL = {http://www.cs.ukc.ac.uk/people/staff/cr3/publications/cpn-train.html}, abstract = { The paper describes the design of a coloured Petri net model for a rather complex model train system. The purpose of this system is to teach graduate CS students net modelling and analysis techniques, and the systematic concersion of non-trivial net models into fully operational real systems. The track layout of this system currently includes three main cyclic tracks, each subdivided into several sections, three switchyards of several sidings, and also interconnecting tracks via which trains may change main tracks and directions. The idea is to equip each of several trains - currently up to ten - with its own travel plan. It specifies a sequence of tracks through which the train must be routed in the given order. Execution of these plans must be dynamically coordinated based on locally made decisions about the allocation of track sections to requesting trains so that essential safety and liveness properties are met. The paper first introduces the basic net components necessary to model train movement along track sections and across branching and merging switches, then describes the composition of a complete track model from these components, including the controls necessary to enforce an orderly behaviour, and then outlines the composition of the complete system model. It also addresses some of the as yet unsolved problems of deadlock prevention in the system. }, topics = {Petri Nets} } @inproceedings{Reinke99, author = {Claus Reinke}, title = {{Haskell-Coloured Petri Nets}}, booktitle = {{Implementation of Functional Languages (IFL~'99), Lochem, The Netherlands}}, editor = {P.~Koopman and C.~Clack}, series = {LNCS}, volume = {1868}, pages = {165--180}, publisher = {{Springer Verlag}}, year = 2000, month = {}, isbn = {3-540-67864-6}, sourceURL = {http://www.cs.ukc.ac.uk/people/staff/cr3/publications/HCPN.html}, abstract = { Coloured Petri Nets are a high-level form of Petri Nets, in which transition inscriptions in some programming language operate on individual tokens, i.e., tokens attributed with values of the inscription language. We introduce the variant of Haskell-Coloured Petri Nets (HCPNs) and show that they have a simple mapping to Haskell. HCPNs can thus be used for system modelling in preparation of system implementation in Haskell, following a process of stepwise refinement in which all intermediate specifications are executable Haskell programs. Similar mappings can be used to introduce functional Petri Nets as graphical specification languages on top of other functional languages. }, topics = {FP - Implementation,Petri Nets} } %% inline copy of Reinke.bib - END @article{Reynolds70, author = {John C.~Reynolds}, title = {{GEDANKEN -- A Simple Typeless Language Based on the Principle of Completeness and the Reference Concept}}, journal = CACM, year = 1970, volume = {13}, number = {5}, pages = {308-319}, month = may, topics = {Data Abstraction,Language Design/Semantics} } @incollection{Reynolds75, author = {John C.~Reynolds}, title = {{User-Defined Types and Procedural Data Structures as Complementary Approaches to Data Abstraction}}, booktitle = {{Theoretical Aspects of Object-Oriented Programming}}, publisher = {The MIT Press}, year = 1994, editor = {Carl A.~Gunter and John C.~Mitchell}, chapter = {1}, pages = {13-23}, note = {first appeared in 1975}, topics = {Data Abstraction} } @article{Reynolds93, author = {John C.~Reynolds}, title = {{The Discoveries of Continuations}}, journal = {Lisp and Symbolic Computation}, year = 1993, volume = {6}, number = {3/4}, pages = {233-248}, abstract = {We give a brief account of the discoveries of continuations and related concepts by A.~van Wijngaarden, A.~W.~Mazurkiewicz, F.~L.~Morris, C.~P.~Wadsworth, J.~H.~Morris, M.~J.~Fischer, and S.~K.~Abdali}, topics = {Language Design/Semantics} } @Article{Ritchie83, author = {Dennis M.~Ritchie and Ken Thompson}, title = {The {UNIX} Time-Sharing System}, journal = {Communications of the ACM}, volume = {26}, number = {1}, pages = {84--89}, month = jan, year = {1983}, abstract = {UNIX is a general-purpose, multi-user, interactive operating system for the Digital Equipment Corporation PDP-11/40 and 11/45 computers. It offers a number of features seldom found even in larger operating systems, including: (1) a hierarchical file system incorporating demountable volumes; (2) compatible file, device, and inter-process I/O; (3) the ability to initiate asynchronous processes; (4) system command languages selectable on a per-user basis; and (5) over 100 subsystems including a dozen languages. This paper discusses the nature and implementation of the file system and of the user command interface.}, topics = {History} } @inproceedings{Ritchie84, author = {D.~M.~Ritchie}, title = {The evolution of the {UNIX} time-sharing system}, booktitle = {{Symposium on Language Design and Programming Methodology, Sidney}}, year = 1979, editor = {Jeffrey M.~Tobias}, pages = {25-35}, publisher = {Springer Verlag, LNCS 79}, month = Sep, abstract = {This paper presents a brief history of the early development of the UNIX tm operating system. It concentrates on the evolution of the file system, the process-control mechanism, and the idea of pipelined commands. Some attention is paid to social conditions during the development of the system.}, topics = {History} } @article{RobinsonSilbert82, author = {J.A.~Robinson and E.E.~Silbert}, title = {{LOGLISP: An Alternative to PROLOG}}, journal = {Machine Intelligence}, year = 1982, volume = {10}, pages = {399-419}, topics = {LP - Languages} } @article{Ross60, author = {Douglas T.~Ross}, title = {{A Generalized Technique for Symbol Manipulation and Numerical Calculation}}, journal = CACM, year = 1961, volume = {4}, number = {3}, pages = {147-150}, month = mar, topics = {History,Records} } @inproceedings{Ruf93, author = {Erik Ruf}, title = {{Partial Evaluation in Reflective System Implementations}}, booktitle = {{OOPSLA '93 Workshop on Object-Oriented Reflection and Metalevel Architectures}}, year = 1993, sourceURL = {ftp://ftp.cpl.uiuc.edu/pub/washington/postscript/ruf.ps}, topics = {Reflection/Meta-Programming,Partial Evaluation} } @article{Runciman97, author = {Colin Runciman}, title = {{Lazy wheel sieves and spirals of primes}}, journal = {Journal of Functional Programming}, year = 1997, volume = {7}, number = {2}, pages = {219-225}, month = mar, topics = {FP - Programming} } @techreport{Russo96, author = {Claudio V.~Russo}, title = {{Standard ML Type Generativity as Existential Quantification}}, institution = EDCS, year = 1996, abstractURL = {http://www.dcs.ed.ac.uk/lfcsreps/EXPORT/96/ECS-LFCS-96-344/index.html}, sourceURL = {http://www.dcs.ed.ac.uk/lfcsreps/EXPORT/96/ECS-LFCS-96-344/ECS-LFCS-96-344.ps.gz}, type = {LFCS Technical Report}, number = {ECS-LFCS-96-344}, month = Jun, topics = {Modules,Type Systems,Standard ML} } %% S @book{Sammet69, author = {Jean Elaine}, title = {{Programming languages : history and fundamentals}}, publisher = {Prentice-Hall}, year = 1969, series = {Series in Automatic Computation}, topics = {History} } @inproceedings{Sansom96, author = {Patrick Sansom}, title = {{Smart Recompilation in Glasgow Haskell}}, booktitle = {{1996 Glasgow Workshop on Functional Programming}}, year = 1996, abstractURL = {http://ftp.dcs.glasgow.ac.uk/fp/workshops/fpw96/Proceedings96.html#Sansom}, sourceURL = {http://ftp.dcs.glasgow.ac.uk/fp/workshops/fpw96/Sansom.ps.gz}, editor = {Phil Trinder}, month = jul, topics = {Modules,FP - Implementation} } @inproceedings{SatoSakurai83, author = {M.~Sato and T.~Sakurai}, title = {{Qute : A Prolog/Lisp Type Language for Logic Programming}}, booktitle = {{IJCAI 83, Karlsruhe, W.-Germany}}, year = 1983, pages = {507-513}, topics = {LP - Languages} } @incollection{SatoSakurai86, crossref = {DeGrootLindstrom86}, author = {M.~Sato and T.~Sakurai}, title = {{Qute : A Functional Language Based On Unification}}, year = 1986, pages = {131-155}, topics = {Misc. Functional Languages,LP - Languages} } @inproceedings{Schepers91, author = {Schepers, J{\"o}rg}, title = {{Using Functional Languages for Process Specifications}}, booktitle = {3rd International Workshop on the Parallel Implementation of Functional Languages}, address = {Southampton, UK, June 5--7}, year = {1991}, editor = {Glaser, Hugh and Hartel, Pieter}, publisher = {Technical Report CSTR 91-07, University of Southampton}, pages = {89--102}, abstract = {The GRAPH-system, a tool for the specification, analysis and execution of communicating functional processes, is presented. Processes are specified in GRAPH at two separate specification levels: At the functional level the input/output behavior of processes is specified by means of pgorgrams of a functional language. At the process level these processes constitute the atomic components of hierarchically structured process systems, wherein process communication is realized via streams. Different process types are available, supporting the design of dynamically expanding process structures as well as of non-deterministic processes, such as semaphores. Process systems are externally represented as graphs which are variants of Petri-nets, composed from processes and streams. The Petri-net semantics allows to verify statically certain invariance properties which guarantee a stable overall system behavior. Structural deadlocks can also be detected by a static analysis. The GRAPH-system provides a syntax-oriented editor for the graphical specification of process systems. Furthermore, it includes several control and analysis facilities and supports the stepwise execution of processes under interactive control.}, keywords = {Process networks, streams, Petri nets, deadlocks}, } @phdthesis{Schluetter87, author = {Heinz Schluetter}, title = {{Investigations into the Foundations of Functional Programming and and Implementation of Existential Quantification on a Lambda Calculus Based Reduction Machine}}, school = {Graduate School of Syracuse University}, year = 1987, month = may, topics = {FP - General} } @phdthesis{Scholz97, author = {Sven--Bodo Scholz}, title = {{Single Assignment C -- Entwurf und Implementierung einer funktionalen C-Variante mit spezieller Unterstützung shape-invarianter Array-Operationen }}, school = ifi, year = 1996, sourceURL = {http://www.informatik.uni-kiel.de/~sbs/mypapers/sac-design-sbs-phd-96.ps.gz}, topics = {Misc. Functional Languages} } @techreport{Schreiner93, author = {Wolfgang Schreiner}, institution = {Research Institute for Symbolic Computation (RISC-Linz), Johannes Kepler University, Linz, Austria}, sourceURL = {http://www.risc.uni-linz.ac.at/people/schreine/papers/pfpbib.ps.gz}, title = {{Parallel Functional Programming, An Annotated Bibliography (2nd Edition)}}, year = 1993, topics = {FP - Nonsequential Execution} } @proceedings{Schuman71, editor = {Stephen A.~Schuman}, title = {{International Symposium on Extensible Languages}}, publisher = {ACM SIGPLAN Notices, 6(12)}, month = dec, year = 1971, topics = {History,Language Design/Semantics} } @incollection{ShawWulf80, author = {Mary Shaw and Wm.~A.~Wulf}, title = {{Toward Relaxing Assumptions in Languages and Their Implementations}}, booktitle = {{ALPHARD: Form and Content}}, publisher = {Springer-Verlag}, year = 1980, editor = {Mary Shaw}, chapter = {10}, pages = {295-313}, month = jan, topics = {Language Design/Semantics} } @book{Shaw81, editor = {Mary Shaw}, title = {{ALPHARD: Form and Content}}, publisher = {Springer-Verlag}, year = 1981, topics = {Language Design/Semantics,Modules,Data Abstraction} } @misc{SheardHook94, author = {Tim Sheard and James Hook}, title = {{Meta-Programming tools for ML}}, howpublished = {\url{ftp://cse.ogi.edu/pub/pacsoft/papers/MetaML.dvi}}, month = feb, year = 1994, sourceURL = {ftp://cse.ogi.edu/pub/pacsoft/papers/MetaML.dvi}, topics = {Reflection/Meta-Programming} } @misc{Sheard93, author = {Tim Sheard}, title = {{Type Parametric Programming}}, howpublished = {\url{http://www.cse.ogi.edu/~sheard/papers/typeparam.dvi}}, month = nov, year = 1993, sourceURL = {http://www.cse.ogi.edu/~sheard/papers/typeparam.dvi}, topics = {FP - General} } @misc{Shields97, author = {Marks Shields}, title = {{A Typed Intermediate Language for Haskell}}, howpublished = {Research Statement (WWW)}, month = Oct, year = 1997, sourceURL = {http://www.dcs.gla.ac.uk/~mbs/pub/research_statement.ps.gz}, topics = {Type Systems,FP - Implementation} } @inproceedings{ShieldsSheardPeytonJones98, author = {Mark Shields and Tim Sheard and Simon Peyton Jones}, title = {{Dynamic Typing as Staged Type Inference}}, booktitle = {25th} # POPL, year = 1998, sourceURL = {http://www.dcs.gla.ac.uk/~mbs/pub/dyntyping3.ps.gz}, editor = {}, pages = {}, month = jan, topics = {Type Systems,Reflection/Meta-Programming,Partial Evaluation}, keywords = {Dynamic Types} } @inproceedings{Silva96, author = {Miguel Mira da Silva and Malcolm Atkinson}, title = {{Combining Mobile Agents with Persistent Systems: Opportunities and Challenges}}, booktitle = {{2nd ECOOP Workshop on Mobile Object Systems}}, year = 1996, sourceURL = {http://www.dmat.uevora.pt/~mms/documents/ecoop96-subm.ps}, address = {Linz, Austria}, month = jul, abstract = {In the last three years we have been working with persistence and distribution, in particular migration of higher-level objects (such as procedures) between autonomous persistent programs. In this paper we introduce persistence and the suitability of Napier88 --- the persistent system we have used for our experiments --- as an agent language. We then present a few examples of opportunities and many more challenges that exist in the combination of persistence with agents. }, topics = {Persistence} } @inproceedings{SimmonsFriedman93, author = {Daniel P.~Friedman and John Wiseman Simmons II}, title = {{First-Class Interpreters: Illustrating the Limits Imposed by Representation in a Reflective Language}}, booktitle = {{Workshop on Object-Oriented Reflection and Metalevel Architectures, OOPSLA'93}}, year = 1994, sourceURL = {ftp://ftp.cpl.uiuc.edu/pub/washington/postscript/simmons.ps}, topics = {Reflection/Meta-Programming} } @article{Small93, author = {C.~Small}, title = {{A functional approach to database updates}}, abstractNOMORE = {http://web.dcs.bbk.ac.uk/~carol/DBPL/papers/INFSYS93.abs.html}, journal = {{Information Systems}}, volume = 18, number = 8, year = 1993, topics = {Persistence,Misc. Functional Languages} } @inproceedings{Smith84, author = {Brian Cantwell Smith}, title = {{Reflection and Semantics in Lisp}}, booktitle = {11th } # POPL, year = 1984, pages = {23-35}, topics = {Reflection/Meta-Programming} } @incollection{SubrahmanyamYou86, crossref = {DeGrootLindstrom86}, author = {P.A.~Subrahmanyam and J-H.~You}, title = {{FUNLOG: A Computational Model Integrating Logic Programming and Functional Programming}}, year = 1986, pages = {157-198}, topics = {Misc. Functional Languages,LP - Languages} } @inproceedings{SuttonSmall95, author = {D.R.~Sutton and C.~Small}, title = {{Extending functional database languages to update completeness}}, booktitle = {{13th British National Conference on Databases}}, year = 1995, abstractNOMORE = {http://web.dcs.bbk.ac.uk/~carol/DBPL/papers/BNCOD13.abs.html}, topics = {Persistence,Misc. Functional Languages} } @article{SondergaardSestoft90, author = {Harald S{\o}ndergaard and Peter Sestoft}, title = {{Referential Transparency, Definiteness and Unfoldability}}, journal = {Acta Informatica}, year = 1990, volume = {27}, pages = {505-517}, topics = {FP - General} } @misc{StAndrews, author = {miscellaneous authors}, title = {{St Andrews Persistence Group Publications}}, sourceURL = {http://www-fide.dcs.st-and.ac.uk/Publications/Default.html}, topics = {Persistence} } @techreport{SteeleSussman76, author = {Guy Lewis Steele, Jr.~and Gerald Jay Sussman}, title = {{Lambda: The Ultimate Imperative}}, institution = {MIT AI laboratory}, year = 1976, sourceURL = {ftp://publications.ai.mit.edu/ai-publications/0-499/AIM-353.ps}, type = {AI Memo}, number = {353}, month = Mar, abstract = {We demonstrate how to model the following common programming constructs in terms of an applicative order language similar to LISP: Simple Recursion, Iteration, Compound Statements and Expressions, GO TO and Assignment, Continuation-Passing, Escape Expressions, Fluid Variables, Call by Name, Call by Need, and Call by Reference. The models require only (possibly self-referent) lambda application, conditionals, and (rarely) assignment. No complex data structures such as stacks are used. The models are transparent, involving only local syntactic transformations. This paper is partly tutorial in intent, gathering all the models together for purposes of context. }, topics = {FP - General,Lisp/Scheme} } @techreport{Steele76, author = {Guy Lewis Steele, Jr.}, title = {{Lambda: The Ultimate Declarative}}, institution = {MIT AI laboratory}, year = 1976, sourceURL = {ftp://publications.ai.mit.edu/ai-publications/0-499/AIM-379.ps}, type = {AI Memo}, number = {379}, month = Nov, abstract = {In this paper, a sequel to ``Lambda: The Ultimate Imperative,'' a new view of LAMBDA as a {\it renaming} operator is presented and contrasted with the usual functional view taken by LISP. This view, combined with the view of function invocation as a kind of generalized GO TO, leads to several new insights into the nature of the LISP evaluation mechanism and the symmetry between form and function, evaluation and application, and control and environment. }, orig_keywords = {environments, lambda calculus, procedurally defined data, data types, optimizing compilers, control structures, function invocation, temporary variables, continuation passing, actors, lexical scoping, dynamic binding }, topics = {FP - General,Lisp/Scheme} } @misc{Steele98, author = {Guy Lewis Steele, Jr.}, title = {{Growing a Language}}, note = {Transcript of invited talk at OOPSLA'98, Vancouver}, howpublished = {\url{http://cm.bell-labs.com/cm/cs/who/wadler/steele-oopsla98.ps}}, month = Oct, year = 1998, sourceURL = {http://cm.bell-labs.com/cm/cs/who/wadler/steele-oopsla98.ps}, topics = {Language Design/Semantics} } @phdthesis{Steyaert94, author = {Patrick Steyaert}, title = {{Open Design of Object-Oriented Languages, A Foundation for Specialisable Reflective Language Frameworks (chapter 2)}}, school = {Programming Technology Lab (PROG) at the Vrije Universiteit Brussel (VUB)}, year = 1994, abstractURL = {http://progwww.vub.ac.be/prog/papers/htmlabstracts/vub-prog-phd-94-01.html}, sourceURL = {ftp://progftp.vub.ac.be/dissertation/1994/vub-prog-phd-94-01/}, url = {http://progwww.vub.ac.be/prog/pools/reflection/Reflection.html}, note = {This reference is to ``Computational Reflection and Open Systems'', which is part of (chapter2) of Patrick Steyaert's PhD thesis}, topics = {Reflection/Meta-Programming} } @Article{StoyStrachey72a, author = {J.~E.~Stoy and C.~Strachey}, title = {{OS6} --- An experimental operating system for a small computer. {I}. General principles and structure}, journal = {The Computer Journal}, volume = {15}, number = {2}, pages = {117--124}, month = may, year = {1972}, coden = {CMPJA6}, ISSN = {0010-4620}, bibdate = {Tue Mar 25 13:51:56 MST 1997}, acknowledgement = ack-nhfb, classcodes = {C6150J (Operating systems)}, corpsource = {Oxford Univ.~Computing Lab., UK}, orig_keywords = {BCPL; control structure; hierarchical; minicomputers; operating system; operating systems (computers); principles; small computer; structure; virtual machine}, treatment = {G General Review; X Experimental} } @Article{StoyStrachey72b, author = {J.~E.~Stoy and C.~Strachey}, title = {{OS6} --- An experimental operating system for a small computer. {II}. Input\slash output and filing system}, journal = {The Computer Journal}, volume = {15}, number = {3}, pages = {195--203}, month = aug, year = {1972}, coden = {CMPJA6}, ISSN = {0010-4620}, bibdate = {Tue Mar 25 13:51:56 MST 1997}, acknowledgement = ack-nhfb, classcodes = {C6150J (Operating systems)}, corpsource = {Oxford Univ.~Computing Lab., UK}, orig_keywords = {(computers); BCPL; filing system; input-output programs; input/output; minicomputers; operating; operating systems; small computer; system}, treatment = {P Practical} } @book{Stoy77, author = {Joseph E.~Stoy}, title = {{Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory}}, publisher = {The MIT Press}, year = 1977, topics = {Semantics,Language Design/Semantics} } @article{Stoye86, author = {William Stoye}, title = {{Message-Based Functional Operating Systems}}, journal = {Science of Computer Programming}, year = 1986, volume = {6}, pages = {291-311}, topics = {FP - Nonsequential Execution} } @misc{Strachey67, author = {Christopher Strachey}, title = {{Fundamental Concepts in Programming Languages}}, howpublished = {unpublished lecture notes of a course given at the International Summer School in Computer Programming at Copenhagen}, month = aug, year = 1967, topics = {History,Language Design/Semantics} } @inproceedings{Strachey72, author = {Christopher Strachey}, title = {{Varieties of Programming Language}}, booktitle = {{International Computing Symposium}}, year = 1972, pages = {222-233}, note = {also as: Technical Monograph PRG-10, Programming Research Group, Oxford, 1973}, topics = {Language Design/Semantics} } @techreport{StracheyWadsworth74, author = {Christopher Strachey and Christopher P.~Wadsworth}, title = {{Continuations: A Mathematical Semantics for Handling Full Jumps}}, institution = {Programming Research Group, Oxford University}, year = 1974, number = {PRG-11}, month = jan, topics = {Semantics,Language Design/Semantics} } @inproceedings{StreitzEtAl99, author = {Streitz, N.A. and Gei{\ss}ler, J. and Holmer, T. and Konomi, S. and M{\"u}ller-Tomfelde, C. and Reischl, W. and Rexroth, P. and Seitz, P., and Steinmetz, R.}, title = {{i-LAND: An interactive Landscape for Creativitiy and Innovation}}, booktitle = {{ACM Conference on Human Factors in Computing Systems (CHI '99), Pittsburgh, Pennsylvania, U.S.A.}}, year = 1999, sourceURL = {http://www.darmstadt.gmd.de/ambiente/paper/chi99Reprint.pdf}, publisher = {ACM Press, New York}, month = May, topics = {Human Computer Interfaces} } @book{Stroustrup97, author = {Bjarne Stroustrup}, title = {{The C++ programming language}}, publisher = ADDWES, year = 1997, sourceURL = {http://www.awl-he.com/titles/14288.html}, edition = {3rd}, topics = {Miscellaneous Languages} } @inproceedings{SwarupReddyIreland91, author = {Vipin Swarup and Uday S.~Reddy and Evan Ireland}, title = {{Assignments for Applicative Languages}}, booktitle = {{Functional Programming and Computer Architecture}}, year = 1991, pages = {192-214}, publisher = SPRINGER, series = LNCS, volume = 523, month = Aug, topics = {FP - State} } %%incomplete entry @misc{SwierstraDuponcheelXX, author = {S. Doaitse Swierstra and Luc Duponcheel}, title = {Deterministic, Error­Correcting Combinator Parsers}, year = 0, topics = {FP - Programming,Syntax} } %%incomplete entry @misc{SwierstraAlcocerSaraiva98, author = {S. Doaitse Swierstra and Pablo R. Azero Alcocer and Joao Saraiva}, title = {Designing and Implementing Combinator Languages}, year = 1998, topics = {FP - Programming,Syntax,Language Design/Semantics} } %% T @inproceedings{Taft93, author = {S.~Tucker Taft}, title = {{Ada 9X: From Abstraction-Oriented to Object-Oriented}}, booktitle = {{ACM OOPSLA'93}}, year = 1993, editor = {Andreas Paepcke}, pages = {127-135}, month = oct, topics = {Data Abstraction} } @article{Tanenbaum76, author = {Andrew S.~Tanenbaum}, title = {{A Tutorial on Algol 68}}, journal = {Computing Surveys}, year = 1976, volume = {8}, number = {2}, pages = {155-190}, month = jun, topics = {History} } @misc{TclTk98, author = {Tcl/Tk Consortium}, title = {{Home Page}}, howpublished = {\url{http://www.tclconsortium.org/}}, year = 1999, sourceURL = {http://www.tclconsortium.org/}, topics = {} } @article{Tennent77, author = {R.~D.~Tennent}, title = {{Language Design Methods Based on Semantic Principles}}, journal = {Acta Informatica}, year = 1977, volume = {8}, pages = {97-112}, topics = {Language Design/Semantics} } @inproceedings{TIL96, author = "D.~Tarditi and G.~Morrisett and P.~Cheng and C.~Stone and R.~Harper and P.~Lee", title = "TIL: A Type-Directed Optimizing Compiler for ML", booktitle = PLDI, month = may, year = 1996, sourceURL = "http://www.cs.cornell.edu/Info/People/jgm/papers/pldi96.ps", topics = {FP - Implementation,Standard ML,Type Systems} } @article{Thompson84, author = {Ken Thompson}, title = {{Reflections on Trusting Trust}}, journal = {Communication of the ACM}, year = 1984, sourceURL = {http://www.acm.org/classics/sep95/}, volume = {27}, number = {8}, pages = {761-763}, month = aug, note = {Also appears in ACM Turing Award Lectures: The First Twenty Years 1965-1985 and Computers Under Attack: Intruders, Worms, and Viruses (both by ACM press)}, topics = {Reflection/Meta-Programming} } @incollection{Thompson90, author = {Simon Thompson}, title = {{Interactive Functional Programs - A Method and a Formal Semantics}}, booktitle = {{Research Topics in Functional Programming}}, publisher = ADDWES, year = 1990, abstractURL = {http://www.hensa.ac.uk/TR/abstracts/unix.hensa.ac.uk@pub_misc_ukc.reports_comp.sci_online.bib.new/pub_misc_ukc.reports_comp.sci_abstracts_48}, sourceURL = {ftp://unix.hensa.ac.uk/pub/misc/ukc.reports/comp.sci/reports/48.ps.Z}, editor = {David A.~Turner}, chapter = {10}, pages = {249-285}, topics = {FP - Input/Output} } @mastersthesis{Timm96, author = {Stephan Timm}, title = {{Ein/Ausgabe-Operationen in KiR}}, school = ifi, year = 1996, sourceURL = {http://www.informatik.uni-kiel.de/~base/ffi/stt/stt_diplom.dvi.gz}, month = Jul, topics = {Kiel Reduction Language,FFI} } @InProceedings{TiurynWand95c, author = {Jerzy Tiuryn and Mitchell Wand}, title = {{Untyped Lambda-Calculus with Input-Output}}, year = 1996, booktitle = {{Trees in Algebra and Programming: CAAP'96, Proc.~21st International Colloquium}}, editor = {H.~Kirchner}, pages = {317-329}, organization = {}, publisher = SPRINGER, series = lncs, volume = 1059, month = apr, source = {/proj/wand/tiuryn/untyped/caap.tex}, sourceURL = {ftp://ftp.ccs.neu.edu/pub/people/wand/papers/caap-96.ps}, abstract = {We introduce an untyped lambda-calculus with input-output, based on Gordon's continuation-passing model of input-output. This calculus is intended to allow the classification of possibly infinite input-output behaviors, such as those required for servers or distributed systems. We define two terms to be operationally approximate iff they have similar behaviors in any context. We then define a notion of applicative approximation and show that it coincides with operational approximation for these new behaviors. Last, we consider the theory of pure lambda-terms under this notion of operational equivalence.}, topics = {FP - Input/Output,FP - Lambda Calculi} } @book{Turner90, editor = {David A.~Turner}, title = {{Research Topics in Functional Programming}}, publisher = ADDWES, year = 1990, topics = {FP - General} } @incollection{Turner87, author = {David Turner}, title = {{Functional Programming and Communicating Processes}}, booktitle = {{PARLE'87: Parallel Architectures and Languages Europe. Vol. 2: Parallel Languages}}, series = LNCS, volume = {259}, publisher = SPRINGER, year = 1987, pages = {}, topics = {FP - Nonsequential Execution} } @misc{Tycoon1H, key = {Tycoon1H}, title = {{Tycoon}}, howpublished = {\url{http://www.sts.tu-harburg.de/projects/Tycoon/entry.html}}, year = 1997, sourceURL = {http://www.sts.tu-harburg.de/projects/Tycoon/entry.html}, topics = {Persistence} } @misc{Tycoon2H, key = {Tycoon2H}, title = {{Tycoon-2}}, howpublished = {\url{http://www.sts.tu-harburg.de/projects/Tycoon2/entry.html}}, year = 1997, sourceURL = {http://www.sts.tu-harburg.de/projects/Tycoon2/entry.html}, topics = {Persistence} } %% U @misc{UML13, key = {UML13}, title = {{OMG Unified Modeling Language Specification (draft)}}, howpublished = {\url{http://www.rational.com/uml/resources/documentation/media/OMG-UML-1_3-Alpha5-PDF.zip}}, month = mar, year = 1997, sourceURL = {http://www.rational.com/uml/resources/documentation/media/OMG-UML-1_3-Alpha5-PDF.zip}, topics = {UML} } @inproceedings{UngarSmith87, author = {David Ungar and Randall B.~Smith }, title = {{Self: The Power of Simplicity}}, booktitle = {{OOPSLA '87, Orlando, Florida}}, year = 1987, abstractURL = {http://self.sunlabs.com/papers/self-power.html}, sourceURL = {http://self.sunlabs.com/papers/selfPower.ps.Z}, pages = {227-241}, note = {Published as SIGPLAN Notices 22(12), December, 1987. Also published in Lisp and Symbolic Computation 4(3), Kluwer Academic Publishers, June, 1991.}, topics = {Object-Orientation} } %% V @InCollection{vanWijngaarden63, author = {Adriaan van Wijngaarden}, title = {Generalized {ALGOL}}, booktitle = {Annual Review in Automatic Programming, Vol.~3}, editor = {Richard Goodman}, publisher = {Pergamon Press}, address = {Oxford}, year = 1963, pages = {17--26}, comment = {An earlier version appeared in Proceedings of the ICC Symposium on Symbolic Languages in Data Processing, Gordon and Breach, 1962, pp.~409--419}, topics = {Language Design/Semantics,History} } @misc{Venari, author = {miscellaneous authors}, title = {{CMU Venari Research Group Publications}}, sourceURL = {http://www.cs.cmu.edu/afs/cs.cmu.edu/project/venari/www/home.html}, topics = {Persistence} } @inproceedings{VullinghsTuijSchul95, AUTHOR = {Ton Vullinghs and Daniel Tuijnman and Wolfram Schulte}, TITLE = {{Lightweight GUIs for Functional Programming}}, editor = {M.~Hermenegildo and S.~D.~Swierstra}, booktitle = PLILP, PUBLISHER = SPRINGER, SERIES = {LNCS}, VOLUME = {982}, YEAR = 1995, abstractURL = {http://www.informatik.uni-ulm.de/pm/publikationen/VTS95.html}, sourceURL = {http://www.informatik.uni-ulm.de/pm/publikationen/VTS95.ps}, topics = {FP - Input/Output,FP - Graphics/Visual} } %% W @inproceedings{Wadler85, author = {Philip Wadler}, title = {{How to Replace Failure by a List of Successes}}, booktitle = {{Functional Programming Languages and Computer Architecture, LNCS 201}}, year = 1985, pages = {113-128}, publisher = SPRINGER, topics = {FP - Programming} } @inproceedings{Wadler87, author = {Philip Wadler}, title = {{Views: a way for pattern matching to cohabit with data abstraction}}, booktitle = {14th } # POPL, year = 1987, abstractURL = {http://cm.bell-labs.com/cm/cs/who/wadler/topics/language-design.html#views}, sourceURL = {http://cm.bell-labs.com/cm/cs/who/wadler/papers/view/view.ps.gz}, address = {Munich, Germany}, month = Jan, topics = {Programming/Software Engineering} } @inproceedings{WadlerBlott89, author = {Philip Walder and Stephen Blott}, title = {{How to make {\em ad-hoc polymorphism} less {\em ad hoc}}}, booktitle = {16th } # POPL, year = 1989, sourceURL = {http://cm.bell-labs.com/cm/cs/who/wadler/papers/class/class.ps.gz}, topics = {Type Systems} } @ARTICLE{Wadler92a, AUTHOR = {P.~Wadler}, TITLE = {{Comprehending Monads}}, JOURNAL = {{Mathematical Structures in Computer Science}}, YEAR = 1992, VOLUME = {2}, NUMBER = {4}, abstractURL = {http://cm.bell-labs.com/cm/cs/who/wadler/topics/monads.html#monads}, sourceURL = {http://cm.bell-labs.com/cm/cs/who/wadler/papers/monads/monads.ps.gz}, Note = {(Special issue of selected papers from 6'th Conference on Lisp and Functional Programming.)}, TOPICS ={FP - Monads} } @INPROCEEDINGS{Wadler92b, AUTHOR = {P.~Wadler}, TITLE = {{The essence of functional programming}}, sourceURL = {http://cm.bell-labs.com/cm/cs/who/wadler/papers/essence/essence.ps.gz}, BOOKTITLE = {{POPL '92, Albuquerque}}, YEAR = 1992, TOPICS ={FP - Monads} } @misc{Wadler92c, author ={Wadler, Philip}, title ={{Monads for functional programming}}, howpublished={Lecture notes for Marktoberdorf Summer School on Program Design Calculi, Springer-Verlag}, month ={Aug}, year = 1992, scope ={monads}, sourceURL ={ftp://ftp.dcs.gla.ac.uk/pub/glasgow-fp/authors/Philip_Wadler/monads-for-fp.dvi}, documentSize={102.2 kbytes}, topics = {FP - Monads} } @INPROCEEDINGS{Wadler95, AUTHOR = {Philip Wadler}, TITLE = {{How to declare an imperative}}, note = {(invited paper ILPS'95)}, Editor = {John Lloyd}, BOOKTITLE = {{International Logic Programming Symposium}}, PUBLISHER = {MIT Press}, YEAR = 1995, month = dec, sourceURL = {http://www.dcs.gla.ac.uk/fp/authors/Philip_Wadler/how-to-declare-an-imperative.dvi}, TOPICS = {FP - Input/Output,FP - Monads} } @misc{Wadler98a, author = {Philip Wadler}, title = {{A prettier printer}}, howpublished = {\url{http://www.cs.bell-labs.com/~wadler/papers/prettier/prettier.ps.gz}}, month = {Draft paper, April 1997, revised March 1998}, year = 1998, sourceURL = {http://www.cs.bell-labs.com/~wadler/papers/prettier/prettier.ps.gz}, topics = {FP - Programming} } @misc{Wadler98b, author = {Philip Wadler}, title = {{Functional Programming: An angry half-dozen}}, howpublished = {Column, SIGPLAN Notices 33(2):25-30}, month = feb, year = 1998, sourceURL = {http://cm.bell-labs.com/cm/cs/who/wadler/papers/sigplan-angry/sigplan-angry.ps.gz}, topics = {FP - General} } @phdthesis{Wadsworth71, author = {Christopher Peter Wadsworth}, title = {{Semantics and Pragmatics of the Lambda-Calculus}}, school = {Programming Research Group, University of Oxford}, year = 1971, month = sep, topics = {FP - Lambda Calculi} } @inproceedings{Wakeling97, author = {David Wakeling}, title = {{A Haskell to Java Virtual Machine Code Compiler,}}, booktitle = {{Proceedings of the 9th International Workshop on the Implementation of Functional Languages, St.~Andrews, September 1997}}, year = 1997, publisher = {Springer-Verlag}, topics = {FP - Implementation,Haskell,Java} } @inproceedings{Wakeling98b, author = {David Wakeling}, title = {{Mobile Haskell: Compiling Lazy Functional Programs for the Java Virtual Machine}}, booktitle = {{Principles of Delarative Programming, PLILP'98, Pisa, Italy}}, year = 1998, pages = {335-352}, publisher = {Springer-Verlag}, month = Sep, topics = {FP - Implementation,Java} } @article{Wakeling98a, author = {David Wakeling}, title = {{The Dynamic Compilation of Lazy Functional Programs}}, journal = JFP, year = 1998, sourceURL = {ftp://ftp.dcs.ex.ac.uk/pub/usr/david/jfp98.ps.Z}, volume = {8}, number = {1}, pages = {61-81}, month = jan, topics = {FP - Implementation} } @phdthesis{Wallace95, author = {Malcolm Wallace}, title = {{Functional Programming and Embedded Systems}}, school = {Department of Computer Science, University of York}, year = 1995, abstractURL = {ftp://ftp.cs.york.ac.uk/pub/malcolm/thesis.html}, sourceURL = {ftp://ftp.cs.york.ac.uk/pub/malcolm/thesis.ps.Z}, month = Jan, topics = {FP - Input/Output,FP - Nonsequential Execution} } @inproceedings{WallaceRunciman97, author = {Malcolm Wallace and Colin Runciman}, title = {{Heap Compression and Binary I/O in Haskell}}, booktitle = {{ACM SIGPLAN Haskell Workshop}}, year = 1997, sourceURL = {ftp://ftp.cs.york.ac.uk/pub/malcolm/hw97.ps.gz}, month = jun, topics = {FP - Implementation} } @article{Wand96, author = {Mitchell Wand}, title = {{The Theory of Fexprs is Trivial}}, journal = {to appear in {\it Lisp and Symbolic Computation}, 1998}, year = 1996, sourceURL = {ftp://ftp.ccs.neu.edu/pub/people/wand/papers/fexprs.ps}, month = dec, abstract = {We provide a very simple model of a reflective facility based on the pure lambda-calculus, and we show that its theory of contextual equivalence is trivial: two terms in the language are contextually equivalent iff they are alpha-congruent.}, topics = {Reflection/Meta-Programming} } @Book{Wasserman80, key = {Wasserman}, author = {Anthony I.~Wasserman}, title = {{TUTORIAL} Programming Language Design}, publisher = {IEEE Computer Society Press}, address = {Los Alamitos, Calif.}, year = 1980, note = {Initally presented at Compsac80, The IEEE Computer Society's Fourth International Computer Software \& Applications Conference, October 27-31, 1980. IEEE catalog no.: EHO 164-4.}, annote = {Reprints of classic papers.}, topics = {Language Design/Semantics} } @article{Wegner76, author = {Peter Wegner}, title = {{Programming Languages -- The First 25 Years}}, journal = {IEEE Transactions on Computers}, year = 1976, pages = {1207-1225}, month = dec, note = {reprinted in Wasserman80}, topics = {History} } @article{Weiser91, author = {Mark Weiser}, title = {{The Computer for the Twenty-First Century}}, journal = {Scientific American}, year = 1991, pages = {94--10}, month = sep, sourceURL = {http://www.ubiq.com/hypertext/weiser/SciAmDraft3.html}, topics = {Ubiquitous Computing} } @article{Weiser, author = {Mark Weiser}, title = {{The world is not a desktop}}, journal = {Interactions}, year = 1994, pages = {7--8}, month = jan, sourceURL = {http://www.ubiq.com/hypertext/weiser/ACMInteractions2.html}, topics = {Ubiquitous Computing} } @article{Weiser, author = {Mark Weiser}, title = {{Hot Topics: Ubiquitous Computing}}, journal = {IEEE Computer}, year = 1993, month = oct, sourceURL = {http://www.ubiq.com/hypertext/weiser/UbiCompHotTopics.html}, topics = {Ubiquitous Computing} } @article{Weiser, author = {Mark Weiser}, title = {{Some Computer Science Problems in Ubiquitous Computing}}, journal = CACM, year = 1993, month = jul, note = {Reprinted as "Ubiquitous Computing"; Nikkei Electronics; December 6, 1993; pp.~137-143}, topics = {Ubiquitous Computing} } @article{Wells96, author = {Joe Wells}, title = {{Typability and Type Checking in the Second-Order $\lambda$-Calculus Are Equivalent and Undecidable}}, journal = {submitted to APAP ??}, year = 1996, sourceURL = {ftp://ftp.cs.bu.edu/pub/jbw/types/f-undecidable.ps.gz}, note = {(an earlier version appeared in the proceedings of the {IEEE} Symposium on Logic in Computer Science 1994)}, month = Jun, topics = {Type Systems,FP - Lambda Calculi} } @proceedings{Wexelblat81, title = {{History of Programming Languages}}, year = 1981, editor = {Richard L.~Wexelblat}, publisher = {Academic Press}, note = {Proceedings of the ACM SIGPLAN History of Programming Languages Conference, June 1--3, 1978, Los Angeles, California}, annote = {From the cover text: A record of the early history of thirteen languages that set the tone of most of today's programming: ALGOL, APL, APT, COBOL, BASIC, FORTRAN, GPSS, JOSS, JOVIAL, LISP, PL/I, SIMULA, and SNOBOL}, topics = {History} } @Proceedings{Wexelblat93, ISBN = {0-89791-570-4}, editor = {Richard L.~Wexelblat}, title = {{Proceedings of the Conference on History of Programming Languages}}, conflocation = {Cambridge, MA, USA}, month = apr, confyear = {1993}, series = {ACM Sigplan Notices}, volume = {28(3)}, publisher = {ACM Press}, address = {New York, NY, USA}, year = 1993, topics = {History} } @book{WilkesWheelerGill57, author = {Maurice V.~Wilkes and David J.~Wheeler and Stanley Gill}, title = {{The Preparation of Programs for an Electronic Digital Computer}}, publisher = ADDWES, year = 1957, edition = {second}, topics = {History} } @misc{Wing90, author = {Jeannette M.~Wing}, title = {{The Venari Project: Goals and Plans}}, month = may, year = 1990, sourceURL = {http://www.cs.cmu.edu/afs/cs.cmu.edu/project/venari/www/note1.ps}, note = {(Carnegie Mellon)}, topics = {Persistence,Groups and Projects} } @incollection{Winograd97, author = {Terry Winograd}, title = {{From Computing Machinery to Interaction Design}}, booktitle = {{Beyond Calculation: The Next Fifty Years of Computing}}, publisher = SPRINGER, year = 1997, localURL = {}, sourceURL = {http://hci.standford.edu/~winograd/acm97.html}, editor = {Peter Denning and Robert Metcalfe}, chapter = {}, pages = {149--162}, topics = {Human Computer Interfaces} } @misc{Winograd98, author = {Terry Winograd}, title = {{A Human-Centered Interaction Architecture}}, note = {Working paper for the Interactive Workspaces Project}, howpublished = {\url{http://graphics.stanford.edu/projects/iwork/papers/humcent/}}, month = sep, year = 1998, sourceURL = {http://graphics.stanford.edu/projects/iwork/papers/humcent/}, topics = {Human Computer Interfaces} } @book{Winston84, author = {P.~H.~Winston and B.~K.~P.~Horn}, title = {{Lisp}}, edition = {second}, annote = {(first edition 1981)}, publisher = ADDWES, year = 1984 , topics = {Lisp/Scheme} } @article{WirthHoare66, author = {Niklaus Wirth and C.~A.~R.~Hoare}, title = {{A Contribution to the Development of ALGOL}}, journal = CACM, year = 1966, volume = {9}, number = {6}, pages = {413-432}, month = jun, topics = {Records} } @article{Wirth77, author = {Niklaus Wirth}, title = {{Design and Implementation of Modula}}, journal = {Software -- Practice and Experience}, year = 1977, volume = {7}, pages = {67-84}, topics = {Modules} } @inproceedings{Wirth79, author = {Niklaus Wirth}, title = {{The Module: A System Structuring Facility in High-Level Programming Languages}}, booktitle = {{Proceedings of the Symposium on Language Design and Programming Methodology held in Sidney, Australia}}, year = 1979, editor = {Jeffrey M.~Tobias}, pages = {1-24}, publisher = SPRINGER, topics = {Modules} } %% X @misc{Xerox-OI, key = {Xerox-OI}, title = {{Open Implementation Group, Xerox PARC}}, howpublished = {\url{http://www.parc.xerox.com/spl/projects/oi/}}, year = 1996, sourceURL = {http://www.parc.xerox.com/spl/projects/oi/}, topics = {Programming/Software Engineering,Data Abstraction,Groups and Projects} } %% Y @article{You89, author = {J-H.~You}, title = {{Enumerating Outer Narrowing Derivations for Constructor-Based Term Rewriting Systems}}, journal = {Journal of Symbolic Computation}, year = 1989, number = {7}, pages = {319-341}, topics = {Rewrite Systems} } %% Z @article{Zilles73, author = {Stephen N.~Zilles}, title = {{Procedural Encapsulation: A Linguistic Protection Technique}}, journal = {SIGPLAN Notices}, year = 1973, volume = {8}, number = {9}, pages = {142-146}, month = sep, topics = {Data Abstraction} }