12 ms·

A Road to Common Lisp (2018)

239 points by fuzztester 2y ago

nesarkvechnep 2y ago
I really like Common Lisp! Unfortunately, I can’t really find a use case for it. I usually develop web services and there Elixir and Erlang are winners in my book. For command line tools I use Rust or C. Can someone recommend types of applications where Common Lisp shines? I guess one can always write the business logic in CL and expose it via Unix socket.
- whobre 2y ago
  Even the author of the article says he uses Scala professionally.
- surfingdino 2y ago
  > (...) types of applications where Common Lisp shines? An application to Y Combinator? /s
- vindarel 2y ago
  CL is very general purpose. Where it shines IMO is: the development experience (interactive, good compile-time type warnings with SBCL), the stability, the delivery of applications (compile to a self-contained binary), the overall feature set. I use it for web back-ends and little scripts. Everything's stable, my Sentry dashboard is empty. [edit: sorry, just had a stupid production error in my Python app] Some friends love Elixir and do great things with it, but I'm in your reverse situation: I don't have enough incentives to switch. Elixir's REPL is good but it's only a REPL, not an image-based experience. Its Emacs modes are rudimentary. Phoenix looks great, but it's very opinionated (and very much code-generator oriented, strange). I can't copy-paste a binary to my servers (or other users). The Torch admin dashboard looks cool, but I just made my own in a week-end (and again, I'm afraid by code generation). LiveView looks awesome but it's its own little world and I might approach it with HTMX and HTMX websockets. TLDR; I can do both web apps and CLI tools with CL and switching must be worth it too.
  - nick__m 2y ago
    and again, I'm afraid by code generation Do you use macro and higher order function? If you do, you already use code generation, so why are you afraid ?
    - medo-bear 2y ago
      Because macros in common lisp are very easy to grok, which is not to say that common lisp programmers promote willy-nilly use of macros
      - nick__m 2y ago
        Unlike Scheme, CL macro are glorified template based code generator. If your not careful to use facilities like gensym and packages it easy to accidentally capture already binded terms at call site.
        lispm 2y ago
        If we look at macros in Scheme R7RS they are mostly transformers on patterns. -> https://standards.scheme.org/corrected-r7rs/r7rs-Z-H-6.html#TAG:__tex2page_sec_4.3 https://standards.scheme.org/corrected-r7rs/r7rs-Z-H-6.html#... > If your not careful to use facilities like gensym and packages it easy to accidentally capture already binded terms at call site. Luckily CL programmers have heard about that and are usually careful about that.
    - vindarel 2y ago
      I mean code generation that writes code to files. I'm afraid they bit rot fast and make upgrading harder. Macros generate code on the fly, not in my source files.
      - mst 2y ago
        I tend to regard code generation as being something that should -feel- like a macro to use, just one that optionally materialises the results so you can ship the code without a dependency on the generation logic. I am very conscious that most code generation in the wild is ... Not That.
- medo-bear 2y ago
  As far as use cases are concerned, I think of Common Lisp as a higher level C with much better ergonomics. My particular use case is prototyping low level computations for performance tuning. Common Lisp excels at prototyping. I guess if you need to implement something for which there already exist 20 other libraries there is not much point, which is also the reason I'm not a huge fan of Rewrite in Rust movement.
- citizen_friend 2y ago
  This is an odd question. Web services are great with CL. But you already have languages you prefer. So yes, you must be interested in CL to want to replace one of those.
- deleted 2y ago
  [deleted]
- anthk 2y ago
  Maxima, the math CAS.
vindarel 2y ago
It's a great article. Since 2018 though, we have more tools and resources so we can enhance it. (I copy/edit a comment of mine from last thread) ## Pick and Editor The article is right that you can start with anything. Just `load` your .lisp file in the REPL. But even in Vim, Sublime Text, Atom/Pulsar, VSCode, the Jetbrains suite or Jupyter notebooks, you can get pretty good to very good support. See https://lispcookbook.github.io/cl-cookbook/editor-support.html https://lispcookbook.github.io/cl-cookbook/editor-support.ht... > if anyone is interested in making a Common Lisp LSP language server, I think it would be a hugely useful contribution to the community. Here's a new project used for VSCode: https://github.com/nobody-famous/alive-lsp https://github.com/nobody-famous/alive-lsp There's also https://github.com/cxxxr/cl-lsp https://github.com/cxxxr/cl-lsp ## Libraries He doesn't mention this list, what a shame: https://github.com/CodyReichert/awesome-cl https://github.com/CodyReichert/awesome-cl => the CL ecosystem is probably bigger than you thought. Sincerely, only recently, great packages appeared: CLOG, sento (actors concurrency), 40ants-doc, official CL support on OVH through Platform.sh, great editor add-ons (Slite test runner, Slime-star modules…), Coalton 1.0 (Haskell-like ML on top of CL), April v1.0 (APL in CL), a Qt 5 "library" (still hard to install), many more… (Clingon CLI args parser, Lish, a Lisp Shell in the making, the Consfigurator deployment service, generic-cl)… His list is OK, I'd pick another HTTP client (Dexador instead of Drakma) and another JSON library (jzon or shasht), new ones since 2018 too, but that's a detail. BTW, see also a list of companies: https://github.com/azzamsa/awesome-lisp-companies/ https://github.com/azzamsa/awesome-lisp-companies/ (nothing official, we add when we find one) ## Other resources The Cookbook (to which I contribute) is a useful reference to see code and get things done, quickly. https://lispcookbook.github.io/cl-cookbook/ https://lispcookbook.github.io/cl-cookbook/ While I'm at it, my last shameless plug: after my tutorials written for the Cookbook and my blog, I wanted to do more. Explain, structure, demo real-world Common Lisp. I'm creating this course (there are some free videos): https://www.udemy.com/course/common-lisp-programming/?couponCode=SUMMER-LISP-2206 https://www.udemy.com/course/common-lisp-programming/?coupon... You'll learn CL efficiently and support an active Lisper. ## Web Development See the Cookbook, and the awesome list. We have many libraries, you still have to code for things taken for granted in other big frameworks. I have some articles on my blog. I have a working Django-like DB admin dashboard, I have to finish the remaining 20%… We have new very cool kids in town, especially CLOG, that is like a GUI for the browser. Check it out: https://github.com/rabbibotton/clog https://github.com/rabbibotton/clog ## Game Development See again the awesome-cl list. And the Kandria game, published on Steam, all done in CL: https://kandria.com/ https://kandria.com/ ## Unit Testing We have even more test frameworks since 2018! And some are actually good O_o ## Projects To create a full-featured CL project in one command, look no further, here's my (shameless plug) project skeleton: https://github.com/vindarel/cl-cookieproject https://github.com/vindarel/cl-cookieproject you'll find the equivalent for a web project, lighter alternatives in the README, and a demo video: https://www.youtube.com/watch?v=XFc513MJjos&feature=youtu.be https://www.youtube.com/watch?v=XFc513MJjos&feature=youtu.be ## Community We are also on Discord: https://discord.gg/hhk46CE https://discord.gg/hhk46CE and on Libera Chat. ## Implementations CLASP (CL for C++ on LLVM) reached its v1.0, congrats. https://github.com/clasp-developers/clasp/releases/tag/1.0.0 https://github.com/clasp-developers/clasp/releases/tag/1.0.0 More are in the making… We got dynamic library delivery tool for SBCL (sbcl-librarian). There's a rumor from the European Lisp Symposium that a feature beginning in "co" and lasting in "routine" is coming to SBCL. Allegro CL (proprietary) got a new version running in the browser… Crazy Lisp world <3
huygens6363 2y ago
I love the concept of the REPL and live editing and such, but my everyday work experience using a debugger sounds like it’s about 80% of the way there? I can break, inspect, run expressions and generally figure out what’s going on by experimenting. Maybe not edit code directly, but I honestly never feel the need. Looking and poking around is in the vast majority of cases all I need. Am I missing something incredible?
- 7thaccount 2y ago
  In a lot of cases... probably not in my experience. I think it can make a big difference in some cases though. What REPL were you using though? Something to think about is that the Lisp and Smalltalk REPLs are a lot more powerful than Python in that I think when an expression fails, the program itself can be edited and it will start where it left off. You can't do that with Python. Edit: the article does a good job of explaining this as "It's like if you could run your code in a debugger with a breakpoint at every single line that only activates if something goes wrong!"
  - huygens6363 2y ago
    Modern (proprietary) tooling comes really close to that experience, but I can see how it is liberating compared to editing text files, waiting for compilation and preying it works. I guess modern tools learned from the best.
    - 7thaccount 2y ago
      I've seen this with C# lately. The tools have come a long way as a lot of languages have gotten closer to the good ideas of lisp over the years.
