Jach's personal blog

(Largely containing a mind-dump to myselves: past, present, and future)
Current favorite quote: "Supposedly smart people are weirdly ignorant of Bayes' Rule." William B Vogt, 2010

Thoughts on Writings on Lisp

As a Lisp poser I've spent many more hours reading things about Lisp than programming in Lisp. I use "about" pretty loosely here: sometimes it's just things written by important people in the Lisp community (living and dead) that aren't necessarily about Lisp directly.

So this post is mainly setup for me to accumulate some random references I find myself repeatedly referring to over the years. They're not necessarily the best or most important, my goal isn't to be anything approaching exhaustive either, the main inclusion criteria is whether I've linked the thing more than once to others. I've attached some off-the-cuff commentary to each thing, but much of it is just ranting. If anyone else finds this post at all valuable I'll be surprised!

I'll attempt to incrementally update this blog post over time.

Most recent addition: [48] (2024-07-18, prev 47@2022-02-04)


Lisp Community
Books, Papers
Random Cool Stuff, Experiments
Debugging, Optimization
Commercial Products That Exist/Existed, Production War Stories
Psychology, Smugness
Development and IDEs
Is X Lisp? Is X a Lisp?

Lisp Community

[0] Rondam Ramblings: My Dinner with Erik
I thought of this today while writing a post here about [1]. The relevant take at this time (more thoughts to be filled in later) is just that the two got heated online, had an offline dinner together, and that helped patch things up -- for a while. Perhaps if they had met again at another conference, things could have not soured so much? On the other hand, the author couldn't get another person to even talk, so, that possible side effect of conferences isn't a guarantee.

[1] CL Community(?) Norms
Thoughts here

[2] is community-related.


[4] History of Programming Languages - The Evolution of Lisp (uncut version, mostly about there being a cycle of diversification and consolidation)

Really good paper living up to its title. Though I don't think I've read the whole thing, I've read a lot of it randomly. It's one of those things I reference for why Common Lisp deserves the name Lisp, unqualified. Here's a semi-recent comment of mine, a reply, and another of my comments about that. I have another one somewhere on HN from many years prior. But I'm not actually that invested in the fight -- it's kinda been lost, long ago, so I'm more in the discussion for explaining why there was an argument to begin with, and why CL probably should have won.

I also love this paper for its "CL Conformance Test":

The inclusion of complex numbers in Common Lisp was also an inheritance from the S-1. This was something of a sticking point with Scott Fahlman. A running joke was an acceptance test for nascent Common Lisp implementations developed by Guy Steele. It was in three parts. First you type T; if it responds T, it passes part 1. Second, you define the factorial function and then calculate (/ (factorial 1000) (factorial 999)) If it responds 1000, it passes part 2. Third, you try (atanh -2). If it returns a complex number, it passes; extra credit if it returns the correct complex number. It was a long time before any Common Lisp implementation passed the third part. Steele broke an implementation or two on the trade show floor with this three-part test.

[28] lispm briefly on Common Lisp history

Just a really short blog post by Rainer on the creation and standardization of CL.

[26] Olin Shivers: History of T

Maybe should be part of the "Is X A Lisp?" section. First read the section on Scheme in [4] which includes a bit about T. How can it really be a Lisp when it broke so much from the Lisp tradition but also from the initial versions of Scheme? But surely the result had a sense of elegance to it anyway, even if it lacked features. What's lacking keyword arguments when you can type number? instead of numberp?

