# Lisp

> functional programming language based on the lambda calculus

**Wikidata**: [Q132874](https://www.wikidata.org/wiki/Q132874)  
**Wikipedia**: [English](https://en.wikipedia.org/wiki/Lisp_(programming_language))  
**Source**: https://4ort.xyz/entity/lisp

## Summary
Lisp is a functional programming language based on the lambda calculus, developed in 1958 by John McCarthy. It is one of the oldest high-level programming languages still in use and has been influential in the development of artificial intelligence and programming language theory. Known for its distinctive parenthetical syntax and powerful macro system, Lisp supports multiple programming paradigms including functional, procedural, and metaprogramming.

## Key Facts
- **Inception**: 1958
- **Developer**: John McCarthy
- **Also developed by**: Steve Russell
- **Paradigms supported**: Functional, procedural, reflective, metaprogramming, interpreted
- **Typing discipline**: Dynamic and strong typing
- **Key influences**: Information Processing Language (IPL)
- **Notable derivatives**: Maclisp, Clojure, AutoLISP, Hy, Nyquist
- **Primary use areas**: Artificial intelligence, computer programming, content analysis
- **Aliases**: LISt Processor, List Processing, LISP言語
- **Mascot**: The Lisp alien

## FAQs
### Q: Who created Lisp?
A: Lisp was created by John McCarthy in 1958. Steve Russell also contributed significantly to its early implementation.

### Q: What is Lisp used for?
A: Lisp is primarily used in artificial intelligence research, symbolic computation, and language design. Its flexibility makes it suitable for rapid prototyping and metaprogramming.

### Q: Is Lisp still used today?
A: Yes, although less mainstream than languages like Python or Java, Lisp continues to be used in specialized domains such as AI, financial modeling, and academic research. Modern dialects like Clojure maintain active communities.

## Why It Matters
Lisp holds historical and technical significance as one of the foundational languages of computer science. Designed at the intersection of mathematics and computation, it introduced concepts now central to modern programming—such as garbage collection, closures, and dynamic typing. Its influence can be seen across many contemporary languages and frameworks. In particular, Lisp played a pivotal role in early artificial intelligence projects and remains a reference point for language designers exploring new paradigms. Its homoiconic nature (code as data) enables powerful metaprogramming capabilities that continue to inspire innovation.

## Notable For
- Being among the first programming languages with automatic memory management (garbage collection).
- Introducing the concept of treating code as data through its uniform syntax and macro system.
- Serving as the foundation for numerous other programming languages, especially within the Lisp family.
- Having a long-standing association with artificial intelligence research since the late 1950s.
- Supporting multiple programming paradigms including functional, procedural, reflective, and metaprogramming styles.

## Body
### Origins and Development
Lisp was conceived by John McCarthy at MIT in 1958 and first implemented shortly thereafter. It emerged from his work on artificial intelligence and formal logic, aiming to create a practical tool for symbolic expression manipulation. The initial version was built on the IBM 704 computer using assembly language, with contributions from Steve Russell and others.

The theoretical underpinning of Lisp comes from Alonzo Church’s lambda calculus, which provides a mathematical framework for defining functions and computations. This gives Lisp its functional character and expressive power.

### Design Principles
Lisp's core design emphasizes:
- Homoiconicity – Code and data share the same representation.
- Extensibility via macros – Programs can generate and modify their own structure.
- Dynamic typing – Variables are not bound to types until runtime.
- First-class functions – Functions can be passed around like any other value.

These features make Lisp uniquely suited for tasks involving symbolic reasoning, pattern matching, and self-modifying programs.

### Major Dialects and Implementations
Over time, several major dialects have evolved:
- **Maclisp** (1960s–1980s): Developed at MIT, widely used in early AI labs.
- **Common Lisp** (standardized in 1984): A general-purpose successor consolidating earlier variants.
- **Scheme** (1975): Emphasizes minimalism and lexical scoping.
- **Clojure** (2007): Runs on the Java Virtual Machine and integrates well with modern ecosystems.
- **Hy** (2013): Combines Lisp syntax with Python interoperability.

Each dialect reflects evolving priorities while retaining core Lisp characteristics.

### Applications and Influence
Historically, Lisp powered landmark AI systems such as SHRDLU, Cyc, and early natural language processing tools. Today, it persists in niche but critical applications:
- Financial analytics platforms
- Rapid prototyping environments
- Domain-specific languages (DSLs)
- Educational settings emphasizing recursive thinking

Its legacy extends beyond direct usage; ideas pioneered in Lisp appear in JavaScript, Ruby, Rust, and even newer functional languages.

### Community and Resources
Lisp maintains vibrant online communities:
- Subreddit: r/lisp
- Stack Overflow tag: lisp
- GitHub topic: lisp
- Lemmy community: lisp@lemmy.ml

There are also dedicated conferences, libraries, and documentation hubs supporting both newcomers and seasoned practitioners.

## Schema Markup
```json
{
  "@context": "https://schema.org",
  "@type": "Thing",
  "name": "Lisp",
  "description": "Functional programming language based on the lambda calculus",
  "url": "https://en.wikipedia.org/wiki/Lisp_(programming_language)",
  "sameAs": [
    "https://www.wikidata.org/wiki/Q44564",
    "https://en.wikipedia.org/wiki/Lisp_(programming_language)"
  ],
  "additionalType": "ProgrammingLanguage"
}

## References

1. [Source](http://www-formal.stanford.edu/jmc/history/lisp/node3.html)
2. Integrated Authority File
3. [Source](http://www.dreamsongs.com/NewFiles/HOPL2-Uncut.pdf)
4. [Source](https://marketplace.sshopencloud.eu/tool-or-service/iheHw8)
5. [Source](http://jmc.stanford.edu/articles/lisp/lisp.pdf)
6. [Source](http://hdl.handle.net/1721.1/52234)
7. Freebase Data Dumps. 2013
8. YSO-Wikidata mapping project
9. BabelNet
10. Quora
11. National Library of Israel
12. KBpedia
13. GF WordNet
14. [OpenAlex](https://docs.openalex.org/download-snapshot/snapshot-data-format)