- vindarel 2y ago
  I suggest: do you find yourself often quitting the debugger and re-running the same test, the same task from the start? You can avoid that in CL. Just leave the debugger open, go to the buggy line ("v" on a stacktrace in Slime), fix the function, re-compile it on the fly (C-c C-c in Slime), come back to the debugger, resume the program from the stackframe you want, now it passes. If the first steps were taking 10 minutes, you just saved yourself some time. You don't need special needs for that, it's a fast workflow I use everyday. demo: https://www.youtube.com/watch?v=jBBS4FeY7XM https://www.youtube.com/watch?v=jBBS4FeY7XM debugging a complex stacktrace: Python VS CL: https://lisp-journey.gitlab.io/images/debugging-python-VS-lisp.png https://lisp-journey.gitlab.io/images/debugging-python-VS-li... Another important point: we debug everything while keeping the current state in memory (in the image). We don't have to re-create our test data. All the program state is kept live, until we restart the image.
next_xibalba 2y ago
This comment could read as provocative but it is not intended to be. It’s a genuine question: Lisp seems to get outsized attention on HN. If Lisp is so good, why isn’t its use more widespread? *Maybe it’s disproportionate attention on HN is just a pg remnant?
- schmidt_fifty 2y ago
  People probably just find it interesting
  - tmtvl 2y ago
    I don't know why you're getting downvoted, this is a reasonable take and it's even in the guidelines: > On-Topic: Anything that good hackers would find interesting.
- BeetleB 2y ago
  And this comment is asked every time a Common Lisp submission comes up. Perhaps go and read prior answers? > If Lisp is so good, why isn’t its use more widespread? What does "good" and "widespread" have to do with each other? Mildly orthogonal concerns. As a tech junkie, one experience that has been consistent all my life is "the best stuff is almost never widespread". When I was in to digital cameras, the "best" camera was rarely the widespread one - both pre-DSLR and after. The best file management utility is not the widespread one. The best radio is not the widespread one. The best TV is not the widespread one. The best SW for a task is often not the most widespread one. I know I'm not answering the question. Instead, I want you to ponder the faulty premise in your question. Instead of tying your question to "widespread", why not simply ask why people like Common Lisp so much? It's like asking "If that job is so awesome, why doesn't it pay well?"
  - next_xibalba 2y ago
    > Perhaps go and read prior answers HN is not a knowledge base or docs. It’s a forum. Perhaps you should go and read the HN guidelines?
  - 2y ago
deleted 2y ago
[deleted]
ativzzz 2y ago
This article fails to explain why lisp. People talk about it on HN sometimes. This article says "here's how to learn it". Why should I learn it? There's a million languages out now that I can learn instead. The author gives a few ways I can use lisp. Why would I choose lisp over any of the other languages that have stronger ecosystems that solve those same problems and are built specifically for them? The syntax looks arcane and it seems that the most prevalent modern use for lisp is emacs, so if I don't use emacs, why lisp?
- uncleshelby 2y ago
  Matthew Butterick wrote a book about Racket (a dialect of Lisp) which has a great appendix that tries to explain why Lisp is worth learning: https://beautifulracket.com/appendix/why-racket-why-lisp.html https://beautifulracket.com/appendix/why-racket-why-lisp.htm... There are lots of evangelist explanations for why Lisp is The Best out there, but this is one of the better and more concrete ones.
- nomilk 2y ago
  Not sure how much other languages developed in 22 years since this essay, but PG makes the case for lisp here: https://paulgraham.com/icad.html https://paulgraham.com/icad.html Computerphile riffs on the importance of homoiconicity and the ability for a language to programatically alter itself: https://www.youtube.com/watch?v=dw-y3vNDRWk https://www.youtube.com/watch?v=dw-y3vNDRWk Uncle bob had tried many languages and settled on lisp: https://www.youtube.com/watch?v=UBXXw2JSloo&t=2m40s https://www.youtube.com/watch?v=UBXXw2JSloo&t=2m40s > for 30 years I thought I don't want to learn lisp, it's a dumb language, and I read (Structure and Interpretation of Computer Programs) and it changed my mind... I thought I'm going to get (clojure) and dither around with it.. and I just fell in love with the language and I've been using it ever since
- lgrapenthin 2y ago
  The article is not trying to sell you on Lisp, in its first sentence it clarifies, that it is written for people who were "asking for advice on how to learn Common Lisp"...
