Skip to main content Accessibility help
Practical Foundations for Programming Languages
  • Cited by 19
  • 89.99 (USD)
    Digital access
    (PDF download and/or read online)
    Add to cart
    Added to cart
    Digital access
    (PDF download and/or read online)
    View cart
  • Export citation
  • Recommend to librarian

Book description

Types are the central organizing principle of the theory of programming languages. In this innovative book, Professor Robert Harper offers a fresh perspective on the fundamentals of these languages through the use of type theory. Whereas most textbooks on the subject emphasize taxonomy, Harper instead emphasizes genetics, examining the building blocks from which all programming languages are constructed. Language features are manifestations of type structure. The syntax of a language is governed by the constructs that define its types, and its semantics is determined by the interactions among those constructs. The soundness of a language design – the absence of ill-defined programs – follows naturally. Professor Harper's presentation is simultaneously rigorous and intuitive, relying on elementary mathematics. The framework he outlines scales easily to a rich variety of language concepts and is directly applicable to their implementation. The result is a lucid introduction to programming theory that is both accessible and practical.


"Harper's book provides a comprehensive treatment of the foundations of computation. He touches on a surprising range of concepts that arise in language design: from simple types to polymorphism to dependent types to modules; from strict to lazy to parallel computation; and from proof techniques for reasoning about extensional behavior to practical, compositional cost models in the presence of garbage collection. More importantly, throughout the book he uses types and the principles of type theory to organize the material and help us discover the orthogonal, composable abstractions that arise naturally not only in the design of programming languages but also in logics and mathematics. This approach helps uncover the fundamental structure lurking inside programming languages of today, and provides a principled approach to the designs for tomorrow."
Greg Morrisett, School of Engineering and Applied Sciences, Harvard University

"Starting with a mathematically simple framework and organizing principles that give type systems a central role, Bob Harper's magnum opus reveals the theory of programming languages as a coherent scientific subject with both breadth and elegance. His enormous experience, pithy views, and great good taste are evident throughout a book that deserves to become a classic."
Andrew Pitts, Computer Laboratory, University of Cambridge

"This book offers an excellent introduction to a wide range of programming language concepts. They are all uniformly and carefully explained, using techniques that are very useful in practice for both analysis and implementation of programming languages. The book is authored by one of the most prominent researchers in type theory for programming languages. The presentation is very effective and based on the author's years of experience teaching the material."
Lars Birkedal, Professor, IT University of Copenhagen

Refine List

Actions for selected content:

Select all | Deselect all
  • View selected items
  • Export citations
  • Download PDF (zip)
  • Save to Kindle
  • Save to Dropbox
  • Save to Google Drive

Save Search

You can save your searches here and later view and run them again in "My saved searches".

Please provide a title, maximum of 40 characters.


Page 1 of 3

Page 1 of 3

