
Ask HN: Who is using Common Lisp? - endswapper
What&#x2F;why?
======
jonjacky
At the University of Washington Medical Center (UWMC) we are using a DICOM
server written in Common Lisp [1]. DICOM is a network protocol used for
medical images and other medical data. This was originally developed as part
of the Prism radiation therapy treatment planning system [2][3], which was
completely written in Common Lisp, and was used as the sole planning system at
UWMC for many years.

1\.
[https://dl.acm.org/citation.cfm?id=963921](https://dl.acm.org/citation.cfm?id=963921)

2\.
[https://www.ischool.utexas.edu/~ml/papers/lisp40yrs.pdf](https://www.ischool.utexas.edu/~ml/papers/lisp40yrs.pdf)

3\.
[https://www.redjournal.org/article/S0360-3016(96)00322-7/abs...](https://www.redjournal.org/article/S0360-3016\(96\)00322-7/abstract)

------
reikonomusha
Rigetti Computing [1] uses it for a variety of their projects, including their
high-performance quantum computer simulator called the QVM [2], and their
quantum compiler.

Some of their use of Lisp has been presented in more detail at the European
Lisp Symposium. You can see it in the Cutting Edge section of the proceedings
[3].

[1] [https://www.rigetti.com](https://www.rigetti.com)

[2] [https://youtu.be/f9vRcSAneiw](https://youtu.be/f9vRcSAneiw)

[3] [https://www.european-lisp-
symposium.org/static/proceedings/2...](https://www.european-lisp-
symposium.org/static/proceedings/2018.pdf)

~~~
rurban
Then you should mention Grammarly, with about 10 million users per day. Orbitz
has similar numbers.

------
abrax3141
A month ago I built an entire working MVP for a cloud-based biomedical
knowledge management, discussion, and decision-making system, entirely in CL
(ccl), using raw HTML, down to the metal, in a week. And we went from MVP to
mid-VP (near beta) in another three days, and were running live user
experiments at the end of that week. ~2000 lines of CL. One.5 weeks' work. MVP
NLP and ontology management, discussion management, role management.

Yes, I'm for hire! :-)

ps. That was a month ago. What I've done in the meantime, aside from wind
surf, is build the AI underneath that -- another 2000 lines of working CL.
Lisp Rules!

~~~
endswapper
What is the best way to contact you?

~~~
abrax3141
Post a gig (free!) on SFCL...uh, that's SF CraigsList (not SF Common Lisp :-)
If it looks interesting, I'll answer it. If I don't, you're likely to get
other reasonable folks answering it. (Only reasonable folks answer Lisp job
ads, because only reasonable folks know Lisp; It's not like Python where kids
who have one high school python course are applying for jobs!)

~~~
abrax3141
Haha...a friend of mine, reading the above over my shoulder, reminded me that
there are, like, two complete a-holes over on comp.lang.lisp who long ago
drove everyone else away. (Usenet is pretty much dead anyway, but these folks
hastened the early demise of c.l.l as a useful forum, even before the rest of
usenet folded to Stack Overflow.)

------
brunjact
SISCOG [1] uses on all their products. Actually they use Allegro CL from
Franz. [2]

The main reason (for still using it) being that it all started out as an end
of college project, by the two CEOs, around Artificial Intelligence proof-of-
concept-general-tools (so to say) until the big breakthrough for danish
railway company, NS, which was impressed with their fleet scheduling project.
This adventure began in the late 80's and they were using Lisp Machines!

I suppose the reason for still using Lisp to be a mix of i. there is no
technological necessity to change; ii. the codebase of existing products is
too big to translate; iii. CTOs don't have enough knowledge on other
technologies to evaluate the feasibility of a change; iv. many of the
developers actually love Lisp :-).

Most of the support technology is also done in-house and they don't tend to
use many external libraries.

1\. [http://siscog.eu/](http://siscog.eu/)

2\. [https://franz.com/products/allegro-common-
lisp/](https://franz.com/products/allegro-common-lisp/)

~~~
lispm
Planning and Scheduling is a domain where Lisp has historically seen a lot of
applications. For example the planner for the use of the Hubble Space
Telescope (and many other telescopes in space and on earth) was originally
developed on TI Lisp Machines and later ported to Common Lisp on other
platforms. Generally there were a bunch of Lisp-based planners for space
operations (like payload planning for Space Shuttles or planner for mars
operations). There were a bunch of Lisp-based planner application in military
- with the most famous being the DART system - which was used for planning the
logistics for the first gulf war and saved more money that the US had ever
invested in AI research up to that point in the past 30 years. With field-
deployed Common Lisp applications in the middle-east, talking to remote
servers.
[https://en.wikipedia.org/wiki/Dynamic_Analysis_and_Replannin...](https://en.wikipedia.org/wiki/Dynamic_Analysis_and_Replanning_Tool)

~~~
brunjact
Indeed. As for space exploration goes I don't remember if it was The Martian
or Interstellar which mentions Nasa's Jet Propulsion Lab (JPL). And from there
I found this nice article about Lisping at JPL, by Ron Garret [1]. I think
it's an enjoyable reading.

1\. [http://flownet.com/gat/jpl-lisp.html](http://flownet.com/gat/jpl-
lisp.html)

~~~
lispm
[https://franz.com/success/customer_apps/scheduling/nasa.lhtm...](https://franz.com/success/customer_apps/scheduling/nasa.lhtml)

~~~
brunjact
Wow!!! I had no idea. Thanks for the link. :-)

------
aidenn0
I want to echo Grue3[1] that the tooling around common lisp is amazing; some
tools I've used are better at one level of abstraction, but none are as good
all up and down the levels of abstraction. Very few languages (smalltalk comes
to mind) have the culture of caring about tools.

A lot of other features that are great about lisp have become mainstream in
the 15 years since I learned lisp.

Or to put it another way, python feels like a slow lisp implementation with a
friendlier syntax[2], a large standard library, and poor metaprogramming
support[3].

1:
[https://news.ycombinator.com/item?id=17617889](https://news.ycombinator.com/item?id=17617889)

2: Some lispers will be annoyed by me calling python's syntax "friendlier"
than lisps, but it seems to me to be true, inasmuch as this can be objective.

3: One major reason for lisp's syntax has persisted is how easy it makes
metaprogramming. Once you've learned the basics of lisp, I can explain to you
how Common Lisp's macro system works in under 5 minutes. The ratio of
power/simplicity of it is really astounding.

~~~
jjtheblunt
python friendlier? just kinda different, i'd say, like algol-ier

------
andyhd
I'm planning to write a game for Ludum Dare 42 using SBCL and clopengl. I
wrote a simple Asteroids game way back with SDL
([https://github.com/andyhd/asteroids](https://github.com/andyhd/asteroids)),
but I haven't had much opportunity to use CL since then. I find Lisp is the
most enjoyable language to write in, because it has such minimal syntax, but
is incredibly flexible.

------
Grue3
I'm using Common Lisp for all my personal projects
([https://ichi.moe](https://ichi.moe) is the biggest one). I find it the
easiest language to develop in, because of the tooling (SLIME), language
features (CLOS, macros), and it fits my mental model the best. Granted I've
been using it for a very long time, so maybe I'm just more familiar with it.

~~~
yoklov
I have no real opinion on the tech stack (beyond being glad that it works for
you), but this is very cool, and is something I've looked for in the past,
unsuccessfully.

~~~
yorwba
For something a bit more mature, you might also like
[https://jisho.org](https://jisho.org) , which uses the venerable MeCab [1]
for morphological analysis, instead of the apparently homegrown system of
ichi.moe, and also incorporates a lot of other resources.

[1] [http://taku910.github.io/mecab/](http://taku910.github.io/mecab/) , also
available as a Debian package

~~~
Grue3
Except Jisho obviously produces worse results on pretty much any non-trivial
sentence. Sure, I wrote my own segmenter because everyone else's wasn't good
enough, that's a feature not a downside.

~~~
yorwba
Can you give an example?

~~~
Grue3
Just a few deficiencies that I found:

1\. Jisho can't really do conjugations. It only says "X could possibly be an
inflection of Y with these forms" based on the ending of the verb. For example
邪推してしまう becomes

邪推してしまう could be an inflection of 邪推する, with these forms: Te-form. It is a
connective form of the verb, usually called the gerund.

As you can see it only saw "邪推して" and ignored all the rest. ichi.moe always
fully parses each conjugation.

2\. Jisho can't handle when words are spelled in kana, unless the word is
specifically marked as "usually kana". For example when parsing a sentence
"ヤバそうなはなしを聞いた", the word "ヤバそう" is not recognized at all, and "なはなし" is parsed
as "なは"+"なし". ichi.moe can often handle such spellings.

3\. It splits expressions like "いざとなったら" in "いざとなったら勇気が無くなった" (despite the
word obviously being present in their dictionary) and the meaning of the
expression can be hard to guess from the components.

Considering their segmenter apparently last updated in 2013 there's little
hope this will ever improve.

~~~
yorwba
When I do _echo '邪推してしまう' | mecab_ I get

    
    
      邪推	名詞,サ変名詞,*,*,邪推,じゃすい,代表表記:邪推/じゃすい カテゴリ:抽象物
      して	動詞,*,サ変動詞,タ系連用テ形,する,して,代表表記:する/する 付属動詞候補（基本） 自他動詞:自:成る/なる
      しまう	接尾辞,動詞性接尾辞,子音動詞ワ行,基本形,しまう,しまう,連語
      EOS
    

and I have no idea why jisho.org completely ignores the しまう.

The other problems do seem to be related to the segmentation approach MeCab
takes. I've usually found it to be satisfactory, but maybe I just haven't been
looking hard enough for errors. I might try and see how well your Ichiran
works as a replacement. Thanks!

------
aryamaan
Slightly off the topic: if I have to start using Lisp now, how do I start? I
tried curating things on my own but felt overwhelmed with the alternatives and
resources.

Will appreciate your take on this.

~~~
TurboHaskal
Best beginners book
[http://www.gigamonkeys.com/book/](http://www.gigamonkeys.com/book/)

Curated library list [https://awesome-cl.com](https://awesome-cl.com)

Cookbook [https://lispcookbook.github.io/cl-
cookbook/](https://lispcookbook.github.io/cl-cookbook/)

IDE+Runtime [https://portacle.github.io](https://portacle.github.io)

Printable cheatsheet [http://clqr.boundp.org](http://clqr.boundp.org)

------
spacemanmatt
The venerable pgloader ([https://pgloader.io/](https://pgloader.io/)) is
written/maintained in CL. It's pretty cool.

------
kingherring
I'm using Common Lisp for a program I wrote called simple-content-host. I'm
connecting Common Lisp and C++17 to create a tiny CDN! Not only that, but I
stream my programming live on Twitch and youtube, check it out:
[https://youtu.be/hWmrSyWZS5A](https://youtu.be/hWmrSyWZS5A)
[https://www.twitch.tv/kingherring](https://www.twitch.tv/kingherring)

P.S. here's the code [https://github.com/kennymalac/simple-content-
host/tree/maste...](https://github.com/kennymalac/simple-content-
host/tree/master/src/program) ;)

------
borodust
A lot of us at #lispgames[1][2] community using it to make games and related
tools. We have a bunch of awesome libraries and wrappers, few game
engines/frameworks (3D/2D alike) in development, games too!

Reasons we all chose Common Lisp are often personal, but almost all agree it
is the superior interactivity, high language and runtime customizability,
performance.

[1]:
[https://github.com/lispgames/lispgames.github.io/wiki](https://github.com/lispgames/lispgames.github.io/wiki)
(lispgames.org)

[2]: #lispgames channel at freenode.net

------
pjmlp
SISCOG, a Portuguese company, uses Common Lisp on their planning software.

[http://www.siscog.eu/](http://www.siscog.eu/)

[http://www.siscog.eu/upload/GESTAO-DE-
LISTAS/News/PDF/eclm-2...](http://www.siscog.eu/upload/GESTAO-DE-
LISTAS/News/PDF/eclm-2013-siscog-a-story-written-in-lisp-20130602.pdf)

If you feel like enjoying Lisbon or Porto's weather, they are hiring.

------
Sodaware
It's nothing major, but I built a simple web scraper for collecting
screenshots from various forums and then creating a static site from it.

I've also used it to build small tools like generating project documentation
or collating data from online api's.

Emacs was my gateway (via org mode) and I messed around with Emacs lisp for a
while before learning Common Lisp. Developing in Emacs + SLIME is a lot of fun
once I get in the rhythm.

------
wglb
As part of a startup, I wrote an automated trading platform in SBCL Common
Lisp. It is about 70,000 lines.

I use lisp these days when hacking some automation around common tasks like
scraping web sites, extracting info from xlsx or rtf files, and producing
LaTeX documentation.

------
dpezely
FYI: there's currently a DNS problem for "sbcl.org", so instead, please use
what it ordinarily points to:

[https://sbcl.sourceforge.net/](https://sbcl.sourceforge.net/)

------
limeblack
I use clisp mainly with quicklisp. Lisp isn't rather unique and simple so I
have used it for an occasionally algorithm that is annoying any other way. Not
for the entire system typically.

~~~
pvaldes
Same, for small personal projects only. Drawing a quicklisp map for example:

[https://github.com/pablovaldes/quickdot](https://github.com/pablovaldes/quickdot)

You can find a picture example of the whole thing in the directory doc

------
yellowapple
Does using StumpWM count?

~~~
nextos
I think it does! The whole Lisp desktop is a step closer now: StumpWM, Emacs &
GuixSD.

~~~
mbrock
It’s kind of funny that those all use divergent versions of Lisp... :)

~~~
abrax3141
Doesn’t matter. That’s why it’s called “Common” Lisp. Any code will run on any
conformant CL.

~~~
linfocito
Fair point, but in the specific case the differences matter indeed. StumpWM is
coded and extensible in Common Lisp, while Emacs use Emacs Lisp and Guix is
built on Guile Scheme - both not CL conformant.

it's a very lispy stack, otherwise!

~~~
abrax3141
Ah. Yes. Right. But these aren’t Common Lisps. But you’ve indirectly brought
up another useful point, to wit, the general Lisp paradigm is so useful that
language designers regularly approximate it when building new platforms.
(Clojure is another.)

------
dpezely
I've brought or used CL in a few companies.

2005: At a bank dealing with mortgage secondary markets, we snuck it into the
Research group (where "research" isn't R&D but feeding information to the
trading floor) for plowing through dirty data from multiple databases before
our DBAs could make it available via Oracle. This hack helped keep the math &
stats PhDs’ pipelines full.

Rationale for using CL: because values have type rather than variables (but
may be asserted with CHECK-TYPE; see Google CL style guide), this essentially
gave us late-binding of schema.

2006: at Zillow, we were building autonomous server farm control at a time
when AWS still emerging. Unfortunately, two things happened at the same time.
1) There was a re-org in Ops leading to discontinuing contractors, so both of
us had a 2 weeks to finish it and finish early. 2) SBCL had just reached 1.0
after years in 0.x land. One modification in the run up to SBCL v1.0 that I
overlooked in the changelog was how bindings for special vars were handled
across threads. It required a trivial fix, but we didn't track that down
before time ran out-- oops!

Rationale for using CL: 2 guys still learning the language (one also working
on Masters) got lots of traction quickly.

2007: at an education administration start-up, same colleague as from Zillow
and I began working on a conceptual sibling to Amazon Dynamo, roughly when
their original white paper came out. In 5 weeks, we had an MVP; Kevin wrote
all the code, I helped with design and code reviews; it handled arbitrary data
payloads and migration of data "ownership" by node. We were about to begin
multi-node load & capacity measurements when the business joined a Microsoft
incubator and removed all Unix-only folks.

Rationale for using CL: 2 guys, lots of traction quickly... plus, late binding
of schema via MOP tricks.

I would like to believe that parts of this continue as Kevin’s vivace-graph
despite being a very different animal.

2008: at a Seattle-based ad network (I still bear the shame...), the geek-
macho angle was that this is one of the few types of businesses likely to see
billions of requests per day. In 4 months, we were deployed at RackSpace and
completed baseline load & capacity measurements.

There was an issue with garbage-collection after Hunchentoot would release a
HTTP connection, because by the time FreeBSD would release the underlying
TCP/IP structs, several minutes would elapse before gc could reclaim
everything. Not ideal, but it was manageable!

Rationale for using CL: 1 guy, lots of traction, successful hand-off to new
hire (the guy who later brought Clojure to Amazon’s retail side of the house).

Bonus: local Angels and VC (Madrona) came to us but then came the economic
crash of 2008...

2009: recruited into Memetrics, a former startup that had been acquired by big
consulting firm, and the core software was already written in CL from nearly a
decade earlier. I was only in the core group briefly, but subsequent work
using CL was my default choice and already approved. (Then again, I didn’t ask
permission or beg forgiveness.) There were more dirty data cleaning tools and
a Recommender system from which China’s answer to Amazon became a client. Mind
you, they didn’t use this code, as they had their own, but it demonstrated
that our group understood the principles. I still count this as a win.

Rationale for selecting CL: was decided by folks in Sydney before I arrived.
Their head-hunter found me after their acquisition.

2013: Splunk acquired BugSense. BugSense used "Erlang, Lisp and C" (Scheme R4)
for handling billions of inbound requests per day non-stop from all time zones
into our cluster. While not CL, having previously gone sufficiently deep into
CL allowed me getting from zero to presenting at Erlang Factory conference in
exactly one year while reaching more than 25x performance increase with the
pure-Erlang rewrite.

Rationale for selecting Lisp by their founder: made for malleable query
language.

2015: wife wanted to move back to Canada after several years in Silicon
Valley. Resurrected a pet project circa 2007, snagz.net, and I attempted
founding a company. Back-end is CL for Natural Language Processing work-flow.
Core NLP things now use spaCy.io, because their NLP-fu is far better than my
self-taught version. Some intermediate working data sets were pushed into a
slightly modified Anarki fork of HN, partly to see what the Arc language was
about, and partly because that tool fit the (internal) need.

Rationale for selecting CL: Lisp is a beautiful language within which to work.

Others in and around Vancouver using CL: Routific mentions Rust and Common
Lisp in their job postings; D-Wave previously mentioned Lisp in job postings
but unable to see it today; there was at least one other, but I can’t recall.

In my early experience with Common Lisp, I would have said MACROS were key.

Then, pre-populating memory followed by #’sb-ext:save-lisp-and-die was a handy
trick for improving cold-start times. (Alternative to using POSIX mmap().)

Now, it’s simply the joy of writing code in the language.

First milestone: parens disappear, because using the right editor config means
never typing a single paren, and editing involves manipulating whole
expressions with fluid motion.

Second: thinking how a function _should_ be or _might_ be named, points to
something either in the HyperSpec or be the name of a package, thus easy
internet search. Today, there’s Quicklisp.org and Quickdocs.org, making this
even easier.

That said, I’m currently learning Rust and React-Native for a tiny mobile app,
as each language can teach you something new.

But something in the Lisp family will be with me for the rest of my days. I
might go with Racket next just to expand my knowledge there.

So I recommend: use Common Lisp for a real project-- just because you can!

------
kazinator
Tankan is a browser-based program for Windows for memorizing Japanese
characters.

[http://www.kylheku.com/tankan/](http://www.kylheku.com/tankan/)

It's written in Common Lisp, except for the little tray icon control program
that is in Visual C++.

------
jacobwilliamroy
I don't know what the relation is between common lisp and scheme but I use
R5RS (the S is for "scheme") mainly to program the GIMP to make it do batch
image-processing. Gimp also has a Python api, but I just find scheme to be
more accessible and user-friendly.

