LISP

Lisp (historically, LISP) is a family of computer programming languages with a long history and a distinctive, fully parenthesized Polish prefix notation.[1] Originally specified in 1958, Lisp is the second-oldest high-level programming language in widespread use today; only Fortran is older (by one year). Like Fortran, Lisp has changed a great deal since its early days, and a number of dialects have existed over its history. Today, the most widely known general-purpose Lisp dialects are Common Lisp and Scheme. Lisp was originally created as a practical mathematical notation for computer programs, influenced by the notation of Alonzo Church’s lambda calculus. It quickly became the favored programming language for artificial intelligence (AI) research. As one of the earliest programming languages, Lisp pioneered many ideas in computer science, including tree data structures, automatic storage management, dynamic typing, conditionals, higher-order functions, recursion, and the self-hosting compiler.[2] The name LISP derives from ”LISt Processing”. Linked lists are one of Lisp language’s major data structures, and Lisp source code is itself made up of lists. As a result, Lisp programs can manipulate source code as a data structure, giving rise to the macro systems that allow programmers to create new syntax or even new domain-specific languages embedded in Lisp. The interchangeability of code and data also gives Lisp its instantly recognizable syntax. All program code is written as s-expressions, or parenthesized lists. A function call or syntactic form is written as a list with the function or operator’s name first, and the arguments following; for instance, a function f that takes three arguments might be called using (f arg1 arg2 arg3).


References in zbMATH (referenced in 126 articles , 1 standard article )

Showing results 81 to 100 of 126.
Sorted by year (citations)
  1. Pippenger, Nicholas: Pure versus impure Lisp. (1997) ioport
  2. Bielli, Maurizio; Reverberi, Pierfrancesco: New operations research and artificial intelligence approaches to traffic engineering problems (1996)
  3. Clark, A. N.: Formal basis for the refinement of rule based transition systems (1996)
  4. Hohl, Hubertus; Boecker, Heinz-Dieter; Gunzenhaeuser, Rul: Hypadapter: An adaptive hypertext system for exploratory learning and programming. (1996) ioport
  5. Hohl, Hubertus; Boecker, Heinz-Dieter; Gunzenhaeuser, Rul: Hypadapter: An adaptive hypertext system for exploratory learning and programming. (1996) ioport
  6. Tung, Sho Huan Simon; Dybvig, R. Kent: Reliable interactive programming with modules. (1996) ioport
  7. Aït-Kaci, Hassan; Garrigue, Jacques: Label-selective (\lambda)-calculus syntax and confluence (1995)
  8. Boyer, R. S.; Kaufmann, M.; Moore, J. S.: The Boyer-Moore theorem prover and its interactive enhancement (1995) ioport
  9. Chakravarthy, Sharma: Architectures and monitoring techniques for active databases: An evaluation (1995)
  10. Raman, T. V.; Gries, David: Audio formatting - making spoken text and math comprehensible. (1995) ioport
  11. Abadi, Martin: Baby Modula-3 and a theory of objects (1994)
  12. Guida, Giovanni; Tasso, Carlo: Design and development of knowledge-based systems. From life cycle to methodology (1994)
  13. Lopez, Gus; Freeman-Benson, Bjorn; Borning, Alan: Kaleidoscope: A constraint imperative programming language (1994)
  14. Nakano, Hiroshi: A constructive logic behind the catch and throw mechanism (1994)
  15. Russinoff, David M.: A mechanically verified incremental garbage collector (1994)
  16. Russinoff, David M.: A mechanically verified incremental garbage collector. (1994) ioport
  17. Tang, Yan Mei; Jouvelot, Pierre: Separate abstract interpretation for control-flow analysis (1994)
  18. Walther, Christoph: On proving the termination of algorithms by machine (1994)
  19. Praehofer, H.; Auernig, F.; Reisinger, G.: An environment for DEVS-based multiformalism simulation in common lisp/CLOS (1993)
  20. Fateman, Richard J.: A review of Mathematica (1992)