- deleted 2y ago
  [deleted]
julianeon 2y ago
There's some serious cognitive dissonance going on in this section: As an open-source project, Racket is positioned at a happy medium. The core development team has been working together for years, and the commits remain fast & furious. But they’re friendly scientists, not Shire-dwelling egotists, and remain receptive to improvements across the whole system. If you have a better idea, they’ll listen; if you code it up to their standards and make a pull request, they’ll take it. [2021 update: I no longer contribute to Racket due to abuse & bullying by the project leadership. Everyone in the broader Racket community, however, has always been helpful and kind.]
- vindarel 2y ago
  Wrong thread? There is no mention of Racket here.
  - Jtsummers 2y ago
    My guess is they meant to respond to this comment: https://news.ycombinator.com/item?id=40442347 https://news.ycombinator.com/item?id=40442347 But somehow didn't hit reply and just made it a top level comment instead.
- Jtsummers 2y ago
  That's not cognitive dissonance, that's "I wrote a thing when I held one view. Instead of changing it entirely here is an additional comment that revises my previous one. I'm not going to edit the original." The order of things matters. "I hold this view which contradicts my earlier, no longer held, view." is not cognitive dissonance. "I hold this view despite it contradicting my other view." is cognitive dissonance.
barrenko 2y ago
Lisps are great to challenge your thinking, but (with Clojure) I got stuck at making sense of macros — way out of my depth at that moment in time.
- Jtsummers 2y ago
  I'd recommend studying some existing macros and spending time recreating them. Starting with simple use-cases of the macro and working up. Repeat this with a few macros and you'll eventually learn how they operate. Let Over Lambda is also a good (opinionated) book on macros (most of the book is available for free), and of course there's PG's On Lisp (jump to page 95 in the PDF if you're already comfortable with Lisp). https://letoverlambda.com/index.cl/toc https://letoverlambda.com/index.cl/toc https://paulgraham.com/onlisp.html https://paulgraham.com/onlisp.html
  - barrenko 2y ago
    Thank you!
- iLemming 2y ago
  > I got stuck at making sense of macros Are you simply staring intently at the macros, trying to make sense of them, or are you actually utilizing the macro-expanding feature in your editor? Or perhaps you're grappling with writing macros yourself? Macros can be tricky, which is why Clojurists often avoid creating new ones unless there's a compelling reason to do so. There's an old book called "Mastering Clojure macros", it's tiny - fewer that a hundred pages. It helped me back when I was learning Clojure.
  - barrenko 2y ago
    more trying to understand really, this blew my mind at a time https://aphyr.com/posts/305-clojure-from-the-ground-up-macros https://aphyr.com/posts/305-clojure-from-the-ground-up-macro...
troad 2y ago
I recently posted my observations about taking an interest in Common Lisp and a few people kindly pointed me to this resource, which was very, very helpful. If you, like me, are drawn to Lisp because of its reputed elegance, just bear in mind that Common Lisp is probably the least elegant of the Lisps, though probably the most mature. It uses dated mnemonics that won't be intuitive to someone coming from modern languages, and in many ways it's surprisingly hacky. I've been pointed at Scheme, Clojure, and Racket for examples of more elegant Lisps, with Clojure probably being the most day-to-day useful of the three (albeit sadly it runs on the JVM - talk about the Beauty and the Beast). The two big (but very basic) observations that made Lisp click for me: (A) Those nested parentheses directly indicate the AST of a Lisp program - Lisp syntax doesn't just feature lists, Lisp syntax is those lists (Lisp = LISt Processing). A Lisp program is just a single list made up of other lists. There's almost no other syntax you have to learn. Operators are just functions, which are just lists. (B) Working with a REPL allows you to climb inside of a program in a way that working with an 'Algolian' language doesn't. All the functions are there for you to play with. Using a REPL seems to be iterative; programmers will work in text files (in e.g. emacs) and then jump into a REPL every now and again to test and prod and poke at the code. Cumulatively, those two insights I think define what is special about Lisps. Since everything is a list, you program by defining more complex lists around simpler lists, which - like Legos - you can freely manipulate with a REPL. This allows you to build programs from the inside out, compared to Algolian languages. You can build all the bits and pieces well before there's any main() method to unite them. It's not theoretically impossible to work with C or Rust like this, but the tooling around Lisp makes this easy and fundamental. On the flip side of this, how one is meant to distribute finished Lisp programs is very unclear to me. It appears that to ship a Lisp program you basically ship the entire development environment, plus all your source code, and point the former at the entry point to the latter. I'm almost certainly missing something obvious here though, and I'm happy to be enlightened on this point. I honestly don't know how one would distribute a closed-source binary where they don't necessarily want the end user to be able to use a REPL on the code. There appears to be a proprietary compiler called LispWorks that can do this, but with prices in the four figures that's far too dear for a merely intellectual curiosity about Lisp. (There's a hobbyist edition of LispWorks, but my policy is not to spend time learning tools I couldn't turn to professional use.)
e12e 2y ago
(2018)
sapling-ginger 2y ago
The author first says that CL people usually avoid dependency hell: >When programming applications in Common Lisp people will often depend on a small(ish) number of stable libraries, and library writers often try to minimize dependencies by utilizing as much of the core language as possible. But then try to expound on CL's extensibility using libraries: > No one has been clamoring for a new version of the specification that adds features because Common Lisp's extensibility allows users to add new features to the language as plain old libraries Very contradictory, and these two paragraphs are in two adjacent sections.
- mepian 2y ago
  How is this contradictory? The point is that you can extend the language when you really need it.
- fuzztester 2y ago
  I don't see any contradiction in those two points. Both of them can simultaneously be true.
- deleted 2y ago
  [deleted]
- iLemming 2y ago
  As other pointed out, there's no contradiction. I would like to add that CL often avoids dependency hell with: - Standardized Specification: Common Lisp has a stable and comprehensive standard that reduces the need for external libraries. - Load Time Flexibility: Its dynamic nature allows loading and reloading of code at runtime, facilitating easier management of dependencies. - Isolation through Packages: The Lisp package system provides a way to encapsulate code and manage namespaces effectively, reducing conflicts. - Backward Compatibility: Common Lisp places a strong emphasis on backward compatibility, which helps in maintaining stability across versions. - Mature Ecosystem: Many Common Lisp projects are long-lived and stable, leading to a mature ecosystem with less frequent breaking changes. I can't claim to be a very experienced CL coder, but I wrote enough Clojure, and similarly, rarely ever see dependency problems, even though Clojure heavily relies on the JVM ecosystem, inheriting both its strengths and complexities. Clojure emphasizes interoperability with Java and uses many Java libraries, which can introduce complex dependency trees and conflicts common in the Java ecosystem, yet at the same time, Clojure emphasizes small, composable libraries (often referred to as the "small libraries" philosophy), reducing the likelihood of large, monolithic dependencies causing issues. The community prioritizes modularity and ease of composition, leading to the prevalence of smaller, more focused libraries. Common Lisp in contrast tends to favor more extensive libraries or systems that provide a broad set of features within a single package.
deleted 2y ago
[deleted]
dang 2y ago
Related: A Road to Common Lisp (2018) - https://news.ycombinator.com/item?id=31645558 https://news.ycombinator.com/item?id=31645558 - June 2022 (48 comments) A Road to Common Lisp - https://news.ycombinator.com/item?id=17852194 https://news.ycombinator.com/item?id=17852194 - Aug 2018 (92 comments)
nomilk 2y ago
Great read. Highly fond of long single-pagers. Curious why lisp's REPL is frequently touted as an incredible language feature e.g.: > Support for this style of interactive development doesn't just come from some fancy editor plugins — it's baked into the bones of the language. > So how do you actually get this wonderful interactive experience? I've only ever programmed in interpreted languages (R, ruby), so I can't really understand how or why a REPL is so great since to me a (console|REPL|interpreter) is a standard feature (nothing extraordinary). Perhaps because I haven't had to work in a language without the convenient and immediate ability to execute arbitrary user inputs (as a REPL or interpreter can), for example a compiled language.
- sourcepluck 2y ago
  I think this relatively short blogpost does an excellent job of answering your question: https://mikelevins.github.io/posts/2020-12-18-repl-driven/ https://mikelevins.github.io/posts/2020-12-18-repl-driven/
- julianeon 2y ago
  I can think of a REPL use case I don't know how to do easily in another language. Doable yes, but easily and conveniently, no. I want to build a little tool for the command line: meaning it should be runnable at any time I pull down my terminal, easily started and stopped. In it, I want to listen to a Telegram room. Basically the idea is, in this Telegram room, things are announced, and I want to look up some of them. It could be anything: sneakers, toys, concert tickets. But let's say crypto projects, as there is a running stream of them all day. (Doesn't have to be if you don't like crypto but let's go with it for now). So I'm printing this list of crypto projects to the screen. Every so often I want to hover over one and get more information about it. For example, pretend there's a project called PGPalooza, one of many that's being printed in this list that's spilling out in real time on my terminal screen. I scroll up to PGPalooza and run a command on it, and then it runs some commands and opens up a few browser windows that I can look at to learn more about it. This is easy to do in Lisp, in an intuitive natural way, that I don't think I could do with the same ease in other languages. You could think of this as demonstrating the benefits of interactivity in action. I can scroll up and modify the PGPalooza text to read lookup("PGPalooza") and then press Ctrl-E at the end to return one type of data, and financials("PGPalooza") to see another. It's also very easy to modularly add commands to it too, to expand on this.
b3lm0nt 2y ago
I wanted to love Common Lisp, but as a Vim user every day was a struggle. One typically uses plugins (Slimv, Vlime) that contort buffers in bizarre ways in order to simulate the SLIME EMacs REPL — if not, they will lose out on the interactive development experience that is so central to CL. Being tied to either EMacs or an enterprise solution like LispWorks to get the full language experience was ultimately a non-starter. I’d love for someone to build an alternative CL development experience that could work in a wider range of text editors and IDEs. There is a lot to learn from CL, but I think it can be hard to access for most developers.
- massysett 2y ago
  The author of “Let Over Lambda” dislikes Emacs and does not use it. What’s more, he didn’t use Slimv or anything like it or even Vim at all. He used a more basic vi, maybe nvi. So perhaps the interactive experience is not essential. You can just edit and compile like you would in C. That’s not what I do—-I use Slime—but it is possible. Also, a lot of the interactivity is required by the standard to be built in to your Lisp’s REPL, so you can do quite a bit if your REPL isn’t primitive. SBCL doesn’t even have readline but you can use rlwrap. https://letoverlambda.com/ https://letoverlambda.com/
  - amno 2y ago
    > The author of “Let Over Lambda” dislikes Emacs and does not use it. I have no idea what Hoyte like to type in, but why does it matter what text editor he uses? Einstein didn't had any computer, not even a calculator. Do we have to use paper and pencil for all the calculations just because Einstein did? Our physics teacher in gymnasium, forced us for 4 years to do all calculations on tests by hand, at four decimal places, with that exact excuse: Einstein didn't have a mini calc. Non of us have become a Nobel prize taker in physics :). > Also, a lot of the interactivity is required by the standard to be built in to your Lisp’s REPL, so you can do quite a bit if your REPL isn’t primitive. Mnjah; not so much really. Using at least SBCL from plain command line really sucks. If you mistype something you have to retype everything, no history, etc. > SBCL doesn’t even have readline If you are on some *nix OS, you can get a long way by just using SBCL with built-in sb-aclrepl + linedit. Aclrepl gives you "command-like" stuff, similar to ":" in Vi (or M-x in Emacs), and linedit adds cursor motion, history and some basic completion. I would still not type entire programs in repl, but for running and testing the code it is a basic survival kit. For me personally it is enough. There is also cl-repl package which gives you native bindings and some extras if you want to go all-in readline from within the lisp itself.
ngcc_hk 2y ago
This totally changed me and enjoy lisp so much more using vim. No more emacs. https://susam.net/lisp-in-vim.html https://susam.net/lisp-in-vim.html
anentropic 2y ago
> JSON support in Common Lisp is a god damn mess Is the JSON situation any better now in 2024?
- cess11 2y ago
  JSON is a messy format, you'll always have to know your requirements well to be able to pick a fitting parser for it. Are you going to parse a simple, small key-value-structure? Pretty much any library will solve it for you or you could invent your own simple parser. If you need to stream gigabytes of complicated JSON and do sophisticated transformations back into JSON or something like that, then you'll have to evaluate several libraries and have a look at how they translate into CL datatypes. Some might reduce a combination of false, null, the empty list to NIL, which could lead to information loss and surprises.
- varjag 2y ago
  This piece is enthusiastic but a bit subjective. I personally had zero troubles with JSON in CL, just chose one library and use it. Would also disagree with some his recommendations, e.g. Drakma has a lacking interface for error handling and Dexador is nicer for use in prod.
- ludston 2y ago
  Yes. The trend is towards standardizing on an library called jzon. It's pretty decent.

239 points by fuzztester 2y ago

I really like Common Lisp! Unfortunately, I can’t really find a use case for it. I usually develop web services and there Elixir and Erlang are winners in my book. For command line tools I use Rust or C. Can someone recommend types of applications where Common Lisp shines? I guess one can always write the business logic in CL and expose it via Unix socket.

whobre 2y ago
Even the author of the article says he uses Scala professionally.
surfingdino 2y ago
> (...) types of applications where Common Lisp shines? An application to Y Combinator? /s
vindarel 2y ago
CL is very general purpose. Where it shines IMO is: the development experience (interactive, good compile-time type warnings with SBCL), the stability, the delivery of applications (compile to a self-contained binary), the overall feature set. I use it for web back-ends and little scripts. Everything's stable, my Sentry dashboard is empty. [edit: sorry, just had a stupid production error in my Python app] Some friends love Elixir and do great things with it, but I'm in your reverse situation: I don't have enough incentives to switch. Elixir's REPL is good but it's only a REPL, not an image-based experience. Its Emacs modes are rudimentary. Phoenix looks great, but it's very opinionated (and very much code-generator oriented, strange). I can't copy-paste a binary to my servers (or other users). The Torch admin dashboard looks cool, but I just made my own in a week-end (and again, I'm afraid by code generation). LiveView looks awesome but it's its own little world and I might approach it with HTMX and HTMX websockets. TLDR; I can do both web apps and CLI tools with CL and switching must be worth it too.
- nick__m 2y ago
  and again, I'm afraid by code generation Do you use macro and higher order function? If you do, you already use code generation, so why are you afraid ?
  - medo-bear 2y ago
    Because macros in common lisp are very easy to grok, which is not to say that common lisp programmers promote willy-nilly use of macros
    - nick__m 2y ago
      Unlike Scheme, CL macro are glorified template based code generator. If your not careful to use facilities like gensym and packages it easy to accidentally capture already binded terms at call site.
      - lispm 2y ago
        If we look at macros in Scheme R7RS they are mostly transformers on patterns. -> https://standards.scheme.org/corrected-r7rs/r7rs-Z-H-6.html#TAG:__tex2page_sec_4.3 https://standards.scheme.org/corrected-r7rs/r7rs-Z-H-6.html#... > If your not careful to use facilities like gensym and packages it easy to accidentally capture already binded terms at call site. Luckily CL programmers have heard about that and are usually careful about that.
  - vindarel 2y ago
    I mean code generation that writes code to files. I'm afraid they bit rot fast and make upgrading harder. Macros generate code on the fly, not in my source files.
    - mst 2y ago
      I tend to regard code generation as being something that should -feel- like a macro to use, just one that optionally materialises the results so you can ship the code without a dependency on the generation logic. I am very conscious that most code generation in the wild is ... Not That.
