The era when Lisp had its greatest commercial success (the 1980s) was a time when free (as in either beer or speech) high-quality development tools for any language were rare. This was the golden age of proprietary software; people were expected to pay for operating systems, compilers, editors, and other tools, and there was increasingly no expectation of having access to the source code. The GNU project was started in 1983 by Richard Stallman, who used to work on MIT Lisp projects (many of his colleagues became part of either Lisp Machines, Inc. or Symbolics, which all came from MIT’s work on Lisp machines).

Back to proprietary software, during the AI boom of the 1980s, Lisp machine vendors had success selling high-end workstations to customers willing to pay good money for Lisp environments. This dried up during the subsequent AI winter, though some customers were able to move their Common Lisp solutions to commercial Lisp implementations that worked on workstations or servers running Unix or Windows. But at this point Lisp no longer had the same level of commercial interest, though the legacy and mindshare of Lisp grew through the use of Scheme in CS education (e.g., SICP and the team that wrote PLT Scheme, which was renamed Racket) and the advocacy of Lisp from prominent developers and researchers like Paul Graham, Richard Stallman (Emacs), Eric S. Raymond, Alan Kay (while he’s of course a Smalltalker, he’s spoken fondly of LISP 1.5 and also of The Art of the Metaobject Protocol), and many others. There are also many people who used Symbolics Genera in particular and who speak highly of its development environment, sometimes expressing the sentiment that modern development environments don’t compare to it.

There are FOSS Common Lisp implementations with wide usage. The most notable is Steel Bank Common Lisp (SBCL), and I also hear of plenty of people using Armed Bear Common Lisp (ABCL, which runs on the Java virtual machine) and Embeddable Common Lisp (ECL). There are other FOSS Common Lisp implementations that I know less about.

Thanks, this is interesting. I always like to know more about the history of the tech I use.

Then I highly recommend the book "Hackers: Heroes of the Computer Revolution" [1]. It describes the hacker culture and the hackers behind a lot of things we use to this day, from the early 50s to the mid 80s.

[1] https://en.wikipedia.org/wiki/Hackers:_Heroes_of_the_Compute...

Thanks, I'll check it out.

Symbolics is actually the founding reason for Stallman becoming full Stallman and all of the free software / GPL thing.

I will throw makerlisp in there which is a hardware lisp from Luther Johnson.

Just use SBCL - https://www.sbcl.org/

Pick an editor: https://lispcookbook.github.io/cl-cookbook/editor-support.ht...

Good enough for games (and other commercial offerings) - https://kandria.com/

It's definitely good enough for Google: https://lisp-journey.gitlab.io/blog/yes-google-develops-comm...

ITA software is an acquisition, and I’m sure most of the Lisp development at Google is just done by engineers tweaking their .emacs files.

The problem of parsing data from airlines is fiendishly hard. There are a ton of different rules for how to calculate prices, and all sorts of deals and promotions that may affect a particular route on a particular day. If you have a system which can parse this data, then you wouldn’t want to rewrite it. I’ve read a number of articles about ITA Software’s Lisp code and it’s really interesting.

Lisp may be a critical part of ITA’s success, but “good enough for Google” is probably the wrong take here—Google, I’m sure, purchased a company to add its working product to their portfolio. I doubt that Google’s processes would allow someone to ale a new product in Lisp.

I meant SBCL specifically, not Common Lisp in general. They could have been using LispWorks or Allegro CL instead, but they aren't.

Can you share some of the articles you mentioned about ITA Software's Lisp code?

Keep in mind that the information is old.

http://www.paulgraham.com/carl.html

I’ve read other stories, and seen presentations, but the information is getting harder to find.

Realistically, "good enough for Google" is probably largely an accident of acquisition. QPX, the low airfare search engine, is not exactly a small piece of software. In c. 2007, it consisted of about 1 million lines of code divided unevenly between Common Lisp and C++, which, by then, had been developed for roughly a decade for the airline industry. Rewriting it would have been a non-trivial task.

Furthermore, Carl de Marcken, chief scientist/co-founder of ITA, had chosen Lisp because it was what he was most familiar with. He had told me in 2007 that if he had to choose a language again, he probably would have chosen Java, a choice Google would likely favor over Lisp.

I say this not to disparage Lisp—I enjoy Lisps, and I use Lisp professionally—but to contextualize this particular use of Lisp at Google.

EDIT: Just saw your reply to a sibling comment explaining that you meant SBCL, not Lisp per se.

See my other comment in this subthread.

>Pick and editor

Well, Emacs, SBCL and SLIME are like bread and butter for obvious reasons.

I’ve recently been enjoying using Alive with vscode(and copilot). Everyone suggests emacs+slime but it always felt like too many things to learn at once. Being able to use my usual ide has made it so much more pleasant. Recommend it to newcomers.

https://github.com/nobody-famous/alive

And you’ll get a pile of UNIX tools that are approximately nothing like Genera in actual use.

Yes, in that you can actually use such tools to rapidly develop and ship software that runs on consumer machines (even Windows). Or did you have a more interesting point?

The request was for an environment similar to Genera, not an optimal environment for deploying to consumer systems. While it may work quite well for the latter, it fails at the former.

I don't see how you read that from behnamoh's comment. The 'request' or rather confusion was that the only way to do Lisp, historically and now, is with proprietary stuff like Genera or more modernly LispWorks, so what's there to do if someone wants to get into it now. On the contrary, I pointed out if anyone wants to get into Lisp now, in 2023, there is also amazing free tooling that's very capable just like many other languages for building and doing the sorts of things people typically want to do in 2023. The only other part of the comment I didn't address was just my agreement that proprietary emphasis did hurt Lisp adoption, though not getting Quicklisp until as late as 2010 hurt it more. Things don't seem so gloomy now these last several years at least.

> if you wanna do Common lisp you have to pay for Lisp Works

Nothing could be further from the truth.

Could be part of the reason, but I think a bigger reason is that it's just not very pleasant to read. Syntax exists for a reason! Nobody really wants to hand-write an AST (or read it).

Imagine programming Python by writing out the AST in JSON. That's what Lisp looks like.

I guess it makes the parser really simple and elegant, but they definitely went way too far towards the programmer on the "make it simple for the programmer/user" spectrum.

I find lisp much nicer to read than most languages.

C/Java etc (which I was a professional in) have too many bits to the syntax - braces and semi-colons and the execution is not necessarily shown by the format.

I also like python for similar reasons.