Ask HN: Why were people crazy about Lisp during 70s and 80s?

Lisp was at the forefront of many high-level programming techniques that we take for granted today. The most popular of which, is functional programming: the concept of closures (the "data" that is packaged with a function as a concept), which leads to lambda, scoping rules and the like.

-----

The other part of Lisp, which is IMO highly underrated, is the purity of "List-Programming", the CAR / CDR data structure that is truly universal.

You can represent arrays, lists, sets, trees, graphs, and... basically everything... with garbage-collected CAR/CDR pairs.

Its a bit inefficient (especially on today's architectures), but the supreme flexibility of the "Lisp list", (aka: a linked-list-like CAR/CDR pair) is incredible.

Back in the days before standard libraries, Python-dictionaries, and the like, having a singular, consistent data-structure that was reasonably efficient in many use-cases (at the time CAR/CDR pairs were very efficient to traverse, not so much today anymore), and flexible for pretty much all problems in existence is a pretty neat trick.

-------

There are a few tricks that didn't really stick. Symbolic computation, with "quote" symbols and the like, was popular for compiler writers / macros, but I don't think its really come out into the greater programming community. Continuations, CLOS / Multiple-dispatch based OOP, and other features were also experimented with the Lisp community and are cool to think about but not really used outside of Lisp circles yet.

Fortran was used for numeric domains. Algol was dead. Pascal was used in education and on early personal computers (for example at Apple). Prolog was very niche.

Lisp was used in education, as an early Functional Programming language and in symbolic AI. The latter had a considerable hype then.

Note also that Peter Seibel wrote an influential Common Lisp book, so the choice of people might have been influenced by the author...

At that time, most people programmed in static, compiled languages like Fortran, C, or Pascal. If you wanted a powerful dynamic language with an interactive REPL and garbage collection, Lisp was almost the only choice. Since then, those attractive features of Lisp have been incorporated into many other popular languages: Python, Javascript, Ruby, etc. etc.

Scheme / LISP was a standard in academic CS for serious theoretical & AI work. FORTRAN, C, Pascal were more like tools for simulations, networks and building user facing applications. I really think it's as simple as that, more than any inherent design features of languages themselves. It comes down to influence and community and taste. We can see it now in real time with the adoption of Julia. Is it the "best" language for science / HPC? Perhaps not, but at some point it simply becomes a "norm". And a major part of that process is introducing the language to incoming students ;)

Intro to Computational Thinking in Julia

https://computationalthinking.mit.edu/Fall20/

Just as modern static languages date back to 1950s FORTRAN, dynamic languages date back to 1950s LISP.

Today a person who uses LISP might use Python, TCL, Node.js, Lua, etc.

Despite attempts (Algol, Ada, ...), there wasn't really a portable language for general systems programming until C came along. FORTRAN and COBOL were designed for specific application domains. Pascal was intended for education although I thought Borland's Turbo Pascal was better than C for real work in 1990.