medo-bear 2y ago
As far as use cases are concerned, I think of Common Lisp as a higher level C with much better ergonomics. My particular use case is prototyping low level computations for performance tuning. Common Lisp excels at prototyping. I guess if you need to implement something for which there already exist 20 other libraries there is not much point, which is also the reason I'm not a huge fan of Rewrite in Rust movement.
citizen_friend 2y ago
This is an odd question. Web services are great with CL. But you already have languages you prefer. So yes, you must be interested in CL to want to replace one of those.
deleted 2y ago
[deleted]
anthk 2y ago
Maxima, the math CAS.

vindarel 2y ago

It's a great article. Since 2018 though, we have more tools and resources so we can enhance it. (I copy/edit a comment of mine from last thread) ## Pick and Editor The article is right that you can start with anything. Just `load` your .lisp file in the REPL. But even in Vim, Sublime Text, Atom/Pulsar, VSCode, the Jetbrains suite or Jupyter notebooks, you can get pretty good to very good support. See https://lispcookbook.github.io/cl-cookbook/editor-support.html https://lispcookbook.github.io/cl-cookbook/editor-support.ht... > if anyone is interested in making a Common Lisp LSP language server, I think it would be a hugely useful contribution to the community. Here's a new project used for VSCode: https://github.com/nobody-famous/alive-lsp https://github.com/nobody-famous/alive-lsp There's also https://github.com/cxxxr/cl-lsp https://github.com/cxxxr/cl-lsp ## Libraries He doesn't mention this list, what a shame: https://github.com/CodyReichert/awesome-cl https://github.com/CodyReichert/awesome-cl => the CL ecosystem is probably bigger than you thought. Sincerely, only recently, great packages appeared: CLOG, sento (actors concurrency), 40ants-doc, official CL support on OVH through Platform.sh, great editor add-ons (Slite test runner, Slime-star modules…), Coalton 1.0 (Haskell-like ML on top of CL), April v1.0 (APL in CL), a Qt 5 "library" (still hard to install), many more… (Clingon CLI args parser, Lish, a Lisp Shell in the making, the Consfigurator deployment service, generic-cl)… His list is OK, I'd pick another HTTP client (Dexador instead of Drakma) and another JSON library (jzon or shasht), new ones since 2018 too, but that's a detail. BTW, see also a list of companies: https://github.com/azzamsa/awesome-lisp-companies/ https://github.com/azzamsa/awesome-lisp-companies/ (nothing official, we add when we find one) ## Other resources The Cookbook (to which I contribute) is a useful reference to see code and get things done, quickly. https://lispcookbook.github.io/cl-cookbook/ https://lispcookbook.github.io/cl-cookbook/ While I'm at it, my last shameless plug: after my tutorials written for the Cookbook and my blog, I wanted to do more. Explain, structure, demo real-world Common Lisp. I'm creating this course (there are some free videos): https://www.udemy.com/course/common-lisp-programming/?couponCode=SUMMER-LISP-2206 https://www.udemy.com/course/common-lisp-programming/?coupon... You'll learn CL efficiently and support an active Lisper. ## Web Development See the Cookbook, and the awesome list. We have many libraries, you still have to code for things taken for granted in other big frameworks. I have some articles on my blog. I have a working Django-like DB admin dashboard, I have to finish the remaining 20%… We have new very cool kids in town, especially CLOG, that is like a GUI for the browser. Check it out: https://github.com/rabbibotton/clog https://github.com/rabbibotton/clog ## Game Development See again the awesome-cl list. And the Kandria game, published on Steam, all done in CL: https://kandria.com/ https://kandria.com/ ## Unit Testing We have even more test frameworks since 2018! And some are actually good O_o ## Projects To create a full-featured CL project in one command, look no further, here's my (shameless plug) project skeleton: https://github.com/vindarel/cl-cookieproject https://github.com/vindarel/cl-cookieproject you'll find the equivalent for a web project, lighter alternatives in the README, and a demo video: https://www.youtube.com/watch?v=XFc513MJjos&feature=youtu.be https://www.youtube.com/watch?v=XFc513MJjos&feature=youtu.be ## Community We are also on Discord: https://discord.gg/hhk46CE https://discord.gg/hhk46CE and on Libera Chat. ## Implementations CLASP (CL for C++ on LLVM) reached its v1.0, congrats. https://github.com/clasp-developers/clasp/releases/tag/1.0.0 https://github.com/clasp-developers/clasp/releases/tag/1.0.0 More are in the making… We got dynamic library delivery tool for SBCL (sbcl-librarian). There's a rumor from the European Lisp Symposium that a feature beginning in "co" and lasting in "routine" is coming to SBCL. Allegro CL (proprietary) got a new version running in the browser… Crazy Lisp world <3

