Common Lisp

This page summarizes the projects mentioned and recommended in the original post on news.ycombinator.com

Our great sponsors
  • Scout APM - Less time debugging, more time building
  • OPS - Build and Run Open Source Unikernels
  • SonarLint - Deliver Cleaner and Safer Code - Right in Your IDE of Choice!
  • cl-cookbook

    The Common Lisp Cookbook

    That's my personal opinion, but I think that programming language pages should have more information density. I also think that using your average "startup template" for Common Lisp is a bit weird. A good example of what I like might be the OCaml homepage https://lisp-lang.org/, the Go homepage https://golang.org/. The Haskell homepage has a REPL with a tutorial, which encourages you to play around with the language, I think that's a good idea https://www.haskell.org/. TypeScript's page is also nice https://www.typescriptlang.org/. For something a little bit different, Dhall is also good at quickly demonstrating how it works https://dhall-lang.org/.

    That might just be a consequence of my time on Hacker News, but I think the insistance on Paul Graham is a bit much.

    The chart about server performance felt a bit weird to me, as I think the difference between Ruby and JS would be bigger at least. So I checked on techempower benchmarks (https://www.techempower.com/benchmarks/) and sadly there is no common lisp. It's also not on the last runs (https://tfb-status.techempower.com/). I think putting the origin of the results and a way to reproduce them would be a good thing. I don't doubt that common lisp is fast, but that diagram looks a bit too much like hollow marketing, especially with the image behind.

    The page about OO (https://lisp-lang.org/learn/clos) has a good explanation of multiple dispatch, but I think it should come with an example. The first steps pages (https://lisp-lang.org/learn/first-steps) also explains atoms well, but it doesn't explain lists after mentionning them.

    In general this feels a bit unpolished, though some part are good. There's no mention of the Common Lisp cookbook (https://lispcookbook.github.io/cl-cookbook/), which sadly confirms a bit the "Lisp users all have NIH syndrome" meme.

  • TypeScript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

    That's my personal opinion, but I think that programming language pages should have more information density. I also think that using your average "startup template" for Common Lisp is a bit weird. A good example of what I like might be the OCaml homepage https://lisp-lang.org/, the Go homepage https://golang.org/. The Haskell homepage has a REPL with a tutorial, which encourages you to play around with the language, I think that's a good idea https://www.haskell.org/. TypeScript's page is also nice https://www.typescriptlang.org/. For something a little bit different, Dhall is also good at quickly demonstrating how it works https://dhall-lang.org/.

    That might just be a consequence of my time on Hacker News, but I think the insistance on Paul Graham is a bit much.

    The chart about server performance felt a bit weird to me, as I think the difference between Ruby and JS would be bigger at least. So I checked on techempower benchmarks (https://www.techempower.com/benchmarks/) and sadly there is no common lisp. It's also not on the last runs (https://tfb-status.techempower.com/). I think putting the origin of the results and a way to reproduce them would be a good thing. I don't doubt that common lisp is fast, but that diagram looks a bit too much like hollow marketing, especially with the image behind.

    The page about OO (https://lisp-lang.org/learn/clos) has a good explanation of multiple dispatch, but I think it should come with an example. The first steps pages (https://lisp-lang.org/learn/first-steps) also explains atoms well, but it doesn't explain lists after mentionning them.

    In general this feels a bit unpolished, though some part are good. There's no mention of the Common Lisp cookbook (https://lispcookbook.github.io/cl-cookbook/), which sadly confirms a bit the "Lisp users all have NIH syndrome" meme.

  • Scout APM

    Less time debugging, more time building. Scout APM allows you to find and fix performance issues with no hassle. Now with error monitoring and external services monitoring, Scout is a developer's best friend when it comes to application development.

  • FrameworkBenchmarks

    Source for the TechEmpower Framework Benchmarks project

    That's my personal opinion, but I think that programming language pages should have more information density. I also think that using your average "startup template" for Common Lisp is a bit weird. A good example of what I like might be the OCaml homepage https://lisp-lang.org/, the Go homepage https://golang.org/. The Haskell homepage has a REPL with a tutorial, which encourages you to play around with the language, I think that's a good idea https://www.haskell.org/. TypeScript's page is also nice https://www.typescriptlang.org/. For something a little bit different, Dhall is also good at quickly demonstrating how it works https://dhall-lang.org/.

    That might just be a consequence of my time on Hacker News, but I think the insistance on Paul Graham is a bit much.

    The chart about server performance felt a bit weird to me, as I think the difference between Ruby and JS would be bigger at least. So I checked on techempower benchmarks (https://www.techempower.com/benchmarks/) and sadly there is no common lisp. It's also not on the last runs (https://tfb-status.techempower.com/). I think putting the origin of the results and a way to reproduce them would be a good thing. I don't doubt that common lisp is fast, but that diagram looks a bit too much like hollow marketing, especially with the image behind.

    The page about OO (https://lisp-lang.org/learn/clos) has a good explanation of multiple dispatch, but I think it should come with an example. The first steps pages (https://lisp-lang.org/learn/first-steps) also explains atoms well, but it doesn't explain lists after mentionning them.

    In general this feels a bit unpolished, though some part are good. There's no mention of the Common Lisp cookbook (https://lispcookbook.github.io/cl-cookbook/), which sadly confirms a bit the "Lisp users all have NIH syndrome" meme.

  • go

    The Go programming language

    That's my personal opinion, but I think that programming language pages should have more information density. I also think that using your average "startup template" for Common Lisp is a bit weird. A good example of what I like might be the OCaml homepage https://lisp-lang.org/, the Go homepage https://golang.org/. The Haskell homepage has a REPL with a tutorial, which encourages you to play around with the language, I think that's a good idea https://www.haskell.org/. TypeScript's page is also nice https://www.typescriptlang.org/. For something a little bit different, Dhall is also good at quickly demonstrating how it works https://dhall-lang.org/.

    That might just be a consequence of my time on Hacker News, but I think the insistance on Paul Graham is a bit much.

    The chart about server performance felt a bit weird to me, as I think the difference between Ruby and JS would be bigger at least. So I checked on techempower benchmarks (https://www.techempower.com/benchmarks/) and sadly there is no common lisp. It's also not on the last runs (https://tfb-status.techempower.com/). I think putting the origin of the results and a way to reproduce them would be a good thing. I don't doubt that common lisp is fast, but that diagram looks a bit too much like hollow marketing, especially with the image behind.

    The page about OO (https://lisp-lang.org/learn/clos) has a good explanation of multiple dispatch, but I think it should come with an example. The first steps pages (https://lisp-lang.org/learn/first-steps) also explains atoms well, but it doesn't explain lists after mentionning them.

    In general this feels a bit unpolished, though some part are good. There's no mention of the Common Lisp cookbook (https://lispcookbook.github.io/cl-cookbook/), which sadly confirms a bit the "Lisp users all have NIH syndrome" meme.

  • dhall-lang

    Maintainable configuration files

    That's my personal opinion, but I think that programming language pages should have more information density. I also think that using your average "startup template" for Common Lisp is a bit weird. A good example of what I like might be the OCaml homepage https://lisp-lang.org/, the Go homepage https://golang.org/. The Haskell homepage has a REPL with a tutorial, which encourages you to play around with the language, I think that's a good idea https://www.haskell.org/. TypeScript's page is also nice https://www.typescriptlang.org/. For something a little bit different, Dhall is also good at quickly demonstrating how it works https://dhall-lang.org/.

    That might just be a consequence of my time on Hacker News, but I think the insistance on Paul Graham is a bit much.

    The chart about server performance felt a bit weird to me, as I think the difference between Ruby and JS would be bigger at least. So I checked on techempower benchmarks (https://www.techempower.com/benchmarks/) and sadly there is no common lisp. It's also not on the last runs (https://tfb-status.techempower.com/). I think putting the origin of the results and a way to reproduce them would be a good thing. I don't doubt that common lisp is fast, but that diagram looks a bit too much like hollow marketing, especially with the image behind.

    The page about OO (https://lisp-lang.org/learn/clos) has a good explanation of multiple dispatch, but I think it should come with an example. The first steps pages (https://lisp-lang.org/learn/first-steps) also explains atoms well, but it doesn't explain lists after mentionning them.

    In general this feels a bit unpolished, though some part are good. There's no mention of the Common Lisp cookbook (https://lispcookbook.github.io/cl-cookbook/), which sadly confirms a bit the "Lisp users all have NIH syndrome" meme.

  • ocaml

    The core OCaml system: compilers, runtime system, base libraries

    > A good example of what I like might be the OCaml homepage https://lisp-lang.org/

    That should be https://ocaml.org/ of course :).

  • cffi

    The Common Foreign Function Interface

    I feel inspired to start Lisp after being disappointed with the "open" source scene of 2021. I'd rather pay LispWorks a yearly fee and be left alone than dealing with unbalanced people in the Python space. The free Lisp implementations also look somewhat isolated from the ideological wars.

    However, a C interface is required. Is this one the recommended solution? Is it really portable?

    https://common-lisp.net/project/cffi/

    What is the speed compared to a Python C extension? Are implementation-specific C interfaces faster (I guess they are)?

    Sorry for so many questions, but these can usually only be answered by people who have actually used the interface.

  • OPS

    OPS - Build and Run Open Source Unikernels. Quickly and easily build and deploy open source unikernels in tens of seconds. Deploy in any language to any cloud.

  • CPython

    The Python programming language

    I agree that a language homepage should be information dense, and give the new user a clear overview without having to scroll. I think the Common Lisp homepage is an improvement over what I remember from years ago, and while it’s visually appealing it’s not as immediately useful as I’d like.

    Besides the examples Zababa offered, I’d say the home pages for Ruby, Julia, and Python are also good:

    https://www.ruby-lang.org/en/

    https://julialang.org/

    https://www.python.org/

  • julia

    The Julia Programming Language

    I agree that a language homepage should be information dense, and give the new user a clear overview without having to scroll. I think the Common Lisp homepage is an improvement over what I remember from years ago, and while it’s visually appealing it’s not as immediately useful as I’d like.

    Besides the examples Zababa offered, I’d say the home pages for Ruby, Julia, and Python are also good:

    https://www.ruby-lang.org/en/

    https://julialang.org/

    https://www.python.org/

  • awesome-cl

    A curated list of awesome Common Lisp frameworks, libraries and other shiny stuff.

    This website (and all the author's libraries) was such a refresher. It has been important for me to not run away from CL (again). At that time, the "official" website, the first Google result for CL looked like this: https://web.archive.org/web/20160305135106/https://common-li... Fortunately, they revamped it circa 2018: https://common-lisp.net/ (work mainly due to @mmontone if I'm not mistaken). Since then, the Cookbook was expanded with useful content (it was kind of hard to find up to date information online, on even simple matters like how to build a binary) and we got some useful lists too, like https://github.com/CodyReichert/awesome-cl and a list of (current, existing) companies: https://github.com/azzamsa/awesome-lisp-companies/ Hopefully it's easier than ever to have your questions answered and start hacking in Lisp!

    Another very helpful resource by Fernando was his state of CL ecosystem: https://borretti.me/article/common-lisp-sotu-2015 It really helped have an overview of the ecosystem, pick libraries and work on consolidation. I compiled one for 2020 here: https://lisp-journey.gitlab.io/blog/state-of-the-common-lisp...

  • awesome-lisp-companies

    Awesome Lisp Companies

    This website (and all the author's libraries) was such a refresher. It has been important for me to not run away from CL (again). At that time, the "official" website, the first Google result for CL looked like this: https://web.archive.org/web/20160305135106/https://common-li... Fortunately, they revamped it circa 2018: https://common-lisp.net/ (work mainly due to @mmontone if I'm not mistaken). Since then, the Cookbook was expanded with useful content (it was kind of hard to find up to date information online, on even simple matters like how to build a binary) and we got some useful lists too, like https://github.com/CodyReichert/awesome-cl and a list of (current, existing) companies: https://github.com/azzamsa/awesome-lisp-companies/ Hopefully it's easier than ever to have your questions answered and start hacking in Lisp!

    Another very helpful resource by Fernando was his state of CL ecosystem: https://borretti.me/article/common-lisp-sotu-2015 It really helped have an overview of the ecosystem, pick libraries and work on consolidation. I compiled one for 2020 here: https://lisp-journey.gitlab.io/blog/state-of-the-common-lisp...

  • cl-autowrap

    (c-include "file.h") => complete FFI wrapper

    If you're interested in FFI, then yeah CFFI is the standard. The other comments addressed speed, I also wanted to point out https://github.com/rpav/cl-autowrap which is built on top of CFFI and can help get a wrapper up and running faster. After using autowrap's c-include you can then use CFFI basically like normal or some useful autowrap/plus-c's helper functions -- e.g. in one project, I have an SDL_Event (https://wiki.libsdl.org/SDL_Event) and to access event.key.keysym.scancode I have a helper function that's just (plus-c:c-ref event sdl2-ffi:sdl-event :key :keysym :scancode). Last year I wanted to try out using FMOD, and even though it's closed source and has a (to me) "interesting" API things worked easily: https://gist.github.com/Jach/dc2ec7b9402d0ec5836a935384cacdc... More work would be needed to make a nice wrapper, type things more fully, etc. but depending on the C library you might find someone's already done that (or made a start) and made it available from quicklisp.

  • austral

    Systems language with linear types

    I like Common Lisp but I no longer use it. I'm pretty much completely burned out on dynamic typing. It feels like building on sand. I want calmer programming, even if it's less powerful. At present I'm building a new language[0] with that goal in mind.

    [0]: https://github.com/austral/austral

  • coalton

    Coalton is an efficient, statically typed functional programming language that supercharges Common Lisp.

  • paip-lisp

    Lisp code for the textbook "Paradigms of Artificial Intelligence Programming"

    Norvig's PAIP is what won me over from Scheme to Common Lisp. https://github.com/norvig/paip-lisp

  • racket

    The Racket repository

  • Pipenv

    Python Development Workflow for Humans.

    Here's a good example of unbalanced people: https://github.com/pypa/pipenv/issues/2228#issuecomment-3926...

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts