参考书目

Abadi, Martín, & Cardelli, Luca. 1996. A Theory of Objects. Berlin, Heidelberg, and New York: Springer-Verlag.

Abelson, Harold, & Sussman, Gerald Jay. 1985. The Structure and Interpretation of Computer Programs. Cambridge, MA: MIT Press.

Abelson, Harold, & Sussman, Gerald Jay. 1996. Structure and Interpretation of Computer Programs. Second edition. Cambridge, MA: McGraw Hill.

Aho, Alfred V., Lam, Monica S., Sethi, Ravi, & Ullman, Jeffrey D. 2006. Compilers: Principles, Techniques, and Tools. Second edition. Boston: Addison-Wesley Longman.

Appel, Andrew W., & Jim, Trevor. 1989. Continuation-Passing, Closure-Passing Style. Pages 293–302 of: Proceedings ACM Symposium on Principles of Programming Languages.

Arnold, Ken, & Gosling, James. 1998. The Java Programming Language. Second edition. The Java Series. Reading, MA: Addison-Wesley.

Armstrong, Joe. 2007. Programming Erlang: Software for a Concurrent World. The Pragmatic Programmers Publishers.

Backus, John W., et al. 1957. The Fortran Automatic Coding System. Pages 188–198 of: Western Joint Computer Conference.

Barendregt, Henk P. 1981. The Lambda Calculus: Its Syntax and Semantics. Amsterdam: North-Holland.

Barendregt, Henk P. 1991. The Lambda Calculus. Revised edition. Studies in Logic and the Foundations of Mathematics, no. 103. Amsterdam: North-Holland.

Bergin, Thomas J., & Gibson, Richard G. (eds.). 1996. History of Programming Languages. New York: Addison-Wesley.

Birtwistle, Graham M., Dahl, Ole-Johan, & Myhrhaug, Bjorn. 1973. Simula Begin. Philadelphia: Auerbach.

Burstall, Rod M. 1969. Proving Properties of Programs by Structural Induction. Computer Journal, 12(1), 41–48.

Church, Alonzo. 1941. The Calculi of Lambda Conversion. Princeton, NJ: Princeton University Press. Reprinted 1963 by University Microfilms, Ann Arbor, MI.

Clinger, William D., et al. 1985a. The Revised Revised Report on Scheme or The Uncommon Lisp. Technical Memo AIM-848. Massachusetts Institute of Technology, Artificial Intelligence Laboratory.

Clinger, William D., Friedman, Daniel P., & Wand, Mitchell. 1985b. A Scheme for a Higher-Level Semantic Algebra. Pages 237–250 of: Reynolds, John, & Nivat, Maurice (eds.), Algebraic Methods in Semantics: Proceedings of the US-French Seminar on the Application of Algebra to Language Definition and Compilation (Fontainebleau, France, June, 1982). Cambridge: Cambridge University Press.

Clinger, William D., Rees, Jonathan, et al. 1991. The Revised4 Report on the Algorithmic Language Scheme. ACM Lisp Pointers, 4(3), 1–55.

Danvy, Olivier, & Filinski, Andrzej. 1992. Representing Control: A Study of the CPS Transformation. Mathematical Structures in Computer Science, 2(4), 361–391.

Danvy, Olivier, & Nielsen, Lasse R. 2003. A First-order One-pass CPS Transformation. Theoretical Computer Science, 308(1-3), 239–257.

de Bruijn, N. G. 1972. Lambda Calculus Notation with Nameless Dummies: A Tool for Automatic FormulaManipulation, with Application to the Church-Rosser Theorem. Indagationes Mathematicae, 34, 381–392.

Dominus, Mark Jason. 2005. Higher-Order Perl: Transforming Programs with Programs. San Francisco: Morgan Kaufmann Publishers.

Dybvig, R. Kent. 2003. The Scheme Programming Language. Third edition. Cambridge, MA: MIT Press.

Felleisen, Matthias, & Friedman, Daniel P. 1996. The Little MLer. Cambridge, MA: MIT Press.