huygens6363 2y ago

I love the concept of the REPL and live editing and such, but my everyday work experience using a debugger sounds like it’s about 80% of the way there? I can break, inspect, run expressions and generally figure out what’s going on by experimenting. Maybe not edit code directly, but I honestly never feel the need. Looking and poking around is in the vast majority of cases all I need. Am I missing something incredible?

7thaccount 2y ago
In a lot of cases... probably not in my experience. I think it can make a big difference in some cases though. What REPL were you using though? Something to think about is that the Lisp and Smalltalk REPLs are a lot more powerful than Python in that I think when an expression fails, the program itself can be edited and it will start where it left off. You can't do that with Python. Edit: the article does a good job of explaining this as "It's like if you could run your code in a debugger with a breakpoint at every single line that only activates if something goes wrong!"
- huygens6363 2y ago
  Modern (proprietary) tooling comes really close to that experience, but I can see how it is liberating compared to editing text files, waiting for compilation and preying it works. I guess modern tools learned from the best.
  - 7thaccount 2y ago
    I've seen this with C# lately. The tools have come a long way as a lot of languages have gotten closer to the good ideas of lisp over the years.
vindarel 2y ago
I suggest: do you find yourself often quitting the debugger and re-running the same test, the same task from the start? You can avoid that in CL. Just leave the debugger open, go to the buggy line ("v" on a stacktrace in Slime), fix the function, re-compile it on the fly (C-c C-c in Slime), come back to the debugger, resume the program from the stackframe you want, now it passes. If the first steps were taking 10 minutes, you just saved yourself some time. You don't need special needs for that, it's a fast workflow I use everyday. demo: https://www.youtube.com/watch?v=jBBS4FeY7XM https://www.youtube.com/watch?v=jBBS4FeY7XM debugging a complex stacktrace: Python VS CL: https://lisp-journey.gitlab.io/images/debugging-python-VS-lisp.png https://lisp-journey.gitlab.io/images/debugging-python-VS-li... Another important point: we debug everything while keeping the current state in memory (in the image). We don't have to re-create our test data. All the program state is kept live, until we restart the image.