Abadi, M. and L., Cardelli (1996). A Theory of Objects. Springer-Verlag.
Abadi, M. and C., Fournet (2001). Mobile values, new names, and secure communication. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 104–15, Association for Computing Machinery.
Aczel, P. (1977). An introduction to inductive definitions. In Jon, Barwise, editor, Handbook of Mathematical Logic, chapter C.7, pp. 783–818. North-Holland.
Allen., J. (1978). The Anatomy of LISP. Computer Science Series. McGraw-Hill.
Allen, S. (1987). A non-type-theoretic definition of Martin-Löf's types. In LICS, pp. 215–21. IEEE Computer Society.
Allen, S. F., M., Bickford, R. L., Constable, R., Eaton, C., Kreitz, L., Lorigo, and E., Moran (2005). Innovations in computational type theory using NuPRL. J. Appl. Logic, 4: 428–69.
Andreoli, J.-M. (1992). Logic programming with focusing proofs in linear logic. J. Log. Comput., 2: 297–347.
Ariola, Z. M. and M., Felleisen (1997). The call-by-need lambda calculus. J. Funct. Prog., 7: 265–301.
Arvind, R., S., Nikhil, and K., Pingali (1986). I-structures: Data structures for parallel computing. In J. H., Fasel and R. M., Keller, editors, Graph Reduction, Volume 279 of Lecture Notes in Computer Science Series, pp. 336–69. Springer.
Avron, A. (1991). Simple consequence relations. Inf. Comput., 92:105–39.
Barendregt, H. (1984). The Lambda Calculus, Its Syntax and Semantics. Volume 103 of Studies in Logic and the Foundations of Mathematics. North-Holland.
Barendregt, H. (1992). Lambda calculi with types. In S., Abramsky, D. M., Gabbay, and T. S. E, Maibaum, editors, Handbook of Logic in Computer Science, Volume 2 of Computational Structures Series. Oxford University Press.
Bertot, Y., G., Huet, J.-J., Lévy, and G., Plotkin (editors) (2009). From Semantics to Computer Science: Essays in Honor of Gilles Kahn. Cambridge University Press.
Blelloch, G. E. (1990). Vector Models for Data-Parallel Computing. MIT Pres.
Blelloch, G. E. and J., Greiner (1995). Parallelism in sequential functional languages. In FPCA, pp. 226–37.
Blelloch, G. E. and J., Greiner (1996). A provable time and space efficient implementation of NESL. In ICFP, pp. 213–25.
Brookes, S. D. (2002). The essence of parallel Algol. Inf. Comput., 179(1): 118–49.
Burstall, R. M., D. B., MacQueen, and D., Sannella (1980). Hope: An experimental applicative language. In LISP Conference, pp. 136–43.
Buss, S. R. (editor). (1998). Handbook of Proof Theory. Elsevier.
Cardelli, L. (1988). Structural subtyping and the notion of power type. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 70–9. Association for Computing Machinery.
Cardelli, L. (1997). Program fragments, linking, and modularization. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 266–77. Association for Computing Machinery.
Castagna, G. and B. C., Pierce (1994). Decidable bounded quantification. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 151–62. Association for Computing Machinery.
Church, A. (1941). The Calculi of Lambda-Conversion. Princeton University Press.
Colmerauer, A. and P., Roussel (1993). The birth of Prolog. In Proceedings of the Second ACM SIGPLAN Conference on the History of Programming Languages, HOPL-II, pp. 37–52. Association for Computing Machinery.
Constable, R. L. (1986). Implementing Mathematics with the Nupri Proof Development System. Prentice-Hall.
Constable, R. L. (1998). Types in logic, mathematics, and programming. In S. R., Buss, editor, Handbook of Proof Theory, chapter X. Elsevier.
Constable, R. L. and S. F., Smith (1987). Partial objects in constructive type theory. In LICS, pp. 183–93. IEEE Computer Society.
Cook, W. R. (2009). On understanding data abstraction, revisited. In OOPSLA, pp. 557–72.
Cousineau, G. and M., Mauny (1998). The Functional Approach to Programming. Cambridge University Press.
Crary, K. (2009). A syntactic account of singleton types via hereditary substitution. In Proceedings of the Fourth International Workshop on Logical Frameworks and MetaLanguages: Theory and Practice, LFMTP '09, pp. 21–29. Association for Computing Machinary.
Dreyer, D. (2005). Understanding and Evolving the ML Module System. Ph.D. dissertation. Carnegie Mellon University.
Engberg, U. and M., Nielsen. (2000). A calculus of communicating systems with label passing — ten years after. In G. D., Plotkin, C., Stirling, and M., Tofte (editors), Proof, Language, and Interaction, Essays in Honour of Robin Milner, pp. 599–622. MIT Press.
Felleisen, M. and R., Hieb (1992). The revised report on the syntactic theories of sequential control and state. TCS: Theoretical Computer Science, 103.
Gelernter, D. (1985). Generative communication in Linda. ACM Trans. Prog. Lang. Syst., 7: 80–112.
Gentzen, G. (1969). Investigations into logical deduction. In M. E., Szabo, editor, The Collected Papers of Gerhard Gentzen, pp. 68–213. North-Holland.
Girard, J.-Y. (1972). Interpretation fonctionelle et elimination des coupures de l'arithmetique d'ordre superieur. These d'etat, Universite Paris VII.
Girard, J.-Y. (1989). Proofs and Types. Translated by P., Taylor and Y., Lafont. Cambridge University Press.
Gödel, K. (1980). On a hitherto unexploited extension of the finitary standpoint. Translated by W., Hodges and B., Watson. Philos. Logic, 9: 133–42.
Gordon, M. J., A. J., Milner, and C., P. Wadsworth. Edinburgh LCF, Volume 78 of Lecture Notes in Computer Science Series. Springer-Verlag.
Greiner, J. and G. E., Blelloch (1999). A provably time-efficient parallel implementation of full speculation. ACM Trans. Prog. Lang. Syst., 21: 240–85.
Griffin, T. (1990). A formulae-as-types notion of control. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 47–58. Association for Computing Machinery.
Halstead, R. H. Jr. (1985). Multilisp: A language for concurrent symbolic computation. ACM Trans. Prog. Lang. Syst., 7: 501–38.
Harper, R. (1992). Constructing type systems over an operational semantics. J. Symb. Comput., 14: 71–84.
Harper, R. (1994). A simplified account of polymorphic references. Inf. Process. Lett., 51: 201–6.
Harper, R. and M., Lillibridge (1994). A type-theoretic approach to higher order modules with sharing. In Proceecings of the ACM Symposium on Principles of Programming Languages, pp. 123–37. Association for Computing Machinery.
Harper, R., J. C., Mitchell, and E., Moggi (1990). Higher-order modules and the phase distinction. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 341–54. Association for Computing Machinery.
Harper, R., F., Honsell, and G., Plotkin (1993). A framework for defining logics. J. Assoc. Comput. Mach., 40: 194–204.
Hinze, R. and J., Jeuring (2003). Generic Haskell: practice and theory. In R. C., Backhouse and J., Gibbons, editors, Generic Programming, Volume 2793 of Lecture Notes in Computer Science, pp. 1–56. Springer.
Hoare, C. A. R. (1978). Communicating sequential processes. Commun. ACM, 21: 666–77.
Hoare, T. (2009). Null references: the billion dollar mistake. Paper presented at QCon.
Jones, S. L. P. (2003). Haskell 98: Introduction. J. Funct. Program., 13: 0–6.
Kleene, S. C. (1952). Introduction to Metamathematics. van Nostrand.
Kowalski, R. A. (1988). The early years of logic programming. Commun. ACM, 31: 38–43.
Lakatos, I. (1976). Proofs and Refutations: The Logic of Mathematical Discovery. Cambridge University Press.
Landin, P. J. (1965). A correspondence between Algol 60 and Church's lambda notation. Commun. ACM, 8: 89–101; 158–65.
Lee, D. K., K., Crary, and R., Harper (2007). Towards a mechanized metatheory of Standard ML. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 173–84. Association for Computing Machinery.
Leroy, X. (1994). Manifest types, modules, and separate compilation. In Pro. ACM Symposium on Principles of Programming Languages, pp. 109–22, 1994.
Leroy, X. (1995). Applicative functors and fully transparent higher-order modules. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 142–53. Association for Computing Machinery.
Licata, D. R. and R., Harper (2010). A monadic formalization of ML5. In K., Crary and M., Miculan, editors, Logical Frameworks and Metalanguages: Theory and Practice, Volume 34 of EPTCS Series, pp. 69–83. Association for Computing Mechinery.
Lillibridge, M. (1997). Translucent Sums: A Foundation for Higher-Order Module Systems. Ph.D. dissertation, Carnegie Mellon University School of Computer Science.
Liskov, B. and J. M., Wing (1994). A behavioral notion of subtyping. ACM Trans. Prog. Lang. Syst., 16: 1811–41.
MacLane, S. (1998). Categories for the Working Mathematician (2nd ed). Graduate Texts in Mathematics Series. Springer-Verlag.
MacQueen, D. B. (1986). Using dependent types to express modular structure. In Proceedings of the ACM Symposium on Principles of Programming Languges, pp. 277–86. Association for Computing Machinery.
MacQueen, D. B. (2009). Kahn networks at the dawn of functional programming. In Bertot, et al., editors, From Semantics to Computer Science: Essays in Honor of Gilles Kahn, chapter 5. Cambridge University Press.
Martin-Löf, P. (1980). Constructive mathematics and computer programming. In Logic, Methodology and Philosophy of Science IV, pp. 153–75. North-Holland.
Martin-Löf, P. (1983). On the meanings of the logical constants and the justifications of the logical laws. Unpublished lecture notes.
Martin-Löf, P. (1984). Intuitionistic Type Theory. Studies in Proof Theory Series. Bibliopolis.
Martin-Löf, P. (1987). Truth of a proposition, evidence of a judgement, validity of a proof. Synthese, 73: 407–20.
McCarthy, J. (1965). LISP1.5 Programmer's Manual. MIT Press.
Mendler, N. P. (1987). Recursive types and type constraints in second-order lambda calculus. In LICS, pp. 30–6. IEEE Computer Society.
Milner, R. (1978). A theory of type polymorphism in programming. JCSS, 17: 348–75.
Milner, R. (1999). Communicating and Mobile Systems — the Pi-Calculus. Cambridge University Press.
Milner, R., M., Tofte, R., Harper, and D., MacQueen (1997). The Definition of Standard ML (Revised). MIT Press.
Mitchell, J. C. (1984). Coercion and type inference. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 175–85. Association for Computing Machinery.
Mitchell, J. C. (1986). Representation independence and data abstraction. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 263–76. Association for Computing Machinery.
Mitchell, J. C. (1996). Foundations for Programming Languages. MIT Press.
Mitchell, J. C. and G. D., Plotkin (1988). Abstract types have existential type. ACM Trans. Prog. Lang. Syst., 10: 470–502.
Murphy, T. VII, K., Crary, R., Harper, and F., Pfenning (2004). A symmetric modal lambda calculus for distributed computing. In LICS, pp. 286–95. IEEE Computer Society.
Murthy, C. R. (1991). An evaluation semantics for classical proofs. In LICS, pp. 96–107. IEEE Computer Society.
Nanevski, A. (2003). From dynamic binding to state via modal possibility. In PPDP, pp. 207–18. Association for Computing Machinery.
Nederpelt, R. P., J. H., Geuvers, and R. C., deVrijer (editors) (1994). Selected Papers on Automath, Volume 133 of Studies in Logic and the Foundations of Mathematics Series. North-Holland.
Ocaml (2012). Available at
Park, D. M. R. (1981). Concurrency and automata on infinite sequences. In P., Deussen, editor, Theoretical Computer Science, Volume 104 of Lecture Notes in Computer Science Series, pp. 167–83. Springer.
Pierce, B. C. (2002). Types and Programming Languages. MIT Press.
Pierce, B. C. (2004). Advanced Topics in Types and Programming Languages. MIT Press.
Pitts, A. M. (1998). Existential types: Logical relations and operational equivalence. In K. G., Larsen, S., Skyum, and G., Winskel, editors, ICALP, Volume 1443 of Lecture Notes in Computer Science Series, pp. 309–26. Springer.
Pitts, A. M. (2000). Operational semantics and program equivalence. In G., Barthe, P., Dybjer, L., Pinto, and J., Saraiva, editors, APPSEM, Volume 2395 of Lecture Notes in Computer Science Series, pp. 378–412. Springer.
Pitts, A. M. and I. D. B., Stark (1993). Observable properties of higher order functions that dynamically create local names, or what's new? In A. M., Borzyszkowski and S., Sokolowski, editors, MFCS, Volume 711 of Lecture Notes in Computer Science Series, pp. 122–141. Springer.
Plotkin, G. D. (1977). LCF considered as a programming language. Theor. Comput. Sci., 5: 223–55.
Plotkin, G. D. (1981). A structural approach to operational semantics. Technical Report DAIMIFN-19, Aarhus University, Computer Science Department.
Plotkin, G. D. (2004). The origins of structural operational semantics. J. Logic Algebraic Program., 60: 3–15.
Reppy, J. H. (1999). Concurrent Programming in ML. Cambridge University Press.
Reynolds, J. C. (1974). Towards a theory of type structure. In B., Robinet, editor, Symposium on Programming, Volume 19 of Lecture Notes in Computer Science Series, pp. 408–23. Springer.
Reynolds, J. C. (1980). Using category theory to design implicit conversions and generic operators. In N. D., Jones, editor, Semantics-Directed Compiler Generation, Volume 94 of Lecture Notes in Computer Science Series, pp. 211–58. Springer.
Reynolds, J. C. (1981). The essence of Algol. In Proceedings of the 1981 International Symposium on Algorithmic Languages, pp. 345–72. North-Holland.
Reynolds, J. C. (1983). Types, abstraction, and parametric polymorphism. In Information Processing '83, pp. 513–23. North-Holland.
Reynolds, J. C. (1993). The discoveries of continuations. Lisp Symbol. Comput., 6: 233–48.
Reynolds, J. C. (1998). Theories of Programming Languages. Cambridge University Press, Cambridge, England.
Rossberg, A., C. V., Russo, and D., Dreyer (2010). F-ing modules. In A., Kennedy and N., Benton, editors, TLDI, pp. 89–102. ACM.
Scott, D. (1980). Lambda calculus: Some models, some philosophy. In J., Barwise, H. J., Keisler, and K., Kunen, editors, The Kleene Symposium, pp. 223–65. North-Holland, Amsterdam.
Scott, D. S. (1976). Data types as lattices. SIAM J. Comput., 5(3): 522–87.
Scott, D. S. (1982). Domains for denotational semantics. In M., Nielsen and E. M., Schmidt, editors, ICALP, volume 140 of Lecture Notes in Computer Science, pp. 577–613. Springer.
Smyth, M. B. and G. D., Plotkin (1982). The category-theoretic solution of recursive domain equations. SIAM J. Comput., 11(4): 761–83.
Statman, R. (1985). Logical relations and the typed lambda-calculus. Information and Control, 65(2/3): 85–97.
Steele, G. L. (1990). Common Lisp: The Language (2nd ed.). Digital Press.
Stone, C. A. and R., Harper (2006). Extensional equivalence and singleton types. ACM Trans. Comput. Log., 7: 676–722.
Taylor, P. (1999). Practical Foundations of Mathematics. Cambridge Studies in Advanced Mathematics. Cambridge University Press.
Turner, D. (1987). An overview of Miranda. Bull. EATCS, 33: 103–14.
Wadler, P. (1989). Theorems for free! In FPCA, pp. 347–59.
Wadler, P. (2003). Call-by-value is dual to call-by-name. In C., Runciman, and O., Shivers, editors, ICFP, pp. 189–201. Association for Computing Machinery.
Wand, M. (1979). Fixed-point constructions in order-enriched categories. Theor. Comput. Sci., 8: 13–30.
Watkins, K., I., Cervesato, F., Pfenning, and D., Walker (2008). Specifying properties of concurrent computations in clf. Electr. Notes Theor. Comput. Sci., 199: 67–87.
Wright, A. K. and M., Felleisen (1994). A syntactic approach to type soundness. Inf. Comput., 115: 38–94.
Zeilberger, N. (2008). On the unity of duality. Ann. Pure Appl. Logic, 153: 66–96.


Altmetric attention score

Full text views

Total number of HTML views: 0
Total number of PDF views: 0 *
Loading metrics...

Book summary page views

Total views: 0 *
Loading metrics...

* Views captured on Cambridge Core between #date#. This data will be updated every 24 hours.

Usage data cannot currently be displayed.