Felleisen, Matthias, Findler, Robert Bruce, Flatt, Matthew, & Krishnamurthi, Shriram. 2001. How to Design Programs. Cambridge, MA: MIT Press.

Fischer, Michael J. 1972. Lambda-Calculus Schemata. Pages 104–109 of: Proceedings ACM Conference on Proving Assertions about Programs. Republished in Lisp and Symbolic Computation, 6(3/4), 259–288.

Flanagan, Cormac, Sabry, Amr, Duba, Bruce F., & Felleisen, Matthias. 1993. The Essence of Compiling with Continuations. Pages 237–247 of: Proceedings ACM SIGPLAN 1993 Conf. on Programming Language Design and Implementation, PLDI’93, Albuquerque, NM, USA, 23–25 June 1993, vol. 28(6). New York: ACM Press.

Flatt, Matthew, Krishnamurthi, Shriram, & Felleisen, Matthias. 1998. Classes and Mixins. Pages 171–183 of: Proceedings ACMSymposium on Principles of Programming Languages.

Friedman, Daniel P. 1974. The Little LISPer. Palo Alto, CA: Science Research Associates.

Friedman, Daniel P., & Felleisen, Matthias. 1996. The Little Schemer. Fourth edition. Cambridge, MA: MIT Press.

Friedman, Daniel P., & Wise, David S. 1976. Cons should not Evaluate its Arguments. Pages 257–284 of: Michaelson, S., & Milner, R. (eds.), Automata, Languages and Programming. Edinburgh: Edinburgh University Press.

Gamma, Erich, Helm, Richard, Johnson, Ralph, & Vlissides, John. 1995. Design Patterns: Bookents of Reusable Object-Oriented Software. Reading, MA: Addison Wesley.

Giarratana, V., Gimona, F., & Montanari, U. 1976. Observability Concepts in Abstract Data Type Specifications. Pages 576–587 of: Mazurkiewicz, A. (ed.), Mathematical Foundations of Computer Science 1976. Lecture Notes in Computer Science, vol. 45. Berlin, Heidelberg, New York: Springer-Verlag.

Goguen, Joseph A., Thatcher, James W., Wagner, Eric G., & Wright, Jesse B. 1977. Initial Algebra Semantics and Continuous Algebras. Journal of the ACM, 24, 68–95.

Goldberg, Adele, & Robson, David. 1983. Smalltalk-80: The Language and Its Implementation. Reading, MA: Addison-Wesley.

Gordon, Andrew D. 1995. A Tutorial on Co-induction and Functional Programming. Pages 78–95 of: Functional Programming, Glasgow 1994. Berlin, Heidelberg, and New York: SpringerWorkshops in Computing.

Gosling, James, Joy, Bill, & Steele, Guy L. 1996. The Java Language Specification. The Java Series. Reading, MA: Addison-Wesley.

Hailpern, Brent (ed.). 2007. HOPL III: Proceedings of the Third ACM SIGPLAN Conference on History of Programming Languages. New York: ACM Press.

Hankin, Chris. 1994. Lambda Calculi: A Guide for Computer Scientists. Graduate Texts in Computer Science, vol. 3. Oxford: Clarendon Press.

Haynes, Christopher T., Friedman, Daniel P., & Wand, Mitchell. 1986. Obtaining Coroutines with Continuations. J. of Computer Languages, 11(3/4), 143–153.

Hewitt, Carl. 1977. Viewing Control Structures as Patterns of Passing Messages. Artificial Intelligence, 8, 323–364.

Hindley, Roger. 1969. The Principal Type-Scheme of an Object in Combinatory Logic. Transactions of the American Mathematical Society, 146, 29–60.

Hudak, Paul, et al. 1990. Report on the Programming Language HASKELL. Technical Report YALEU/DCS/RR-777. Yale University, CS Dept.

IEEE. 1991. IEEE Standard for the Scheme Programming Language, IEEE Standard 1178-1990. IEEE Computer Society, New York.