next_xibalba 2y ago

This comment could read as provocative but it is not intended to be. It’s a genuine question: Lisp seems to get outsized attention on HN. If Lisp is so good, why isn’t its use more widespread? *Maybe it’s disproportionate attention on HN is just a pg remnant?

schmidt_fifty 2y ago
People probably just find it interesting
- tmtvl 2y ago
  I don't know why you're getting downvoted, this is a reasonable take and it's even in the guidelines: > On-Topic: Anything that good hackers would find interesting.
BeetleB 2y ago
And this comment is asked every time a Common Lisp submission comes up. Perhaps go and read prior answers? > If Lisp is so good, why isn’t its use more widespread? What does "good" and "widespread" have to do with each other? Mildly orthogonal concerns. As a tech junkie, one experience that has been consistent all my life is "the best stuff is almost never widespread". When I was in to digital cameras, the "best" camera was rarely the widespread one - both pre-DSLR and after. The best file management utility is not the widespread one. The best radio is not the widespread one. The best TV is not the widespread one. The best SW for a task is often not the most widespread one. I know I'm not answering the question. Instead, I want you to ponder the faulty premise in your question. Instead of tying your question to "widespread", why not simply ask why people like Common Lisp so much? It's like asking "If that job is so awesome, why doesn't it pay well?"
- next_xibalba 2y ago
  > Perhaps go and read prior answers HN is not a knowledge base or docs. It’s a forum. Perhaps you should go and read the HN guidelines?
- 2y ago

deleted 2y ago

[deleted]

ativzzz 2y ago

This article fails to explain why lisp. People talk about it on HN sometimes. This article says "here's how to learn it". Why should I learn it? There's a million languages out now that I can learn instead. The author gives a few ways I can use lisp. Why would I choose lisp over any of the other languages that have stronger ecosystems that solve those same problems and are built specifically for them? The syntax looks arcane and it seems that the most prevalent modern use for lisp is emacs, so if I don't use emacs, why lisp?

uncleshelby 2y ago
Matthew Butterick wrote a book about Racket (a dialect of Lisp) which has a great appendix that tries to explain why Lisp is worth learning: https://beautifulracket.com/appendix/why-racket-why-lisp.html https://beautifulracket.com/appendix/why-racket-why-lisp.htm... There are lots of evangelist explanations for why Lisp is The Best out there, but this is one of the better and more concrete ones.
nomilk 2y ago
Not sure how much other languages developed in 22 years since this essay, but PG makes the case for lisp here: https://paulgraham.com/icad.html https://paulgraham.com/icad.html Computerphile riffs on the importance of homoiconicity and the ability for a language to programatically alter itself: https://www.youtube.com/watch?v=dw-y3vNDRWk https://www.youtube.com/watch?v=dw-y3vNDRWk Uncle bob had tried many languages and settled on lisp: https://www.youtube.com/watch?v=UBXXw2JSloo&t=2m40s https://www.youtube.com/watch?v=UBXXw2JSloo&t=2m40s > for 30 years I thought I don't want to learn lisp, it's a dumb language, and I read (Structure and Interpretation of Computer Programs) and it changed my mind... I thought I'm going to get (clojure) and dither around with it.. and I just fell in love with the language and I've been using it ever since
lgrapenthin 2y ago
The article is not trying to sell you on Lisp, in its first sentence it clarifies, that it is written for people who were "asking for advice on how to learn Common Lisp"...
deleted 2y ago
[deleted]

