Minds and Machines

, Volume 27, Issue 3, pp 449–472 | Cite as

AI and the Origins of the Functional Programming Language Style

  • Mark PriestleyEmail author


The Lisp programming language is often described as the first functional programming language and also as an important early AI language. In the history of functional programming, however, it occupies a rather anomalous position, as the circumstances of its development do not fit well with the widely accepted view that functional languages have been developed through a theoretically-inspired project of deriving practical programming languages from the lambda calculus. This paper examines the origins of Lisp in the early AI programming work of the mid-to-late 1950s, and in particular in the work of Allen Newell, Cliff Shaw and Herbert Simon. Their 1956 program, the Logic Theory Machine, introduced new ideas about data and program structures that were articulated in response to perceived limitations in existing programming technique. Later writers, notably John Backus, have described these features as constituting a “programming language style” distinct from the traditional style that preceded it. The paper examines the origins of the earlier style in practices of manual computation, analyses the key technical differences between it and the style first manifested in the Logic Theory Machine, and concludes that programming practice and experience play a large and underappreciated role in the development of programming styles and languages.


History of AI Functional programming Lisp Lambda calculus Logic theory machine IPL 



This paper originated in talks delivered at the CiE 2012 conference in Cambridge and the “Jornadas sobre Inteligencia Artificial y sociedad comtemporánea: El cometido de la información” at the University of A Coruña, in Ferrol, in March 2016. Thanks to John Tucker and Wenceslao J. Gonzalez for invitations to deliver these talks. A preliminary draft was discussed at a workshop on the Early Digital, held at the University of Siegen in 2016, and I would like to thank the workshop participants, and also David Nofre and the two anonymous referees, for many helpful comments and conversations.


  1. Backus, J. (1973). Programming language semantics and closed applicative languages. In Proceedings of the 1st annual ACM SIGACT-SIGPLAN symposium on principles of programming languages (pp. 71–86).Google Scholar
  2. 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.MathSciNetCrossRefzbMATHGoogle Scholar
  3. Backus, J. (1981). The history of FORTRAN I, II, and III. In Wexelblat, 1981, 25–45.Google Scholar
  4. Bartik, J. J. (2013). Pioneer programmer. Kirksville: Truman State University Press.Google Scholar
  5. Benington, H. D. (1956). Production of large computer programs. In Symposium on advanced programming methods for digital computers, ONR Symposium Report ACR-15, 15–28. (Office of Naval Research, Washington, DC, June 28-9, 1956.)Google Scholar
  6. Benington, H. D. (1983). Production of large computer programs. Annals of the History of Computing, 5(4), 350–361.CrossRefGoogle Scholar
  7. Black, F. (1964). Styles of programming in LISP. In E. C. Berkeley & D. G. Bobrow (Eds.), The programming language LISP: Its operation and applications (pp. 96–107). Cambridge: MIT Press.Google Scholar
  8. Boden, M. A. (2006). Mind as machine: A history of cognitive science (Vol. 2). Oxford: Oxford University Press.Google Scholar
  9. Campbell-Kelly, M., Croarken, M., Flood, R., & Robson, E. (2003). The history of mathematical tables: From Sumer to spreadsheets. Oxford: Oxford University Press.CrossRefzbMATHGoogle Scholar
  10. Church, A. (1941). The calculi of lambda-conversion. (Annals of Mathematics Series, Number 6, Princeton: Princeton University Press.)Google Scholar
  11. Curry, H. B. (1949). On the composition of programs for automatic computing. (Naval Ordnance Laboratory Memorandum 9805, 26 January 1949).Google Scholar
  12. Curry, H. B., & Wyatt, W. A. (1946). A study of inverse interpolation of the Eniac. (Ballistic Research Laboratory, Aberdeen Proving Ground, MD. Report No. 615. 19 August, 1946.)Google Scholar
  13. Dinneen, G. P. (1955). Programming pattern recognition. In Proceedings of the Western Joint Computer Conference (pp. 94–100).Google Scholar
  14. Feigenbaum, E. A., & Feldman, J. (Eds.). (1963). Computers and thought. New York: McGraw-Hill.zbMATHGoogle Scholar
  15. Floyd, R. W. (1979). The paradigms of programming. Communications of the ACM, 22(8), 455–460.CrossRefGoogle Scholar
  16. Gelernter, H., Hansen, J. R., & Gerberich, C. L. (1960). A Fortran-compiled list-processing language. Journal of the ACM, 7(2), 87–101.CrossRefzbMATHGoogle Scholar
  17. Goldstine, H. H., von Neumann, J. (1947). Planning and coding of problems for an electronic computing instrument. Part II, Volume 1. (Institute of Advanced Study, NJ. 1 April, 1947.)Google Scholar
  18. Grattan-Guinness, I. (1990). Work for the hairdressers: The production of de Prony’s logarithmic and trigonometric tables. Annals of the History of Computing, 12(3), 177–185.CrossRefzbMATHGoogle Scholar
  19. Grier, D. A. (2005). When computers were human. Princeton: Princeton University Press.Google Scholar
  20. Haigh, T., Priestley, M., & Rope, C. (2016). ENIAC in action: Making and remaking the modern computer. Cambridge: MIT Press.Google Scholar
  21. Harvard. (1946). A manual of operation for the Automatic Sequence Controlled Calculator. Cambridge: Harvard University Press.Google Scholar
  22. Hudak, P. (1989). Conception, evolution, and application of functional programming languages. ACM Computing Surveys, 21(3), 359–411.CrossRefGoogle Scholar
  23. Hughes, T. P. (1998). Rescuing prometheus. New York: Pantheon.Google Scholar
  24. IBM. (1956). The FORTRAN automatic coding system for the IBM 704 EDPM: Programmer’s reference manual. (Applied Science Division and Programming Research Dept., IBM: New York, NY, October 15, 1956.)Google Scholar
  25. IBM. (1958). Reference manual: FORTRAN II for the IBM 704 data processing system. New York: IBM.Google Scholar
  26. Kernighan, B., & Plauger, P. J. (1974). The elements of programming style. Reading: Addison-Wesley, Second edition: 1978.Google Scholar
  27. Lubkin, S. (1947). Proposed programming for the EDVAC. (Moore School of Electrical Engineering, Office of the Director Records, 1931–1948, UPD 8.4, University of Pennsylvania Archives and Records, box 8.)Google Scholar
  28. McCarthy, J. (1959). Letter to the editor. Communications of the ACM, 2(8), 2–3.CrossRefzbMATHGoogle Scholar
  29. McCarthy, J. (1960). Recursive functions of symbolic expressions and their computation by machine: Part I. Communications of the ACM, 3(4), 184–195.CrossRefzbMATHGoogle Scholar
  30. McCarthy, J. (1981). History of LISP. In Wexelblat, 1981, 173–194.Google Scholar
  31. McCarthy, J., Minsky, M. L., Rochester, N., & Shannon C. E. (1955) A proposal for the Dartmouth summer research project on artificial intelligence. (Dartmouth College, 31 August, 1955.)Google Scholar
  32. McCorduck, P. (2004). Machines who think. (A. K. Peters, Natick, MA.)Google Scholar
  33. Merton, R. C., & Scholes, M. S. (1995). Fischer black. The Journal of Finance, 50(5), 1359–1370.CrossRefGoogle Scholar
  34. Newell, A. (1954). The chess machine: An example of dealing with a complex task by adaptation. (RAND Corporation, report P-620, 28 December, 1954.)Google Scholar
  35. Newell, A., & Shaw, J. C. (1957). Programming the logic theory machine. In Proceedings of the western joint computer conference: Techniques for reliability (pp. 230–240).Google Scholar
  36. Newell, A., Shaw, J. C., & Simon, H. A. (1958). Report on a general problem-solving program. (RAND Corporation, report P-1584, 30 December, 1958. Revised 9 Feb 1959.)Google Scholar
  37. Newell, A., & Simon, H. A. (1956a). Current developments in complex information processing. (RAND Corporation, report P-850, 1 May, 1956.)Google Scholar
  38. Newell, A., & Simon, H. A. (1956b). The Logic Theory Machine: A complex information processing system. IRE Transactions on Information Theory, 2(3), 61–79.CrossRefGoogle Scholar
  39. Newell, A., & Tonge, F. M. (1960). An introduction to Information Processing Language V. Communications of the ACM, 3(4), 205–211.MathSciNetCrossRefzbMATHGoogle Scholar
  40. Priestley, M. (2008). Logic and the development of programming languages, 19301975. (PhD thesis, University of London).Google Scholar
  41. Priestley, M. (2011). A science of operations: Machines, logic and the invention of programming. London: Springer.CrossRefzbMATHGoogle Scholar
  42. Rosen, S. (1967). Programming systems and languages. New York: McGraw-Hill.zbMATHGoogle Scholar
  43. Sakoda, J. M. (1974). Structured programming in FORTRAN. ACM SIGSOC Bulletin, 6(1), 12–16.CrossRefGoogle Scholar
  44. Sammet, J. (1969). Programming languages: History and fundamentals. Upper Saddle River: Prentice-Hall.zbMATHGoogle Scholar
  45. Sammet, J. (1971). Application of extensible languages to specialized application languages. ACM SIGPLAN Notices, 6(12), 141–143.CrossRefGoogle Scholar
  46. Sammet, J (1972). An overview of programming languages for specialized application areas. In AFIPS ‘72 (Spring) Proceedings of the May 1618, 1972, Spring joint computer conference (pp. 299–311).Google Scholar
  47. Selfridge, O. G. (1955). Pattern recognition and modern computers. In Proceedings of the western joint computer conference (pp. 91–93).Google Scholar
  48. Simon, H. A. (1962). The architecture of complexity. Proceedings of the American Philosophical Society, 106(6), 467–482.Google Scholar
  49. Stoyan, H. (1984). Early LISP History (1956–1959). In Proceedings of the 1984 ACM symposium on LISP and functional programming (pp. 299–310).Google Scholar
  50. Turner, D. A. (2012). Some history of functional programming languages. In 13th International symposium on trends in functional programming. (Paper available at Accessed February 28, 2017.)
  51. Van Gelder, A. (1977). Structured programming in Cobol: An approach for application programmers. Communications of the ACM, 20(1), 2–12.CrossRefzbMATHGoogle Scholar
  52. Van Roy, P. (2009). Programming paradigms for dummies: What every programmer should know. (Paper available at Accessed February 28, 2017.)
  53. Wexelblat, R. L. (Ed.). (1981). History of programming languages. New York: Academic Press.zbMATHGoogle Scholar
  54. Wilkes, M. V., Wheeler, D. J., & Gill, S. (1951). The preparation of programs for an electronic digital computer. Reading: Addison-Wesley.zbMATHGoogle Scholar

Copyright information

© Springer Science+Business Media Dordrecht 2017

Authors and Affiliations

  1. 1.3 Thurlestone RoadLondonUK

Personalised recommendations