Abelson, H., and G. J. Sussman. 1996. Structure and Interpretation of Computer Programs. 2nd ed. Cambridge, MA: MIT Press.

Aho, A. V., R. Sethi, and J. D. Ullman. 1999. Compilers: Principles, Techniques, and Tools. Reading, MA: Addison-Wesley.

Alexander, C., S. Ishikawa, M. Silverstein, M. Jacobson, I. Fiksdahl-King, and S. Angel. 1977. A Pattern Language: Towns, Buildings, Construction. New York, NY: Oxford University Press.

Appel, A. W. 1992. Compiling with Continuations. Cambridge, UK: Cambridge University Press.

Appel, A. W. 1993. “A Critique of Standard ML.” Journal of Functional Programming 3 (4): 391–429.

Appel, A. W. 2004. Modern Compiler Implementation in ML. Cambridge, UK: Cambridge University Press.

Arabnia, H. R., L. Deligiannidis, M. R. Grimaila, D. D. Hodson, and F. G. Tinetti. 2019. CSC’19: Proceedings of the 2019 International Conference on Scientific Computing. Las Vegas, NV: CSREA Press.

Backus, J. 1978. “Can Programming Be Liberated from the von Neumann Style?: A Functional Style and Its Algebra of Programs.” Communications of the ACM 21 (8): 613–641.

Bauer, F. L., and J. Eickel. 1975. Compiler Construction: An Advanced Course. New York, NY: Springer-Verlag.

Boole, G. 1854. An Investigation of the Laws of Thought: On Which Are Founded the Mathematical Theories of Logic and Probabilities. London, UK: Walton and Maberly.

Carroll, L. 1958. Symbolic Logic and the Game of Logic. Mineola, NY: Dover Publications.

Christiansen, T., b. d. foy, L. Wall, and J. Orwant. 2012. Programming Perl: Unmatched Power for Text Processing and Scripting. 4th ed. Sebastopol, CA: O’Reilly Media.

Codognet, P., and D. Diaz. 1995. “wamcc: Compiling Prolog to C.” In Proceedings of Twelfth International Conference on Logic Programming (ICLP), 317–331.

Computing Curricula 2020 Task Force. 2020. Computing Curricula 2020: Paradigms for Global Computing Education. Technical report. Association for Computing Machinery and IEEE Computer Society. Accessed March 26, 2021. https://www.acm.org/binaries/content/assets/education/curricula-recommendations/cc2020.pdf.

Conway, M. E. 1963. “Design of a Separable Transition-Diagram Compiler.” Communications of the ACM 6 (7): 396–408.

Coyle, C., and P. Crogono. 1991. “Building Abstract Iterators Using Continuations.” ACM SIGPLAN Notices 26 (2): 17–24.

Dijkstra, E. W. 1968. “Go To Statement Considered Harmful.” Communications of the ACM 11 (3): 147–148.

Dybvig, R. K. 2003. The Scheme Programming Language. 3rd ed. Cambridge, MA: MIT Press.

Dybvig, R. K. 2009. The Scheme Programming Language. 4th ed. Cambridge, MA: MIT Press.

Eckroth, J. 2018. AI Blueprints: How to Build and Deploy AI Business Projects. Birmingham, UK: Packt Publishing.

Feeley, M. 2004. The 90 Minute Scheme to C Compiler. Accessed May 20, 2020. http://churchturing.org/y/90-min-scc.pdf.

Felleisen, M., R. B. Findler, M. Flatt, S. Krishnamurthi, E. Barzilay, J. McCarthy, and S. Tobin-Hochstadt. 2018. “A Programmable Programming Language.” Communications of the ACM 61 (3): 62–71.

Flanagan, D. 2005. Java in a Nutshell. 5th ed. Beijing: O’Reilly.

Foderaro, J. 1991. “LISP: Introduction.” Communications of the ACM 34 (9). https://doi.org/10.1145/114669.114670.

Friedman, D. P., and M. Felleisen. 1996a. The Little Schemer. 4th ed. Cambridge, MA: MIT Press.

Friedman, D. P., and M. Felleisen. 1996b. The Seasoned Schemer. Cambridge, MA: MIT Press.

Friedman, D. P., and M. Wand. 2008. Essentials of Programming Languages. 3rd ed. Cambridge, MA: MIT Press.

Friedman, D. P., M. Wand, and C. Haynes. 2001. Essentials of Programming Languages. 2nd ed. Cambridge, MA: MIT Press.

Gabriel, R. P. 2001. “The Why of Y.” Accessed March 5, 2021. https://www.dreamsongs.com/Files/WhyOfY.pdf.