julianeon 2y ago

There's some serious cognitive dissonance going on in this section: As an open-source project, Racket is positioned at a happy medium. The core development team has been working together for years, and the commits remain fast & furious. But they’re friendly scientists, not Shire-dwelling egotists, and remain receptive to improvements across the whole system. If you have a better idea, they’ll listen; if you code it up to their standards and make a pull request, they’ll take it. [2021 update: I no longer contribute to Racket due to abuse & bullying by the project leadership. Everyone in the broader Racket community, however, has always been helpful and kind.]

vindarel 2y ago
Wrong thread? There is no mention of Racket here.
- Jtsummers 2y ago
  My guess is they meant to respond to this comment: https://news.ycombinator.com/item?id=40442347 https://news.ycombinator.com/item?id=40442347 But somehow didn't hit reply and just made it a top level comment instead.
Jtsummers 2y ago
That's not cognitive dissonance, that's "I wrote a thing when I held one view. Instead of changing it entirely here is an additional comment that revises my previous one. I'm not going to edit the original." The order of things matters. "I hold this view which contradicts my earlier, no longer held, view." is not cognitive dissonance. "I hold this view despite it contradicting my other view." is cognitive dissonance.

barrenko 2y ago

Lisps are great to challenge your thinking, but (with Clojure) I got stuck at making sense of macros — way out of my depth at that moment in time.