The full history is just really good story telling though. Lots of good lessons too, like how progress in GC eluded people for decades. (It sometimes still seems that way! Open Java has finally caught up with Azul's pauseless GC from ages ago...) Don't miss out on more details here that includes some errata but also just more great info, even some source code. Regardless of whether one thinks it counts as a "Lisp" or not, is it not very pretty and elegant? Shall we throw away this excellent meme just because it happens to use Scheme?

(What I see)/((((What (())(the) (((non-Lisper))) sees))())())

I often think the worst thing for Common Lisp adoption (I don't know if it's worst or just after "Condescending Smug Lisp Weenies") is the success of the excellent SICP book. Even if you only get a couple chapters in, you come away knowing some Scheme, thinking you know "Lisp", often agreeing that it's beautiful (but also often just hating the parens), but also that it's "impractical" because it didn't seem to have [feature x] that in fact CL had the whole time and older Lisps that consolidated into CL had too, and so you write it off.

[47] Stallman's Lisp Experiences and the Development of GNU Emacs
See also: Daniel Weinreb's Rebuttal to Stallman's story of Lisp history
See also: Sam Williams' "Free as in Freedom: Richard Stallman's Crusade for Free Software"

Why do I link these? Besides interesting history (and people's conflicting memories of it, and old wounds) I also like the stories as tales of Stallman's badassery as a programmer. Sometimes I feel like he doesn't get enough credit for his programming chops -- which sure, haven't been exercised like they once were, but that doesn't stop us from admiring Michael Jordan.

Like, his history with emacs is pretty well known, and then he was working on GNU, which involved duplicating and enhancing Unix stuff, then there was the war of Symbolics and Lisp Machine Inc. Stallman:

I began duplicating all of the improvements Symbolics had made to the Lisp machine system. I wrote the equivalent improvements again myself (i.e., the code was my own).

After a while, I came to the conclusion that it would be best if I didn't even look at their code. When they made a beta announcement that gave the release notes, I would see what the features were and then implement them. By the time they had a real release, I did too.

In this way, for two years, I prevented them from wiping out Lisp Machines Incorporated . . . Symbolics at one point protested to MIT that my work, by thwarting their plan, had cost Symbolics a million dollars.

What can you say to that other than badass? Well, Dan had some remarks for sure, with Moon affirming, and near the end of the comments a great bit of archival recovery from Steele. Dan needlessly lowers the technical difficulties of such a feat, claiming they were simple incremental improvements. Fine, makes sense to me that such a feat could only be done that way, and Stallman to my knowledge never copied the later big applications on top of the OS like the S-Graphics suite or Joshua or Concordia, still it's an impressive feat and we have code to look at if someone ever was to do a deep dive comparison... I also agree with Dan and don't think Symbolics was a bad scruple-less company as characterized (except maaaaaybe in the sense of perpetuating proprietary software even into the 90s which I think hurt Lisp quite a bit, but hey, companies and technologies just miss out on waves, sometimes they survive them, sometimes they don't).

The last link is just for another fun story (also referenced by Steele in the comments of the Dan post) about the Steele-rms mind-meld 10-hour pair programming session. I've done a bit of pair programming, nothing nearly that long and with no mind-melding, yet I always think about the story when pair programming comes up.

Books, Papers

[7] Practical Common Lisp

Really good reference. Probably good to go through cover-to-cover, but I haven't done so. My most referenced page is probably the format recipes one.

[31] Lisp 1.5 Manual

Good historical reference for what was Lisp, in production.

[33] Common Lisp the Language, 2nd Edition

The OG book on CL. Many instances it's resolved some confusions when the hyperspec or something else wasn't as clear. A lot of pre-standardization CL implementations were built off it (or the first edition) as reference, it's very thorough, even if the whole thing is a kludge.

[34] Paradigms of Artificial Intelligence Programming

Norvig's book is such a great Lisp book, independent of its AI content. Code is clean, written in a professional style, lots of information about the language. One day I'll go back and finish it!

[11] Condition Handling in the Lisp Language Family

My favorite writing explaining the overall useful conception of the condition system. I particularly like its little story about finding a fork in a road you don't commonly travel, not knowing what to do, raising a signal, and consulting various sources of wisdom that present themselves to see if any of them can act on your behalf.

[12] Exceptional Situations in Lisp

Another good Kent paper.

[30] The Structure of a Programming Language Revolution, or, Incommensurability is real

First of Gabriel's works on here! It's a really great philosophical paper but it also highlights an important difference in conceptions of programming languages with Lisp being almost more like a programming system than a language. COMPILE is built-in, not a separate program, such a wild concept is so rare. He also talks about the idea of "mixins" and how they meant a specific thing in the lineage of Lisp for quite some time, then some unrelated academics got a hold of the idea and changed it.

Generally everything written by rpg about programming is worth reading.

The notion on incommensurability is really the key issue though. It comes up even now in a lot of places. Yet another recent one I saw was a thread repeating the debate on whether Lisp is "untyped", whether "untyped" means "not statically typed". There's yet another reference I want to make about the curious lack of curiosity about exploring runtime data types vs compile-time types, but I don't remember it right now.

[38] Patterns of Software

Gabriel's book. Haven't finished it (maybe half way) but it's basically a collection of essays, I've enjoyed each one. Contains such interesting thoughts like inheritance in OOP mostly being about compression, not re-use or decomposition or any of the other typical attributions. Lots of unique thoughts, though very 'high level'.

[32] Common Lisp Quick Reference

Printable quick reference to keep by your side and study from.

[13] I Have a Feeling We're Not In Emerald City Anymore

Really amusing tongue-in-cheek explanation for the birth and existence of Ada. Baker's got a lot of nice papers.

Random Cool Stuff, Experiments

[15] Fun with Lisp: Programming the NES

Code more. More of this! It's badass.

But maybe not more of this? Lispers get dragged down proving Lisp can succeed in any environment, either by pointing to the past (3d graphics editors) or implementing one of these small proofs of concepts. I don't think that intent was here but the effect is the same anyway. Perhaps time would be better spent on making large things that are relevant for the present and near-future? (Perhaps time would be better spent by me not writing any of this post! Well, if I'm perceived as taking pot-shots at anyone, it's either equally a shot at myself or it's just a form of devil's advocate.) Every other language has these sorts of creative people in it, it's not a unique Lisp thing. Though the approaches certainly are unique. Same as in [16] or [17]. What makes these things great though is the accompanying thought process notes -- it's not just look at this cool thing artistically, but it's also a learning resource, and there are non-artistic reasons you might want to know how to do something like it.

[16] SBCL: the ultimate assembly code breadboard

Just the ultimate example of how Lisp can also be a super low level programming language, and not just a super high level language.

[36] Me referencing a few instances of using [] for syntax that isn't literal arrays

Just being lazy at this point instead of linking the refs here...

[37] The nest macro

A nice macro, it's available out of the box in uiop. The blog post gives a nice example of its value, how simple the implementation is (in CL), and how unsimple the implementation is in Scheme.

[44] cmu-infix

Basically a library that's been around since 1993 letting you write expressions in infix notation, e.g. #I(sqrt(a^^2 + b^^2)/2) I bring this up every time someone complains about how annoying it is to write math with prefix style. And yes, you can even have variables with dashes in them, you just have to escape them with a \.

Debugging, Optimization

[29] Debugging Lisp Part 1

My favorite short series on the experience of debugging in Lisp. Yes, it mostly is the same in vim.

[17] Going Faster with Lisp

Just another post I've bookmarked before. It's a nice journey into optimizing with Lisp.

[18] lispm comment on defclass/defstruct efficiency

Useful information linked from [17], relinked here. Lisp extracts a price for some of its fanciness, but there's typically tradeoffs you can make to take a different price.

[23] Is Scheme Faster than C?

Could be part of a series on optimization philosophy. The final line is the mindset: "Real efficiency comes from elegant solutions, not optimized programs. Optimization is always just a few correctness-preserving transformations away." In Lisp lore it's common to come across reports of not being able to have constructed a program without Lisp, this anecdote relates that in a very direct way of constructing a program, making it correct, making it faster (but still correct) in vanilla Scheme, and finally getting even more speed by translating it to C, gotos and all, that they could not have written.

I'm not sure I agree with the mindset for optimization, but perhaps it's just a semantics quibble. I would put it as real efficiency comes from understanding the hardware, the relationship of the data with the hardware, and how to process the data while maintaining mechanical sympathy with the hardware. Perhaps this is an "elegant" solution, but I don't really think it turns out very elegant a lot of the time. A good optimizer can do a lot though, with an elegant or unelegant program, even if it can't replace human intelligence.

At the time I read this I was also comparing to optimized Java, e.g. here. There are many other instances. Any real optimization problem experiment in a programming language should really compare the efforts across multiple languages. Last year it was quite amusing to watch a guy struggle to get a Rust program to beat a CL one, but at least what he was doing was a valuable example of hardcore optimization often being tough work, no matter the language, and that different languages (and different implementations of languages) make different things harder or easier.

Commercial Products That Exist/Existed, Production War Stories

[46] List of awesome application software built with Common Lisp

Sort of a cousin to awesome CL libraries, this is more a collection of software (commercial and otherwise) known to be using Lisp. There's another collection of companies. Useful quick answer to "What on earth even uses Lisp?" even if some of it isn't actually all that awesome, or some proprietary stuff that is known about isn't included. (And of course one can't include proprietary stuff that isn't known. Like one would need to ask the authors of something like SHOP3 how many customers used it before it was open sourced.)

[9] N-World 3.0 Online Documentation

References and tutorials for a 3D modeling/painting/animating/scripting tool. It's on my backburner to actually go through some of this for real -- I did get a version of N-World to work on a Windows NT VM. Like, you look at Blender, or just the concept of a 3D modeling tool, and you think, could this be in anything but C++? How about in the 90s, could it be anything but C and assembly? And yet Common Lisp was used in this domain, as in so many other domains. To suppose it can't once again be used is domains now assumed to be the last refuges of C++ is ludicrous.

The wiki page contains some unsourced claims but it's at least easy to verify its use for Mario and FF7 graphics. Of minor interest is this thread where I learned that one famous game did not in fact use it, and there's some useful history about how poorly it was demoed and sold given the more impressive state of Maya at the time.

[22] Lisping at the JPL

Classic Lisp history as it pertains to a space probe. The ability to remotely debug and recompile stuff is still very much a possible design choice today with a simple SSH tunnel that lets your local editor talk to the remote Lisp's swank instead of a local Lisp. Also worth watching this video talk for more details. You might not always want this functionality, but when you do, boy is it nice to have basically for free as part of the language, and not something you have to cobble together.

[24] GOAL - Game Oriented Assembly Lisp

I think later I'll add more links to this single number. But basically GOAL and Naughty Dog are classic "Lisp success in video games" examples, with some compelling anecdotes about how things wouldn't have turned out as nice.

Related to [9], there are just a lot of things Lisp has been used for. In my head I've compiled quite a few, I'll need to track them down again for linking. I remember once many years ago being asked "what uses Lisp?" and not having an answer, then later on not having a modern answer except for ITA/Google Flights. I have more answers now off the top of my head, but it's worth collecting answers both historical and modern, and in a pinch [46] works as a quick reference. As always a quote by Kent Pitman applies:

"Please don't assume Lisp is only useful for Animation and Graphics, AI, Bioinformatics, B2B and E-Commerce, Data Mining, EDA/Semiconductor applications, Expert Systems, Finance, Intelligent Agents, Knowledge Management, Mechanical CAD, Modeling and Simulation, Natural Language, Optimization, Research, Risk Analysis, Scheduling, Telecom, and Web Authoring just because these are the only things they happened to list."

[39] Rainer shows the receive-ip-packet method on a Lisp machine

In Symbolics Genera, everything was "open" (not in a legal sense, but visibility and modifiability sense). If you wanted to look at how the OS handles UDP, or tweak it yourself, you could just do it.

[40] Rainer shows more software on the Symbolics Macivory 3

Some commentary also here.

[41] Some videos showing Symbolics technology

My two favorites might be the ones on Concordia, for writing docs, and the graphics demo reel.

[42] More videos with demos and interviews

Some are of interest outside of Lisp per-se and more just the history of computer graphics, and movies like Tron. But I particularly like this collection of client work and demos, which shows some of the work flows. Imagine that so many decades ago... I also like this little 3-minute animated video and I've been using Stanley's head as a profile pic in some places.

[45] PTC Creo Elements/Direct Modeling

"Creo Elements/Direct is a comprehensive system for mechanical engineers and designers who create products using the direct modeling approach to 3D CAD."

Its architecture has a C++ kernel and a (mostly Common) Lisp wrapper for the interface (customizable), overall app logic, scripting, some amount of other implementation/integration, and so forth...

This software used to be called CoCreate Modeling. I first heard about it (and occasionally relink it) because it was given as an example of an existing Lisp project that has scaled to millions of lines of code. Pretty impressive! I finally tracked down some sort of authoritative source for that. That source is here, where at the ELS in 2009 the lead software architect gave a lightning talk about it. His slides are still available (or I have a copy if it ever goes offline) and his blog is quite interesting, and includes a lot more info in other posts. I think I'll start linking to that more often. Some highlights from the slides:
  • Implementation close to CLtL1. No condition system, "embryonic" CLOS
  • Several million lines of code in Lisp or Lisp-based DSLs (2/3 of our code overall)
  • Significant distributed development team.
  • Lisp compiler generates C/C++ code
  • Full Lisp compilation can take a day. Homegrown tools to detect dependencies.
  • 30 customer releases. 60,000 active users.
  • Initial prototyping in 1989

Presumably in 2022, 13 years later, the project has grown even larger? Unless like so many of these things that get swallowed up by big companies, it went into maintenance mode. Still, I think it serves as a good existence proof. Full CL with full conditions system and CLOS should be able to scale even better.

[48] SISCOG - 35 years of keeping trains on track

Per lispm on HN: Siscog, company is 37 years old, 130 employees, 1.7 Million lines of Lisp code. In the planning/scheduling domain for railway companies.

Other example ITA Software, bought by Google for $700 Million dollar. 100+ Lisp developers.

Psychology, Smugness

[14] Ooh! Ooh! My turn! Why Lisp?

I'm of two minds when it comes to the "smug lisp weeny" phenomenon. On the one hand, perhaps it's a barrier to community health and broader Lisp adoption. Perhaps even the biggest barrier. On the other hand, it can be just fun. And why not be smug? Look at all the amazing stuff listed, with him barely even getting started. But back on the other hand, it's basically lost on someone not already in the know. Perhaps the smugness should be restrained to circlejerk sessions and not left out in public so much. And to really go extreme at killing it, talk is cheap, code more.

I have a great fondness for the Norvig-McCarthy interaction at the end.

[19] I'm turning into a Lisp snob

Again with the smug weeny stuff. This time the author is sad at what he's becoming, because, like me I think, he recognizes it's not really that great of a look. And yet part of me still says, why not? Lisp is amazing, and just look at the mess the programming world is in, and has been in. I think reading this was also the first time I saw that go-algol68 link, which now that I've mentioned go I'm contractually obligated to lol no generics.

The HN thread at the time is interesting. Typical comments, though a few good points, and we can see that the library criticism has never gone away even though a year or so later quicklisp came out and now there are many libraries easily available. 2011_me was more or less in agreement with jerf's comments. But current me is only in agreement of the tradeoff depicted, that Lisp represents a minimization of constraints and thus maximizes what's allowed (which can be nice for expressive freedom among other things), and that many languages have instead opted to explore what's possible when you disallow many things programmers have previously taken for granted. I disagree with him that this direction is better, or that you can't actually enforce certain invariants at all over some fixed timestamp t. Languages that bind you can be interesting, in the same way puzzles can be interesting, but I typically want to solve problems, not puzzles, and global totalitarianism is as evil in the domain of languages as it is in the domain of governments.

[8] The Bipolar Lisp Programmer

I haven't linked this in a long time. It's an old essay that was influential years ago, when I was in high school, and while I knew by then I didn't have "outstanding brilliance", I still entertained the idea of at least a little brilliance. Any external validation said I was well above average, anyway. In short, I saw a lot of myself in it. I still see elements (what is this very blog post but a bout of stimulant-driven manic activity on something pointless?), and you can trace them through this blog even. But ultimately I wasn't brilliant, and so while I sometimes reflect on how far I've come, I didn't get very far at anything after all. I didn't even really begin to take Lisp seriously until 2016 when I saw either this comment or this comment (or both) and had an important preconception shattered, this was 2 years after college.

My attempts at Lisping (Scheme, Clojure) during college ended poorly, though I didn't really start imploding in college until third year (and thus making my 4-year degree that maybe could have been done in 3.5 end up taking 5 years) -- I still wonder what really went wrong internally, was it some subconscious thing with my grandma's death in November '11 (who I wasn't even super close to, though I have some nice memories)? Or something else, since there was a minor implosion my final year of high school? Related to the <a href="/view/2011/7/fall_semester_classes">course work?

I want to go with the post's "perhaps he doesn't get into beer, but into some mental digression from his official studies that takes him too far away from the main syllabus" since that describes a lot of my behavior -- I was working at the time as well, and work was far more interesting (plus I got paid, rather than paying absurd per-credit prices on student loans).

But the issue wasn't boredom, that's something I rarely feel, and have at times pretended doesn't happen to me in general ("Even if I can only stare at a wall, I can generate feelings of awe about how the wall exists, its paint, how the paint got there, how it was made, the components..."). Lack of mental stamina, maybe? Apart from the 'manic' modes? Lack of whatever you call the kind of "stamina" that keeps people going to work every work-day for years, but applied to focused intellectual pursuits of such a long expected-completion time that it can be easy to just be deflated/defeated without even trying much?

I didn't mean to write so much about myself, even now as an older adult... But that's the poignancy of this little essay, if it resonates with you when you're young, even if you'd like to take a pill so you can disavow much of it in reality and not just in words, it still resonates at least somewhat when you're older.

"He can see far; further than in fact his strength allows him to travel. He conceives of brilliant ambitious projects requiring great resources, and he embarks on them only to run out of steam." -- for me, I tend to not even embark, and when I do, I don't think it's steam that causes me to stop without getting far. I also think far sight is useless and maybe even nonsensical without detail. Like, can you imagine the actual pieces of putting together and maintaining a city water system? You can't do it all on your own, you need to bring people and parts and resources together. The truly far sighted are the businessmen and engineers and organizers of people who can actually see far and detailed enough to accomplish their grand visions. I don't think Lispers, even the "bi-polar" ones, have any natural advantage when it comes to entrepreneurship.

I don't think taking Common Lisp more seriously earlier on would have helped, and may have hurt (given that I resigned myself to Java, and later even started to like it a bit..., and got paid a bunch of money).

I accidentally wrote too much about me here (you can read it in the HTML source), but the intent of the commentary is just that even if this resonates with someone, that doesn't actually mean much in predictive power. I have some disagreements with the piece now -- mostly in that it's really about Lisp programmers, and not just a more general personality type, that I'm not really sure is drawn to Lisp over any other language. "Far sight" isn't really an accurate characteristic either since without details it's useless, yet I don't think this personality type or Lispers in general have a unique advantage on detailed far-seeing that is needed for e.g. a successful startup founder or classic big project engineer.

I disagree also with the characterization of the "lisp community" in this piece, and annoyingly the take shows up elsewhere. Not really finished, poorly documented, many-questionable-alternatives, and other flawed types of software exist in every ecosystem. Basically every ecosystem has the opposite good software too, including Lisp. The biggest factor here for modern concerns I think comes from exposure to professional for-profit software development. There's unfortunately not a lot of that in the Lisp world -- but where there has been, what the hell do you call the 14 or so Symbolics manuals and S-applications but very well documented and very well finished? Or other professional tools? Take a look at just [9] (N-World). And there are of course modern examples too, with modern companies depending on Lisp and writing it professionally in teams.

[10] Making a success from being a brilliant bipolar

Related to [8], I remember reading this around the same time, and it's good to link if you link the former. You see elements of yourself in that former post, so what do you do about it? This link has some thoughts. Though its self-congratulatory opening suggesting you're on the same tier as Einstein should really be a red flag, and even when I first saw it I knew I was no Einstein. Moderately above average (~1 std dev) at best. That certain resonating elements of a "bi-polar" personality aren't unique to smart people is perhaps best demonstrated by some memes that very many people identify with. This one is one of my favorites. You can find a ton just image-searching side project meme. I also really like the flowerpot one. Point is, they wouldn't be very successful memes if the sentiment they express was only held by Einstein-tier people!

His "advice" is really not helpful, and might even be actively terrible for some people. Ultimately looking back, I haven't followed any of that advice. I'm skeptical of the idea of "acquiring" self-discipline, especially in the ways he suggests. My work performance reviews were great despite my own private ranking of self-discipline as not very good most of the time (and what does it say to be disciplined enough to lose 80 pounds from a dull diet over several months, but then not keep it up over the next several times two months?). Perhaps I'm just disciplined-enough, especially when job incentives are at play, and that's all one needs to worry about most of the time. Emotionally, having a stoic perspective is much better than exercise. "Finding a nice squeeze" might be good advice, in the 50s. Sorry, I'm just having a go at the literal phrasing, which just seems antiquated. (Maybe even insulting to some, watch out.) But sure, the actual advice of get a gf and don't be too picky about it apart from avoiding feminazis is probably helpful on average (ignore the messy relationship dramas unrelated to feminazism so common in our age behind the curtain), though saying "they exist" doesn't really operationalize anything. It's similar to demanding a change to parts of your mental makeup that may not so easily be changed. Could at least suggest reading a book on Game or similar. The fourth advice about working for anybody being a pain, as if he's warning you of something to watch out for, is no good, because one of course that's a very common experience to everyone, but two no it doesn't have to be that way (at least all the time) and the claim is too broad. The advice should rather be: institutions pay very well, try them out even if you're skeptical, and if one is too painful, try another. You need a sample set to really know if you can't stand them as a class. And you really need direct experience here, ahead-of-time predictions are notoriously unreliable. Also sometimes you will only be able to do your best "Einstein-tier" worthy work inside an institution. As was mentioned in the bipolar post, often the guy lacks resources to achieve his vision. You know what doesn't lack resources? Big institutions. Consider.

But that last bit, #5, about getting money for doing your own thing, and not settling for second best, is so inspirational it went straight into my quotes file. I was much more into the idea of founding a startup of my own at the time, too (thanks pg), so it resonated all the more. Still, I didn't follow it. Now that I'm "quasi-retired" maybe I can follow it! But probably not any time soon. People keep trying to recruit me to do work for them, I keep saying no. Not because I'm making money or want to make money doing my own thing, but simply because I'm in a position of security and so can afford to not work, which is my current preference and my current goal is to keep it that way (perhaps it's an irrational protective feeling of my time). My alternate advice to consider would be that until you are also in such a stable position (not necessarily quasi-retirement state, but if you took a few years off working, you wouldn't starve), maybe put this goal of doing-your-own-thing-at-all-costs on the backburner and revisit whether it's a goal you really want later. And besides, working on someone else's thing from time to time can be fun, and maybe it'll be better than your thing! Try it.

This ref admittedly was even less on Lisp and mostly just a followup to the bipolar one, which again I don't think characterizes Lisp programmers very well even if it does characterize certain common (not restricted to Einstein-tier) personality traits well...

[21] Naggum - Re: Is LISP dying?

A classic in the never-ending series asking the question of how well is Common Lisp doing these days, and perhaps Lisp-like things in general that we can begrudgingly grant to Clojure and Racket since "Lisp-like" seems to just mean vaguely s-expression based. (If standard Scheme is a Lisp, Julia is a Lisp.)

It's also fun and humorous. Never forget Bill Gates' real crimes! It wasn't his ruthless business acts, but what underlay them, his "competitiveness and personal fear of losing to imaginary competitors". Whatever the case, it's worth reflecting on one's level of fear, whether for the health of Lisp or for anything else. "if you think in terms of the imminent end of the world, _everything_ is soon food for the great garbage collector in the sky and whoever is not scrambling in panic looks like they aren't moving and have been passed by or are dying." -- yes, this and the following thoughts he wrote aided me against pursuing many mindless trends in tech that have come and have now gone. It hasn't been bulletproof, what I still remember of Flex for instance is likely to never be relevant again, but at least I got paid.

Development and IDEs

[5] The Common Lisp Cookbook (Editor support)

The whole cookbook site as a whole is great. This page is just a nice overview of where to get started using emacs, vim, atom, vscode, eclipse, lem, sublime, and others. It's a great reminder that there's not only emacs. For me, a vim lover, it's a great reminder that there's not only emacs and vim. In particular vim has two decent plugins, reviewed in [6]

[6] Lisp in Vim

Thorough review of slimv vs vlime. I prefer slimv, at least one quite better lisp programmer than me prefers vlime. Try both.

[35] CLiki: Development

Should be mentioned in the same light as [5], the CLiki is older than the cookbook and has a lot of useful info on it, some of it even modern, but also a lot of historical stuff.

[43] Resources for your Lisp Journey

Includes some screencasts, which some people find very helpful.

[2] On New IDEs
Disagree with its view on what makes a community, and that the standard is relevant. There is very much a C++ community (even if there's some animosity among subgroups, largely divided by embedded systems work or not) despite the standard, and there's very much a webdev community despite the ever shifting "standards" of the web.

Agree with most everything in the "Is there a Lisp one", with some thoughts again related to this post's section on community. I'm not sure the lisp communities are that tightly integrated around implementation, though it's certain a factor, and more importantly I see an open-source/not divide. I get emails from the hug mailing list, most are relevant only to lispworks stuff and aren't interesting. It'd be an interesting exercise to go through the names and look them up, both as an opportunity for cold outreach but also just to see if any have overlap in published open source (even if non-lisp).

See [3] for thoughts on the two proprietary Lisp IDEs as they relate into this post too. But I agree there's a mismatch in what new users want and what professionals want (and have). My main take on this mismatch is that new users should suck it up but also old users should actually get professionally productive in another language (like Java) to actually understand what others have available to them. Some of that could be very useful for them too! e.g. I rather like being able to right click a class name, click rename, type in the new name, and have the IDE go find and update all the files in the project that reference it. I care less about the IDEs source control integration (but certainly others appreciate it) and the post brings up the integrations with other things I basically never cared about that some really like too, like CI/CD pipelines. There's a lot that a modern IDE like IntelliJ offers, and even Eclipse (especially with plugins). For my biases, I use vim with slimv and am mostly happy, but I also did 6 years of professional Java (mostly in Eclipse) and there are things I sometimes miss. No, emacs doesn't have them.

I kind of think if there's any hope it would be for a lisper to go work at JetBrains and create a team to make a kickass Common Lisp plugin that puts everything else to shame. Built off idea/intellij stuff a lot of things people want would come mostly 'for free'.

[3] Allegro Common Lisp and LispWorks
These are the two proprietary Lisp IDEs. At some points I have tried both of them, and haven't really been impressed. (To put it mildly. I've wanted to rant about them both for some time, so I guess I might as well start here.) Allegro annoyed me a bit less, though I think it's possible LispWorks has customizations I don't know about that can make it better.

[2] talks about Why not Lispworks only. I think its criticisms are fair but weak, focused only on price and the fact that the IDE is built around the implementation. But there are bigger issues. First is that first impressions matter. Look at them! LispWorks at least has a decent site design (apart from it being rather difficult to, you know, BUY their software) but check out its three screenshots. The middle one for Windows is 826x763 and was taken in the Windows XP era. Now you can find screenshots of it running in big resolutions on Windows 10 with modern OS chrome, but come on. (As for what is in the screenshot: kudos that it's showing off a few things you want from an IDE. Stepping debugger, syntax colors, cross-referencing, file and project explorer.)

For Allegro, it's using a very dated site. To be fair, Franz employs good web designers, as can be seen on their home site. It's equally impossible to just buy the thing from the site. No screenshots though, you have to click the very small IDE link. You're greeted with something very similar to LispWorks: a single 1024x768 screenshot from Windows fucking XP. Here we see an inspector and stacktrace and class explorer and debugger... and some dumb factorial code with no syntax highlighting (I think I remember the IDE does in fact have syntax highlighting though). Like LispWorks, it's a window of windows.

Have either of them heard of panels that are ubiquitous in Eclipse/IntelliJ/Visual Studio/etc etc? LispWorks shows itself as a window of windows, using the OS chrome. These inner windows should be panels, sorry, and they shouldn't be easily overlapable like in other screenshots that just have them in an untiled mess. My IDE shouldn't resemble my desktop!

I also recall with LispWorks you can actually make these windows of windows be physical desktop windows. I guess some people like the idea of alt-tabbing from their browser to their System Browser 1 window? And if they have to move a window like their browser or slack or whatever on top of the IDE, they want clicking one of the things the IDE controls to only show that window and not all the subwindows now hidden? I can't remember if this behavior was default, it must have been because I remember being bugged by it when I tried LispWorks long ago.

Do they just not care about their IDEs? That's the impression I get, just from the initial site visits and screenshots and making it very difficult to actually buy and download a licensed version of the tool. And it probably even makes sense for them not to, their money makers are in their other tools, and partially their implementations, but not the IDEs.

And I'm pretty sympathetic! Here's a random thread I made two replies to that was also poo-pooing them from the screenshots alone.

I don't even like intelliJ (at least enough to have switched to it from Eclipse, I had the choice) and yet look at how much better their site is, from first impressions to how easy it is to buy and download.

Now on to pricing, the referenced post's first complaint. First look at IDEA: $19.90/month for individual use, or if you pay yearly it's $149 the first year (save two months), with 20% off the second year, and 40% off for every year after (so a mere $90/yr). You get a perpetual license for any version + all bug fixes that you pay a year+ on. IntelliJ makes 3 big releases this year? You're subscribed, you get them all for no extra fee. Next year makes only 1 "big" release that's not that big, so you cancel? You still get the last big release to keep using forever, plus any bugfixes they happen to backport to it at a future date.

And this individual use license just means that you an individual pay for it and you an individual use it yourself. There are no restrictions on your development activity -- you can write commercial software, open source software, research, whatever. If a company is paying for it, then a business license is needed, which is modestly more expensive at $49.90/mo or $499/yr with the same percent-off structure. The company owns it and can move it between one employee at a time.

Don't forget to click on their Special Offers tab! Students and teachers can get it for free, with the restriction of non-commercial use only, and OSS developers can also get it for free for non-commercial OSS work. There are various discounts for former-students, non-profits, startups...

Now let's look at the two Lisp IDEs, starting with LispWorks. If you click around enough you'll find this page for NA prices. Things are split into several categories. You want more categories? Hope you like paying more times! Categories are "Professional" and "Enterprise" editions for everything, and then divided up among a handful of different operating systems, and them divided up among whether your OS is 32-bit (lol) or 64-bit.

For most devs in this century, they're using either Linux/Mac/Windows 64-bit. This puts us at $3000 for a professional license (and no 'maintenance'), $4500 for an enterprise license. Thankfully it's the same for each OS, but if you want to develop on both Windows and Linux (perhaps you would like to ship a binary on both?) then hope you're happy paying twice. With "1 year maintenance" the numbers go up to $3400 and $5100 respectively. Without them, you'll pay $750/$1125 respectively when you need a maintenance renewal. Maintenance entitles you to a licensed update of any sort, e.g. from 7.1 to 8.0 or 8.0 to 8.1. I don't know if minor bugfixes get shipped and whether they are covered.

If you're an academic institution you get a discount! $1800/$2700 for the base no-maintenance cost.

Both professional and enterprise editions entitle you to do whatever development you want (i.e. commercial) and include "application delivery" support, i.e. generating binaries. The enterprise edition includes stuff that I don't think most programmers will want/need, so I think most professional programmers will be fine with a Professional edition. Thus, let's say, $3400 for your first year, and $750/yr thereafter (if you pause your maintenance, I don't know what will happen, whereas intelliJ makes it very clear).

If you want to build for android/ios, it's $1k for each for an annual license. Expensive, but an add-on, so whatever. IntelliJ has expensive add-ons too (its IDE mode for iOS/MacOS development is an extra $89/yr first year for individuals -- they really encourage you to get the all-products pack at $249/yr first year, which is basically immediately worth it the moment you need more than two).

Now, they do offer a Personal Edition which is free to use for non-commercial purposes. It's crippled in a number of ways. It's typically a version behind (currently 7.1.2, where 8.0 is the current version), there's a heap size limit (unstated -- assume less than four gigs), there's a fucking time limit (it shuts itself down possibly without saving anything after a mere 5 hours), and you can't create binaries.

Finally I must mention there are Hobbyist Editions. I don't get the point. The "basic" Hobbyist edition removes most of the crippling behavior of the Personal Edition: it's on the modern version, no heap/time limit, and you can make image saves if even you still can't deliver binaries. You can only use this edition for non-commercial, non-business, and non-academic use. The HobbyistDV edition removes one restriction, which is letting you deliver binaries.

Now the catch: they want money for these! The Hobbyist Edition sounds very reasonable -- if it was free! It's basically saying "hey open source devs, use us!" And hoping that some of them convert later into commercial users. It's a great model.

But no, they want money. And not a small amount either! $750. If you want to deliver executables, $1500. Fuck you too. No maintenance contracts, so if you bought 7.1, you can now buy 8.0 for half off. Fuck you again.

Now, when I was working at my six figure job, I contemplated buying a LispWorks license, because, you know, I want to support Lisp.. but really it's just too outrageous for me to handle, rather than too expensive. Now I've said before, if I was running a Lisp company, I'd suck it up and if my employees wanted or if my application domain demanded I would pay up, with business funds. But personally? No. One of the prolific CL developers who "retired" just a few years ago "rewarded" himself with a personal license -- at the end of his career -- just how much money are they making on their IDEs each year? If it's not much, no wonder they don't care.

If I was still a student looking at these prices.. lol.

Maybe Allegro CL will be priced better? It's also a US company, if that matters.

I'd love to tell you, but... their vastly easier to find "Packages/Pricing" page says that prices start at $599, but that's all they tell you. Fuck you.

There's some more information so we can infer what bullshittery we'd have to endure if we actually called for a quote. They too have a 32-bit and 64-bit divide, except you can only get 64-bit if you go for the Enterprise edition. There's also an Enterprise 64 Platinum Edition that includes a few extra add-on products you could otherwise buy separately.

c2 suggests the standard commercial product is $8000. 8k! And that doesn't include a runtime licensing fee! They also suggest that if you don't need to make executables, you can push the cost down to perhaps $2k. But if you need exes, don't forget the fee. The fee page says it's based on end users using the software in a year for one style, and a royalty fee for another style. If you're wanting to develop a game, and you have a game server, and want the game itself and the server backend to both use Allegro, I think you'll need to pay both commercial license types.

So you may be able to get a 32-bit version of Allegro for one OS only at $600. Who wants that? Maybe you can talk down the sales guy for a 64-bit version with none of the add ons for perhaps $1200, but $2k sounds plausible.

They do have a free download, but it's basically just for evaluation purposes. Doesn't support multi processing (apparently, they talk about "SMP" support a lot) and is only 32-bit, good luck.

So by imposing a runtime fee (if you need to build an exe) and hiding their prices, I think they're actually worse on this metric than LispWorks! Suddenly LW isn't looking so bad! I could learn to tolerate the slight UI differences -- again I have tried the free versions of each, and Allegro is "nicer" in the UI/UX sense, but not that nicer to deal with that crap.

Though again, if I ran my own company, and people tried both commercial systems and wanted one or the other, then I'd pay up. Even at $8k, that's probably around 1/20th of their salary.

Though if I was running a lean startup, I'd have to think harder about it.

And if either company upgraded its pricing model out of the 90s to something like a subscription based (say, $20/mo for a 64-bit professional version that lets me ship commercial restriction-free executables) I stand by my old comment that I would start paying immediately. Hell, even at $100/mo, or $1200/yr, it'd be an instant yes when I was still working, now I'd have to think about it, but not as hard as the initial LW $3400 then $750/yr.

And then I'd hope they add more good IDE features. Subscribers would be investing in them, hopefully they'd invest something in their tool. Whatever periodic charges they get going on under the umbrella of "maintenance" does not inspire investment spending.

Fortunately there are decent free options, see [5].

Is X Lisp? Is X a Lisp?

[25] Naggum - Re: Why is Scheme not a Lisp?

Maybe the classic rant on the topic. It's tiresome though... I will continue to use unqualified Lisp as almost certainly meaning Common Lisp, and encourage others to do so if it comes up, but unqualified Lisp can and does mean other things. What those other things are have to be determined from context. Which is also tiresome. "I wrote an implementation of Lisp this weekend!" "Does it have DISASSEMBLE?" "No." This "Lisp" really just means the person's toy that he's calling Lisp for social signaling purposes.

Consider revisiting [26].

[20] Naggum - Negation

Part of a series for understanding the age-old debate brought up briefly in [4] about what is Lisp, what is "a Lisp", what is "the Lisp family", and what is a "Lisp dialect". Also just generally fun psychobabble to read. Like there really are 1-bit people out there who can't deal with any sort of nuance. And of course there's just frequent misunderstanding of non-probabilistic logic. "If it doesn't compile, it doesn't work" does not imply that "If it compiles, it works".

[27] lispm on Lisp lineage

His first link shows you can trace all the way back to the Lisp 1.5 paper and run code hardly modified in modern Common Lisp, you can't do that for other "lisps", incidentally this is part of what makes CL Lisp and "a Lisp" and other "lisps" not so much. I've argued similarly based on missing features, where is Scheme's CLOS, where is goto, where is the condition system... well, it's not so much arguing for me, but a futile attempt to share historical knowledge, mostly that modern CL has (and always has had) very important features not found in Scheme, Clojure, ... but also many things trivially traceable unmodified back to McCarthy's Lisp.

Another thing from the Lisp 1.5 manual I shared was length. Though looking back I forgot to also insert funcall. No editing 4 year old comments... though I repeated it without noticing a few months ago and then I noticed and it's been bugging me since. Ah well. In the large it's right! "The features of cons cell lists (including the syntax (X . Y)), lambdas, PROG, setq, labeled gotos, and even being able to use SHOUTING names if you want, have all been retained throughout the decades."

Posted on 2022-01-18 by Jach

Tags: lisp, thought


Trackback URL:

Back to the top

Back to the first comment

Comment using the form below

(Only if you want to be notified of further responses, never displayed.)

Your Comment:

LaTeX allowed in comments, use $$\$\$...\$\$$$ to wrap inline and $$[math]...[/math]$$ to wrap blocks.