Gamma, E., R. Helm, R. Johnson, and J. Vlissides. 1995. Design Patterns: Elements of Reusable Object-Oriented Software. Reading, MA: Addison Wesley.

Garcia, M., T. Gandhi, J. Singh, L. Duarte, R. Shen, M. Dantu, S. Ponder, and H. Ramirez. 2001. “Esdiabetes (an Expert System in Diabetes).” Journal of Computing Sciences in Colleges 16 (3): 166–175.

Giarratano, J. C. 2008. CLIPS User’s Guide. Cambridge, MA: MIT Press.

Graham, P. 1993. On Lisp. Upper Saddle River, NJ: Prentice Hall. Accessed July 26, 2018. http://paulgraham.com/onlisp.html.

Graham, P. 1996. ANSI Common Lisp. Upper Saddle River, NJ: Prentice Hall.

Graham, P. 2002. The Roots of Lisp. Accessed July 19, 2018. http://lib.store.yahoo.net/lib/paulgraham/jmc.ps.

Graham, P. 2004a. “Beating the Averages.” In Hackers and Painters: Big Ideas from the Computer Age. Beijing: O’Reilly. Accessed July 19, 2018. http://www.paulgraham.com/avg.html.

Graham, P. 2004b. Hackers and Painters: Big Ideas from the Computer Age. Beijing: O’Reilly.

Graham, P. n.d. [Haskell] Pros and Cons of Static Typing and Side Effects? http://paulgraham.com/lispfaq1.html; https://mail.haskell.org/pipermail/haskell/2005-August/016266.html

Graham, P. n.d. LISP FAQ. Accessed July 19, 2018. http://paulgraham.com/lispfaq1.html.

Graunke, P., R. Findler, S. Krishnamurthi, and M. Felleisen. 2001. “Automatically Restructuring Programs for the Web.” In Proceedings of the Sixteenth IEEE International Conference on Automated Software Engineering (ASE), 211–222.

Harbison, S. P., and G. L. Steele Jr. 1995. C: A Reference Manual. 4th ed. Englewood Cliffs, NJ: Prentice Hall.

Harmelen, F. van, and A. Bundy. 1988. “Explanation-Based Generalisation = Partial Evaluation.” Artificial Intelligence 36 (3): 401–412.

Harper, R. n.d.a. n.d. “Teaching FP to Freshman.” Accessed July 19, 2018. http://existentialtype.wordpress.com/2011/03/15/teaching-fp-to-freshmen/.

Harper, R. n.d.b. n.d. “What Is a Functional Language?” Accessed July 19, 2018. http://existentialtype.wordpress.com/2011/03/16/what-is-a-functional-language/.

Haynes, C. T., and D. P. Friedman. 1987. “Abstracting Timed Preemption with Engines.” Computer Languages 12 (2): 109–121.

Haynes, C. T., D. P. Friedman, and M. Wand. 1986. “Obtaining Coroutines with Continuations.” Computer Languages 11 (3/4): 143–153.

Heeren, B., D. Leijen, and A. van IJzendoorn. 2003. “Helium, for Learning Haskell.” In Proceedings of the ACM SIGPLAN Workshop on Haskell, 62–71. New York, NY: ACM Press.

Hieb, R., K. Dybvig, and C. Bruggeman. 1990. “Representing Control in the Presence of First-Class Continuations.” In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). New York, NY: ACM Press.

Hoare, T. 1980. The 1980 ACM Turing Award Lecture. https://www.cs.fsu.edu/∼engelen/courses/COP4610/hoare.pdf

Hofstadter, D. R. 1979. Gödel, Escher, Bach: An Eternal Golden Braid. New York, NY: Basic Books.

Hughes, J. 1989. “Why Functional Programming Matters.” The Computer Journal 32 (2): 98–107. Also appears as: Hughes, J. 1990. “Why Functional Programming Matters.” In Research Topics in Functional Programming, edited by D. A. Turner, 17–42. Boston, MA: Addison-Wesley.

Hutton, G. 2007. Programming in Haskell. Cambridge, UK: Cambridge University Press.

Interview with Simon Peyton-Jones. 2017. People of Programming Languages:An interview project in conjunction with the Forty-Fifth ACM SIGPLAN Symposium on Principles of Programming Languages (POPL 2018). Interviewer: Jean Yang. Accessed January 20, 2021. https://www.cs.cmu.edu/popl-interviews/peytonjones.html.

Iverson, K. E. 1999. Math for the Layman. JSoftware Inc. https://www.jsoftware.com/books/pdf/mftl.zip