Igarashi, Atshushi, Pierce, Benjamin C., & Wadler, Philip. 1999. Featherweight Java: AMinimal Core Calculus for Java and GJ. Pages 132–146 of: Meissner, Loren (ed.), Proceedings of the 1999 ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages & Applications (OOPSLA ‘99).

Ingerman, Peter Z. 1961. Thunks, A Way of Compiling Procedure Statements with Some Comments on Procedure Declarations. Communications of the ACM, 4(1), 55–58.

Jacobs, Bart, & Rutten, Jan. 1997. A Tutorial on (Co)Algebras and (Co)Induction. Bulletin of the European Association for Theoretical Computer Science, 62, 222–259.

Johnston, John B. 1971. The Contour Model of Block Structured Processes. SIGPLAN Notices, 6(2), 55–82.

Kamin, Samuel. 1980. Final Data Type Specifications: A New Data Type Specification Method. Pages 131–138 of: Proceedings ACM Symposium on Principles of Programming Languages.

Kelsey, Richard, Clinger, William D., & Rees, Jonathan. 1998. Revised5 Report on the Algorithmic Language Scheme. Higher-Order and Symbolic Computation, 11(1), 7–104.

Kiczales, G., des Rivières, J., & Bobrow, D. G. 1991. The Art of the Meta-Object Protocol. Cambridge, MA: MIT Press.

Knuth, Donald E. 1968. Semantics of Context-Free Languages. Mathematical Systems Theory, 2, 127–145. Correction, 5:95–96, 1971.

Knuth, Donald E., & Pardo, L. T. 1977. The Early Development of Programming Languages. Pages 419–493 of: Belzer, J., Holzman, A. G., & Kent, D. (eds.), Encyclopedia of Computer Science and Technology, vol. 6. New York: Marcel Dekker.

Kranz, David A., Kelsey, Richard, Rees, Jonathan A., Hudak, Paul, Philbin, James, & Adams, Norman I. 1986. Orbit: An Optimizing Compiler for Scheme. Pages 219–223 of: Proceedings SIGPLAN ’86 Symposium on Compiler Construction.

Landin, Peter J. 1965a. Correspondence between ALGOL 60 and Church’s Lambda-notation: Part I. Commun. ACM, 8(2), 89–101.

Landin, Peter J. 1965b. A Generalization of Jumps and Labels. Technical Report. UNIVAC Systems Programming Research. Reprinted with a foreword in Higher-Order and Symbolic Computation, 11(2):125–143, 1998.

Leroy, Xavier. 1994. Manifest Types, Modules, and Separate Compilation. Pages 190–122 of: Proceedings ACM Symposium on Principles of Programming Languages.

Lewis, Bil, & Berg, Daniel J. 1998. Multithreaded Programming with PThreads. Englewood Cliffs, NJ: Prentice-Hall.

Liskov, Barbara, Snyder, Alan, Atkinson, R., & Schaffert, Craig. 1977. Abstraction Mechanisms in CLU. Communications of the ACM, 20, 564–576.

McCarthy, John. 1960. Recursive Functions of Symbolic Expressions and their Computation by Machine, Part I. Communications of the ACM, 3, 184–195.

McCarthy, John. 1962. Towards aMathematical Science of Computation. Pages 21–28 of: Popplewell (ed.), Information Processing 62. Amsterdam: North-Holland.

Michie, Donald. 1968. “Memo” Functions and Machine Learning. Nature, 218(1–3), 218–219.

Milne, Robert, & Strachey, Christopher. 1976. A Theory of Programming Language Semantics. London: Chapman and Hall.

Milner, Robin. 1978. A Theory of Type Polymorphism in Programming. Journal of Computer and Systems Science, 17, 348–375.

Milner, Robin, Tofte, Mads, & Harper, Robert. 1989. The Definition of Standard ML. Cambridge, MA: MIT Press.

Milner, Robin, Tofte, Mads, Harper, Robert, & MacQueen, David B. 1997. The Standard ML Programming Language (Revised). Cambridge, MA: MIT Press.