Jtsummers 2y ago
I'd recommend studying some existing macros and spending time recreating them. Starting with simple use-cases of the macro and working up. Repeat this with a few macros and you'll eventually learn how they operate. Let Over Lambda is also a good (opinionated) book on macros (most of the book is available for free), and of course there's PG's On Lisp (jump to page 95 in the PDF if you're already comfortable with Lisp). https://letoverlambda.com/index.cl/toc https://letoverlambda.com/index.cl/toc https://paulgraham.com/onlisp.html https://paulgraham.com/onlisp.html
- barrenko 2y ago
  Thank you!
iLemming 2y ago
> I got stuck at making sense of macros Are you simply staring intently at the macros, trying to make sense of them, or are you actually utilizing the macro-expanding feature in your editor? Or perhaps you're grappling with writing macros yourself? Macros can be tricky, which is why Clojurists often avoid creating new ones unless there's a compelling reason to do so. There's an old book called "Mastering Clojure macros", it's tiny - fewer that a hundred pages. It helped me back when I was learning Clojure.
- barrenko 2y ago
  more trying to understand really, this blew my mind at a time https://aphyr.com/posts/305-clojure-from-the-ground-up-macros https://aphyr.com/posts/305-clojure-from-the-ground-up-macro...

troad 2y ago

I recently posted my observations about taking an interest in Common Lisp and a few people kindly pointed me to this resource, which was very, very helpful. If you, like me, are drawn to Lisp because of its reputed elegance, just bear in mind that Common Lisp is probably the least elegant of the Lisps, though probably the most mature. It uses dated mnemonics that won't be intuitive to someone coming from modern languages, and in many ways it's surprisingly hacky. I've been pointed at Scheme, Clojure, and Racket for examples of more elegant Lisps, with Clojure probably being the most day-to-day useful of the three (albeit sadly it runs on the JVM - talk about the Beauty and the Beast). The two big (but very basic) observations that made Lisp click for me: (A) Those nested parentheses directly indicate the AST of a Lisp program - Lisp syntax doesn't just feature lists, Lisp syntax is those lists (Lisp = LISt Processing). A Lisp program is just a single list made up of other lists. There's almost no other syntax you have to learn. Operators are just functions, which are just lists. (B) Working with a REPL allows you to climb inside of a program in a way that working with an 'Algolian' language doesn't. All the functions are there for you to play with. Using a REPL seems to be iterative; programmers will work in text files (in e.g. emacs) and then jump into a REPL every now and again to test and prod and poke at the code. Cumulatively, those two insights I think define what is special about Lisps. Since everything is a list, you program by defining more complex lists around simpler lists, which - like Legos - you can freely manipulate with a REPL. This allows you to build programs from the inside out, compared to Algolian languages. You can build all the bits and pieces well before there's any main() method to unite them. It's not theoretically impossible to work with C or Rust like this, but the tooling around Lisp makes this easy and fundamental. On the flip side of this, how one is meant to distribute finished Lisp programs is very unclear to me. It appears that to ship a Lisp program you basically ship the entire development environment, plus all your source code, and point the former at the entry point to the latter. I'm almost certainly missing something obvious here though, and I'm happy to be enlightened on this point. I honestly don't know how one would distribute a closed-source binary where they don't necessarily want the end user to be able to use a REPL on the code. There appears to be a proprietary compiler called LispWorks that can do this, but with prices in the four figures that's far too dear for a merely intellectual curiosity about Lisp. (There's a hobbyist edition of LispWorks, but my policy is not to spend time learning tools I couldn't turn to professional use.)

e12e 2y ago

(2018)

sapling-ginger 2y ago

The author first says that CL people usually avoid dependency hell: >When programming applications in Common Lisp people will often depend on a small(ish) number of stable libraries, and library writers often try to minimize dependencies by utilizing as much of the core language as possible. But then try to expound on CL's extensibility using libraries: > No one has been clamoring for a new version of the specification that adds features because Common Lisp's extensibility allows users to add new features to the language as plain old libraries Very contradictory, and these two paragraphs are in two adjacent sections.

mepian 2y ago
How is this contradictory? The point is that you can extend the language when you really need it.
fuzztester 2y ago
I don't see any contradiction in those two points. Both of them can simultaneously be true.
deleted 2y ago
[deleted]
iLemming 2y ago
As other pointed out, there's no contradiction. I would like to add that CL often avoids dependency hell with: - Standardized Specification: Common Lisp has a stable and comprehensive standard that reduces the need for external libraries. - Load Time Flexibility: Its dynamic nature allows loading and reloading of code at runtime, facilitating easier management of dependencies. - Isolation through Packages: The Lisp package system provides a way to encapsulate code and manage namespaces effectively, reducing conflicts. - Backward Compatibility: Common Lisp places a strong emphasis on backward compatibility, which helps in maintaining stability across versions. - Mature Ecosystem: Many Common Lisp projects are long-lived and stable, leading to a mature ecosystem with less frequent breaking changes. I can't claim to be a very experienced CL coder, but I wrote enough Clojure, and similarly, rarely ever see dependency problems, even though Clojure heavily relies on the JVM ecosystem, inheriting both its strengths and complexities. Clojure emphasizes interoperability with Java and uses many Java libraries, which can introduce complex dependency trees and conflicts common in the Java ecosystem, yet at the same time, Clojure emphasizes small, composable libraries (often referred to as the "small libraries" philosophy), reducing the likelihood of large, monolithic dependencies causing issues. The community prioritizes modularity and ease of composition, leading to the prevalence of smaller, more focused libraries. Common Lisp in contrast tends to favor more extensive libraries or systems that provide a broad set of features within a single package.

deleted 2y ago

[deleted]

dang 2y ago

Related: A Road to Common Lisp (2018) - https://news.ycombinator.com/item?id=31645558 https://news.ycombinator.com/item?id=31645558 - June 2022 (48 comments) A Road to Common Lisp - https://news.ycombinator.com/item?id=17852194 https://news.ycombinator.com/item?id=17852194 - Aug 2018 (92 comments)

nomilk 2y ago

Great read. Highly fond of long single-pagers. Curious why lisp's REPL is frequently touted as an incredible language feature e.g.: > Support for this style of interactive development doesn't just come from some fancy editor plugins — it's baked into the bones of the language. > So how do you actually get this wonderful interactive experience? I've only ever programmed in interpreted languages (R, ruby), so I can't really understand how or why a REPL is so great since to me a (console|REPL|interpreter) is a standard feature (nothing extraordinary). Perhaps because I haven't had to work in a language without the convenient and immediate ability to execute arbitrary user inputs (as a REPL or interpreter can), for example a compiled language.

sourcepluck 2y ago
I think this relatively short blogpost does an excellent job of answering your question: https://mikelevins.github.io/posts/2020-12-18-repl-driven/ https://mikelevins.github.io/posts/2020-12-18-repl-driven/
julianeon 2y ago
I can think of a REPL use case I don't know how to do easily in another language. Doable yes, but easily and conveniently, no. I want to build a little tool for the command line: meaning it should be runnable at any time I pull down my terminal, easily started and stopped. In it, I want to listen to a Telegram room. Basically the idea is, in this Telegram room, things are announced, and I want to look up some of them. It could be anything: sneakers, toys, concert tickets. But let's say crypto projects, as there is a running stream of them all day. (Doesn't have to be if you don't like crypto but let's go with it for now). So I'm printing this list of crypto projects to the screen. Every so often I want to hover over one and get more information about it. For example, pretend there's a project called PGPalooza, one of many that's being printed in this list that's spilling out in real time on my terminal screen. I scroll up to PGPalooza and run a command on it, and then it runs some commands and opens up a few browser windows that I can look at to learn more about it. This is easy to do in Lisp, in an intuitive natural way, that I don't think I could do with the same ease in other languages. You could think of this as demonstrating the benefits of interactivity in action. I can scroll up and modify the PGPalooza text to read lookup("PGPalooza") and then press Ctrl-E at the end to return one type of data, and financials("PGPalooza") to see another. It's also very easy to modularly add commands to it too, to expand on this.

b3lm0nt 2y ago

I wanted to love Common Lisp, but as a Vim user every day was a struggle. One typically uses plugins (Slimv, Vlime) that contort buffers in bizarre ways in order to simulate the SLIME EMacs REPL — if not, they will lose out on the interactive development experience that is so central to CL. Being tied to either EMacs or an enterprise solution like LispWorks to get the full language experience was ultimately a non-starter. I’d love for someone to build an alternative CL development experience that could work in a wider range of text editors and IDEs. There is a lot to learn from CL, but I think it can be hard to access for most developers.

massysett 2y ago
The author of “Let Over Lambda” dislikes Emacs and does not use it. What’s more, he didn’t use Slimv or anything like it or even Vim at all. He used a more basic vi, maybe nvi. So perhaps the interactive experience is not essential. You can just edit and compile like you would in C. That’s not what I do—-I use Slime—but it is possible. Also, a lot of the interactivity is required by the standard to be built in to your Lisp’s REPL, so you can do quite a bit if your REPL isn’t primitive. SBCL doesn’t even have readline but you can use rlwrap. https://letoverlambda.com/ https://letoverlambda.com/
- amno 2y ago
  > The author of “Let Over Lambda” dislikes Emacs and does not use it. I have no idea what Hoyte like to type in, but why does it matter what text editor he uses? Einstein didn't had any computer, not even a calculator. Do we have to use paper and pencil for all the calculations just because Einstein did? Our physics teacher in gymnasium, forced us for 4 years to do all calculations on tests by hand, at four decimal places, with that exact excuse: Einstein didn't have a mini calc. Non of us have become a Nobel prize taker in physics :). > Also, a lot of the interactivity is required by the standard to be built in to your Lisp’s REPL, so you can do quite a bit if your REPL isn’t primitive. Mnjah; not so much really. Using at least SBCL from plain command line really sucks. If you mistype something you have to retype everything, no history, etc. > SBCL doesn’t even have readline If you are on some *nix OS, you can get a long way by just using SBCL with built-in sb-aclrepl + linedit. Aclrepl gives you "command-like" stuff, similar to ":" in Vi (or M-x in Emacs), and linedit adds cursor motion, history and some basic completion. I would still not type entire programs in repl, but for running and testing the code it is a basic survival kit. For me personally it is enough. There is also cl-repl package which gives you native bindings and some extras if you want to go all-in readline from within the lisp itself.

ngcc_hk 2y ago

This totally changed me and enjoy lisp so much more using vim. No more emacs. https://susam.net/lisp-in-vim.html https://susam.net/lisp-in-vim.html

anentropic 2y ago

> JSON support in Common Lisp is a god damn mess Is the JSON situation any better now in 2024?

cess11 2y ago
JSON is a messy format, you'll always have to know your requirements well to be able to pick a fitting parser for it. Are you going to parse a simple, small key-value-structure? Pretty much any library will solve it for you or you could invent your own simple parser. If you need to stream gigabytes of complicated JSON and do sophisticated transformations back into JSON or something like that, then you'll have to evaluate several libraries and have a look at how they translate into CL datatypes. Some might reduce a combination of false, null, the empty list to NIL, which could lead to information loss and surprises.
varjag 2y ago
This piece is enthusiastic but a bit subjective. I personally had zero troubles with JSON in CL, just chose one library and use it. Would also disagree with some his recommendations, e.g. Drakma has a lacking interface for error handling and Dexador is nicer for use in prod.
ludston 2y ago
Yes. The trend is towards standardizing on an library called jzon. It's pretty decent.