The Joint Task Force on Computing Curricula: Association for Computing Machinery (ACM) and IEEE Computer Society. 2013. Computer Science Curricula 2013: Curriculum Guidelines for Undergraduate Degree Programs in Computer Science. Technical report. Association for Computing Machinery and IEEE Computer Society. Accessed January 26, 2021. https://www.acm.org/binaries/content/assets/education/cs2013_web_final.pdf.

Jones, N. D. 1996. “An Introduction to Partial Evaluation.” ACM Computing Surveys 28 (3): 480–503.

Kamin, S. N. 1990. Programming Languages: An Interpreter-Based Approach. Reading, MA: Addison-Wesley.

Kay, A. 2003. Dr. Alan Kay on the Meaning of “Object-Oriented Programming, July 23, 2003.” Accessed January 14, 2021. http://www.purl.org/stefan_ram/pub/doc_kay_oop_en.

Kernighan, B. W., and R. Pike. 1984. The UNIX Programming Environment. 2nd ed. Upper Saddle River, NJ: Prentice Hall.

Kernighan, B. W., and P. J. Plauger. 1978. The Elements of Programming Style. 2nd ed. New York, NY: McGraw-Hill.

Knuth, D. E. 1974a. “Computer Programming as an Art.” Communications of the ACM 17 (12): 667–673.

Knuth, D. E. 1974b. “Structured Programming with go to Statements.” ACM Computing Surveys 6 (4): 261–301.

Kowalski, R. A. 1979. “Algorithm = Logic + Control.” Communications of the ACM 22 (7): 424–436.

Krishnamurthi, S. 2003. Programming Languages: Application and Interpretation. Accessed February 27, 2021. http://cs.brown.edu/sk/Publications/Books/ProgLangs/2007-04-26/plai-2007-04-26.pdf.

Krishnamurthi, S. 2008. “Teaching Programming Languages in a Post-Linnaean Age.” ACM SIGPLAN Notices 43 (11): 81–83.

Krishnamurthi, S. 2017. Programming Languages: Application and Interpretation. 2nd ed. Accessed February 27, 2021. http://cs.brown.edu/courses/cs173/2012/book/book.pdf.

Lämmel, R. 2008. “Google’s MapReduce Programming Model—Revisited.” Science of Computer Programming 70 (1): 1–30.

Landin, P. J. 1966. “The Next 700 Programming Languages.” Communications of the ACM 9 (3): 157–166.

Levine, J. R. 2009. Flex and Bison. Cambridge, MA: O’Reilly.

Levine, J. R., T. Mason, and D. Brown. 1995. Lex and Yacc. 2nd ed. Cambridge, MA: O’Reilly.

MacQueen, D. B. 1993. “Reflections on Standard ML.” In Functional Programming, Concurrency, Simulation and Automated Reasoning: International Lecture Series 1991–1992, McMaster University, Hamilton, Ontario, Canada, 32–46. London, UK: Springer-Verlag.

MacQueen, D., R. Harper, and J. Reppy. 2020. “The History of Standard ML.” Proceedings of the ACM on Programming Languages 4 (HOPL): article 86.

Matthews, C. 1998. An Introduction to Natural Language Processing Through Prolog. London, UK: Longman.

McCarthy, J. 1960. “Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I.” Communications of the ACM 3 (4): 184–195.

McCarthy, J. 1981. “History of Lisp.” In History of Programming Languages, edited by R. Wexelblat. Cambridge, MA: Academic Press.

Miller, J. S. 1987. “Multischeme: A Parallel Processing System Based on MIT Scheme.” PhD dissertation. Massachusetts Institute of Technology.

Milner, R. 1978. “A Theory of Type Polymorphism in Programming.” Journal of Computer and System Sciences 17:348–375.

Muehlbauer, J. 2002. “Orbitz Reaches New Heights.” New Architect. Accessed February 10, 2021. https://people.apache.org/jim/NewArchitect/newarch/2002/04/new1015626014044/index.html.

Murray, P., and L. Murray. 1963. The Art of the Renaissance. London, UK: Thames and Hudson.

Niemann, T. n.d. Lex and Yacc Tutorial. ePaperPress. http://epaperpress.com/lexandyacc/.

Parr, T. 2012. The Definitive ANTLR4 Reference. Dallas, TX: Pragmatic Bookshelf.

Pereira, F. 1993. “A Brief Introduction to Prolog.” ACM SIGPLAN Notices 28 (3): 365–366.

Pérez-Quiñones, M. A. 1996. “Conversational Collaboration in User-Initiated Interruption and Cancellation Requests.” PhD dissertation, George Washington University.

Perlis, A. J. 1982. “Epigrams on Programming.” ACM SIGPLAN Notices 17 (9): 7–13.