Moggi, Eugenio. 1991. Notions of Computation and Monads. Information and Computation, 93(1), 55–92.

Morris, Jr., James H. 1968. Lambda Calculus Models of Programming Languages. Ph.D. thesis, MIT, Cambridge, MA.

Morris, Jr., James H., & Wegbreit, Ben. 1977. Subgoal Induction. Communications of the ACM, 20, 209–222.

Naur, Peter, et al. 1963. Revised Report on the Algorithmic Language ALGOL 60. Communications of the ACM, 5(1), 1–17.

Parnas, David L. 1972. A Technique for Module Specification with Examples. Communications of the ACM, 15(5), 330–336.

Paulson, Laurence C. 1996. ML for the Working Programmer. Second edition. New York: Cambridge University Press.

Peyton Jones, Simon L. 1987. The Implementation of Functional Programming Languages. Englewood Cliffs, NJ: Prentice-Hall International.

Peyton Jones, Simon L. 2001.Tackling the Awkward Squad: Monadic Input/Output, Concurrency, Exceptions, and Foreign-Language Calls in Haskell. In: Hoare, C.A.R., Broy, Manfred, & Steinbruggen, Ralf (eds.), Engineering Theories of Software Construction, Marktoberdorf Summer School. Amsterdam, The Netherlands: IOS Press.

Pierce, Benjamin C. 2002. Types and Programming Languges. Cambridge, MA:MIT Press.

Pierce, Benjamin C. 2004. Advanced Topics in Types and Programming Languges. Cambridge, MA: MIT Press.

Plotkin, Gordon D. 1975. Call-by-Name, Call-by-Value and the λ-Calculus. Theoretical Computer Science, 1, 125–159.

Plotkin, Gordon D. 1977. LCF Considered as a Programming Language. Theoretical Computer Science, 5, 223–255.

Plotkin, Gordon D. 1981. A Structural Approach to Operational Semantics. Technical Report FN 19, DAIMI, Department of Computer Science. University of Aarhus, Aarhus, Denmark.

Pratt, Terrence W., & Zelkowitz, Marvin V. 2001. Programming Languages: Design and Implementation. 4th edition. Englewood Cliffs, NJ: Prentice-Hall.

Rees, Jonathan A., Clinger, William D., et al. 1986. Revised3 Report on the Algorithmic Language Scheme. SIGPLAN Notices, 21(12), 37–79.

Reynolds, John C. 1972. Definitional Interpreters for Higher-Order Programming Languages. Pages 717–740 of: Proceedings ACM National Conference. Reprinted, with a foreword, in Higher-Order and Symbolic Computation 11(4) 363-397 (1998).

Reynolds, John C. 1975. User-Defined Types and Procedural Data Structures as Complementary Approaches to Data Abstraction. In: Conference on New Directions on Algorithmic Languages. IFIPWP 2.1, Munich.

Reynolds, John C. 1993. The Discoveries of Continuations. Lisp and Symbolic Computation, 6(3/4), 233–248.

Sabry, Amr, & Felleisen, Matthias. 1992. Reasoning about Programs in Continuation-Passing Style. Pages 288–298 of: Proceedings 1992 ACM Conf. on Lisp and Functional Programming. New York: ACM Press.

Sabry, Amr, & Felleisen, Matthias. 1993. Reasoning about Programs in Continuation-Passing Style. Lisp and Symbolic Computation, 6(3/4), 289–360.

Sabry, Amr, & Wadler, Philip. 1997. A Reflection on Call-by-Value. ACM Transactions on Programming Languages and Systems, 19(6), 916–941.

Scott, Michael L. 2005. Programming Language Pragmatics. Second edition. San Francisco: Morgan Kaufmann.

Sebesta, Robert W. 2007. Concepts of Programming Languages. 8th edition. Boston: Addison-Wesley Longman Publishing Co., Inc.

Smith, Joshua B. 2006. Practical OCaml. Berkeley, CA: Apress.

