What is Lisp

Lisp (short for "LISt Processing") is a family of programming languages, originally developed in the late 1950s by John McCarthy. Known for its unique, parenthesis-heavy syntax and powerful features for symbolic computation and recursive functions, Lisp has been influential in artificial intelligence research and the development of programming language theory.

Lisp's semantics revolve around the evaluation of S-expressions. Every expression in Lisp is either an atom or a list. Atoms (like numbers or symbols) evaluate to themselves or their bound values. Lists generally represent function applications, where the first element is interpreted as the function and the remaining elements as its arguments. The language embraces the idea that code and data share the same form—lists—enabling powerful metaprogramming through constructs like macros. Additionally, Lisp supports first-class functions and dynamic or lexical scoping rules that determine how variables are bound to values during evaluation.

One might argue against striving for a rigid understanding of Lisp’s semantics because its strength lies precisely in its flexibility. Lisp blurs the line between code and data, encouraging a dynamic, experimental approach rather than a fixed, formal interpretation. By attempting to pin down its semantics too strictly, we risk overlooking the language’s creative potential—its power to let programmers redefine and extend its behavior programmatically. In this view, embracing the fluid, context-dependent nature of Lisp can be more fruitful than constraining it within narrowly defined semantic rules.

In Lisp, side effects—including API calls—are handled through standard function calls that, when evaluated, interact with the external world. While Lisp expressions are evaluated uniformly (with both pure and effectful functions treated as expressions), the language allows programmers to deliberately introduce side effects. There’s no enforced separation like in languages with a strict purity model; instead, functions that perform operations such as API calls simply produce effects as part of their execution, and it is up to the programmer to manage and order these operations as needed.

Lisp is a family of languages that emphasizes minimalistic and flexible syntactic constructs (S-expressions) and powerful metaprogramming via macros. It blurs the line between code and data, encouraging creative, dynamic redefinition of language behavior. In contrast, Elixir embraces functional programming with strong influences from Erlang. It is designed with immutability, concurrency, and fault-tolerance in mind—features that promote clear separation between pure computations and side effects. Philosophically, Lisp offers expressive freedom and adaptability at the potential cost of predictable structure, while Elixir prioritizes explicit management of side effects, robust concurrency, and reliability, embedding these values into its design.