Perugini, S., and J. L. Watkin. 2018. “ChAmElEoN: A Customizable Language for Teaching Programming Languages.” Journal of Computing Sciences in Colleges 34 (1): 44–51.

Peters, T. 2004. PEP 20: The Zen of Python. Accessed January 12, 2021. https://www.python.org/dev/peps/pep-0020/.

Peyton Jones, S. L. 1987. The Implementation of Functional Programming Languages. Prentice-Hall International Series in Computer Science. Upper Saddle River, NJ: Prentice-Hall.

Quan, D., D. Huynh, D. R. Karger, and R. Miller. 2003. “User Interface Continuations.” In Proceedings of the Sixteenth Annual ACM Symposium on User Interface Software and Technology (UIST), 145–148. New York, NY: ACM Press.

Queinnec, C. 2000. “The Influence of Browsers on Evaluators or, Continuations to Program Web Servers.” In Proceedings of the Fifth ACM SIGPLAN International Conference on Functional Programming (ICFP), 23–33. New York, NY: ACM Press.

Rich, E., K. Knight, and S. B. Nair. 2009. Artificial Intelligence. 3rd ed. India: McGraw-Hill India.

Robinson, J. A. 1965. “A Machine-Oriented Logic Based on the Resolution Principle.” Journal of the ACM 12 (1): 23–41.

Savage, N. 2018. “Using Functions for Easier Programming.” Communications of the ACM 61 (5): 29–30.

Scott, M. L. 2006. Programming Languages Pragmatics. 2nd ed. Amsterdam: Morgan Kaufmann.

Sinclair, K. H., and D. A. Moon. 1991. “The Philosophy of Lisp.” Communications of the ACM 34 (9): 40–47.

Somogyi, Z., F. Henderson, and T. Conway. 1996. “The Execution Algorithm of Mercury, an Efficient Purey Declarative Logic Programming Language.” The Journal of Logic Programming 29:17–64.

Sperber, M., R. K. Dybvig, M. Flatt, A. van Straaten, R. Findler, and J. Matthews, eds. 2010. Revised ⁶ Report on the Algorithmic Language Scheme. Cambridge, UK: Cambridge University Press.

Sussman, G. J., and G. L. Steele Jr. 1975. “Scheme: An Interpreter for Extended Lambda Calculus.” AI Memo 349. Accessed May 22, 2020. https://dspace.mit.edu/handle/1721.1/5794.

Sussman, G. J., G. L. Steele Jr., and R. P. Gabriel. 1993. “A Brief Introduction to Lisp.” ACM SIGPLAN Notices 28 (3): 361–362.

Swaine, M. 2009. “It’s Time to Get Good at Functional Programming: Is It Finally Functional Programming’s Turn?” Dr. Dobb’s Journal 34 (1): 14–16.

Thompson, S. 2007. Haskell: The Craft of Functional Programming. 2nd ed. Harlow, UK: Addison-Wesley.

Ullman, J. 1997. Elements of ML Programming. 2nd ed. Upper Saddle River, NJ: Prentice Hall.

Venners, B. 2003. Python and the Programmer: A Conversation with Bruce Eckel, Part I. Accessed July 28, 2021. https://www.artima.com/articles/python-and-the-programmer.

Wang, C.-I. 1990. “Obtaining Lazy Evaluation with Continuations in Scheme.” Information Processing Letters 35 (2): 93–97.

Warren, D. H. D. 1983. “An Abstract Prolog Instruction Set,” Technical Note 309. Menlo Park, CA: SRI International.

Watkin, J. L., A. C. Volk, and S. Perugini. 2019. “An Introduction to Declarative Programming in CLIPS and PROLOG.” In Proceedings of the 17th International Conference on Scientific Computing (CSC), edited by H. R. Arabnia, L. Deligiannidis, M. R. Grimaila, D. D. Hodson, and F. G. Tinetti, 105–111. Computer Science Research, Education, and Applications Press (Publication of the World Congress in Computer Science, Computer Engineering, and Applied Computing (CSCE)). CSREA Press. https://csce.ucmss.com/cr/books/2019/LFS/CSREA2019/CSC2488.pdf.

Webber, A. B. 2008. Formal Languages: A Practical Introduction. Wilsonville, OR: Franklin, Beedle and Associates.

Weinberg, G. M. 1988. The Psychology of Computer Programming. New York, NY: Van Nostrand Reinhold.

Wikström, Å. 1987. Functional Programming Using Standard ML. United Kingdom: Prentice Hall International.

Wright, A. 2010. “Type Theory Comes of Age.” Communications of the ACM 53 (2): 16–17.