Sperber, Michael, Dybvig, R. Kent, Flatt, Matthew, & van Straaten, Anton. 2007. Revised6 Report on the Algorithmic Language Scheme. www.r6rs.org.

Springer, George, & Friedman, Daniel P. 1989. Scheme and the Art of Programming. New York: McGraw-Hill.

Steele, Guy L. 1978. Rabbit: A Compiler for Scheme. Artificial Intelligence Laboratory Technical Report 474. Massachusetts Institute of Technology, Cambridge, MA.

Steele, Guy L. 1990. Common Lisp: the Language. Second edition. Burlington, MA: Digital Press.

Steele, Guy L., & Sussman, Gerald Jay. 1978. The Revised Report on SCHEME. Artificial Intelligence Memo 452. Massachusetts Institute of Technology, Cambridge, MA.

Stoy, Joseph E. 1977. Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory. Cambridge, MA: MIT Press.

Strachey, Christopher. 1967. Fundamental Concepts in Programming Languages. Unpublished notes from International Summer School on Programming Languages, Copenhagen. Reprinted, with a foreword, in Higher-Order and Symbolic Computation 13(1–2) 11–49 (2000).

Strachey, Christopher, & Wadsworth, Christopher P. 1974. Continuations: A Mathematical Semantics for Handling Full Jumps. Technical Monograph PRG-11. Oxford University Computing Laboratory. Reprinted, with a foreword, in Higher-Order and Symbolic Computation 13(1–2) 135–152 (2000).

Sussman, Gerald Jay, & Steele, Guy L. 1975. SCHEME: An Interpreter for Extended Lambda Calculus. Artificial Intelligence Memo 349. Massachusetts Institute of Technology, Cambridge, MA. Reprinted, with a foreword, in Higher-Order and Symbolic Computation 11(4) 405-439 (1998).

Thomas, Dave, Fowler, Chad, & Hunt, Andy. 2005. Programming Ruby: The Pragmatic Programmers’ Guide. Second edition. Raleigh, NC: The Pragmatic Bookshelf.

Turing, A. M. 1936. On Computable Numbers, with an Application to the Entscheidungsproblem. Proc. London Math. Soc., 42(1), 230–265.

Ullman, Jeffrey D. 1998. Elements of ML Programming. ML97 edition. Englewood Cliffs, NJ: Prentice-Hall.

van Rossum, Guido, & Drake, Fred L. Jr. 2006. The Python Language Reference Manual (Version 2.5). Bristol, UK: Network Theory Ltd.

von Neumann, John. 1945. First Draft of a Report on the EDVAC. Technical Report. Moore School of Electrical Engineering, University of Pennsylvania.

Wadler, Philip. 1992. The Essence of Functional Programming. Pages 1–14 of: Proceedings ACM Symposium on Principles of Programming Languages.

Wall, Larry, Christiansen, Tom, & Orwant, Jon. 2000. Programming Perl. 3rd edition. Cambridge, MA: O’Reilly.

Wand, Mitchell. 1979. Final Algebra Semantics and Data Type Extensions. Journal of Computer and Systems Science, 19, 27–44.

Wand, Mitchell. 1980a. Continuation-Based Multiprocessing. Pages 19–28 of: Allen, J. (ed.), Conference Record of the 1980 LISP Conference. Palo Alto, CA: The Lisp Company. Republished by ACM. Reprinted, with a foreword, in Higher-Order and Symbolic Computation 12(3) 285–299 (1999).

Wand, Mitchell. 1980b. Continuation-Based Program Transformation Strategies. Journal of the ACM, 27, 164–180.

Wand, Mitchell. 1987. A Simple Algorithm and Proof for Type Inference. Fundamenta Informaticae, 10, 115–122.

Wexelblatt, R. L. (ed.). 1978. Special Issue: History of Programming Languages Conference. Vol. 13. New York: ACM Press.

Winskel, Glynn. 1993. The Formal Semantics of Programming Languages. Cambridge, MA: MIT Press.

Wulf, William. 1971. BLISS: A Language for Systems Programming. Communications of the ACM, 14(12), 780–790.