Ask HN: Why were people crazy about Lisp during 70s and 80s? | Hacker News Reader

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

5 pointsluizfzs8 comments

I'm reading Peter Siebel's Coders at Work and most of the interviewed people mentioned they worked with Lisp, wrote Lisp interpreters (this one I get why), doing so many things using Lisp. I'm sure that Lisp wasn't the only programming language at the time, as Fortan, Algol, Pascal, Prolog (very niche) existed at the time, but they are rarely mentioned.

So, it got me wondering why most of the interviewees where so interested in it. This is an honest question, from a person that has never used Lisp before.

View on HN

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.

The simplicity of LISP lists is indeed "incredible"

https://www.codeproject.com/Articles/1186940/Lisps-Mysteriou...

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/

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...

Regarding his book, yeah I saw that, but I hadn't considered that as a possible cause of my observation as well. Well pointed.

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.

I forget who, but I read some prominent CS guy from the 1970s who said that when he talked to Lisp enthusiasts, he would ask if they would still like the language if it were batch processed and their enthusiasm would dry up.

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.

Reply on news.ycombinator.com