What does HackerNews think of awesome-cl?

If it's all good, sounds like that's a reason to learn it. ;) But I have to push back some -- I mean you can work alone and build your own castles from scratch if that's your thing (I totally understand that appeal), as in any language, but you don't have to. There are libraries, some quite good, here's an incomplete collection: https://github.com/CodyReichert/awesome-cl It's also easy to interface with C libraries or Java libraries, there are options to interface with C++ and Python. There are also communal projects with more than one active developer if you wanted to work on such group things, and some companies here and there.

A google search would point you towards Hunchentoot, and https://github.com/CodyReichert/awesome-cl to a couple choices.

but who's presenting CL as the answer to your needs? (me?)

If you're happy with your mix of Python and Hy, well, great. But you know what, you can do what you described with CL too! Need to do some webscraping? Beautiful Soup -> lquery. Django -> well… no CL framework gives you all these batteries included, but what if you want to extract data from a Postgres DB and display it in a web app? that's very easy [1] in CL too. Django ORM -> postmodern or Mito (or more). IDK about Nix but several people are working with CL and Guix.

https://github.com/CodyReichert/awesome-cl

What worked out for me was to write companion services in CL, instead of extending my big Django app. This new service that takes data from a FTP server, transforms it, stores it, displays it in a web app? CL. That web app that serves another kind of customers than the Django one? A CL app. It isn't for everybody and sometimes you wish for a bigger ecosystem, but anyways, many things can be done in CL.

[1]: ok honestly the learning process was not that easy. It's a bit easier with my contributions now! (Cookbook etc)

This set of jupyter + autoreloads + editor features might get you close, but you won't be on par to CL's level. I'm thinking about CL's interactive debugger, and about language features that were thought with interactivity in mind. On an error, you get the interactive debugger, you can explore the stack frames and get to the erroneous function, change it, recompile it, come back to the debugger and ask it to resume progress from this point, and see execution pass. You didn't have to re-run the whole operation. If we can do that in Python, I've been in my cave for too long^^ As such, this is how debugging a complex program looks like in Python vs in CL: https://lisp-journey.gitlab.io/images/debugging-python-VS-li... (Ravenpack [1] is a company that does big data analysis and that uses CL, they gave some talks, maybe you'll find more practical reasons from them)

for the second point: https://mikelevins.github.io/posts/2020-12-18-repl-driven/

There might be more CL libraries than you think: https://github.com/CodyReichert/awesome-cl but I'm not that a zealot to say you can ignore Python's ecosystem, especially in certain areas…

[1]: https://www.ravenpack.com/

The Lisp ecosystem is in excellent shape. Here's a nice curated list of libraries[1].

[1] https://github.com/CodyReichert/awesome-cl

mmh Elixir definitely has its gems and I need to try it for real. Where I can see it's lacking: no compile-time type warnings (unless you're using a new language on top or using a third-party library, but then we should compare more thoroughly), no compilation with a keystroke function per function. No static executable (even though deployment options are getting better in Elixir (we had to wait though)). Some compilation times, when you change one file and Elixir needs to compile a dozen. We are not inside a live image. I tried Alchemist mode for Emacs: no function signature? No "eval this expression"? Can you switch projects from inside a REPL, or you have to start a new one? No cross-reference capacities built-in? (who calls this function, this macro, who sets, etc) No inspect? No trace? No interactive debugger and no stepper? If only available with LSP and VSCode, then it's strictly inferior. Elixir is less performant in crunching numbers. Less to no GUI framework choice (WxWidgets). No industry-grade theorem prover? (ACL2) Unfit for quantum computing? Unable to program Intel chips? (Barefoot Networks) No computer algebra system? No music composition suite (Opus Modus)?

CL's ecosystem might be better than one thinks: https://github.com/CodyReichert/awesome-cl & https://lisp-journey.gitlab.io/blog/state-of-the-common-lisp...

I invite you to read https://www.dreamsongs.com/Files/Hopl2.pdf which was submitted for the History of Programming Languages conference in 1993. I don't see how you can say with a straight face that no one rallied around Common Lisp given knowledge of Lisp history. (Edit: Uncut version: https://www.dreamsongs.com/Files/HOPL2-Uncut.pdf or you can just read this from 2008 which is the main thrust of the uncut content, mainly that there's a cycle of diversification and consolidation with CL consolidating a lot https://www.dreamsongs.com/Files/PatternOfLanguageEvolution....)

I'm not sure what you mean by "no canonical implementation" -- there's the ANSI Common Lisp standard, of which there are multiple implementations. Is this somehow a bad thing to you?

> Lispers love to say "Lisp is a family of related languages"

Not really. I think it's slightly more common for Scheme or Clojure programmers to claim Lisp relations, but it's just advertising. If having s-expression-ish syntax (with nothing being compatible to CL like a real Lisp dialect would be, and was given how much code in pre-CL Lisps could be run in CL unmodified) makes it part of the "Lisp family", then why not speak of the ALGOL family? It's tiresome semantics and from what I've read Common Lispers at least don't tend to do it.

> There's just no ecosystem of reliable, standard-ish packages.

Here's everything on Quicklisp: https://sabracrolleton.github.io/short-descriptions and a curated list: https://github.com/CodyReichert/awesome-cl

Yes, it's not as impressive as Maven. Yes, not everything is as well-documented as, say, PyGame (http://www.pygame.org/docs/ -- though not every Python library you'll find with pip is, either) or even the Common Lisp Hyperspec (http://www.lispworks.com/documentation/HyperSpec/Front/Conte...). Yes, some things are broken, or even abandoned, though in the latter case it may just be that they're "done" pending anyone coming up with a new issue or feature request. I've happily used web scraping libs to save my HN comments with their context, there's a good Twitter API lib I moved to when something broke the Python one I was previously using, I've orchestrated Selenium, I generated some FFI bindings to FMOD and had it working within a few minutes... My point here is just that there is an ecosystem for CL, and many things are reliable, when something works it's rare to stop working. Sorry about your GPIO experience, it happens, I had a bad experience trying to quickload a library that depended on iolib which opaquely depends on a custom C library the author also made and is not in my distro's package manager.

I'm not sure what you mean by "standard-ish" -- is Python's urllib3 "standard-ish"? What about urllib and urllib2? Do they qualify merely by being part of the standard library, or is it something else? My other guess is you mean something like "X is a common area of development in the current year, are there any packages dedicated to that area, what are they, and are they any good?" But this is a shaky categorization and in other languages changes all the time, not worthy of the attribute "standard" or even "standard-ish".

You're right though that what does exist is small and limited, and that's a natural limiting factor to growth, far more I think that what editors are available or easy to use. Quicklisp came about way too late. Yet the ecosystem continues to grow, so maybe you'll be willing to give it another chance in another 10 years.

https://github.com/CodyReichert/awesome-cl there are less than in Java-land but there might be more than you think. And there are options for the rest.

You can use CL for everything[0] :] As for text editors, there's Lem and LispWorks

https://github.com/CodyReichert/awesome-cl

https://github.com/lem-project/lem/

https://lisp-journey.gitlab.io/blog/discovering-the-lispwork...

Just confirming these libraries are there for CL.

(https://github.com/CodyReichert/awesome-cl/ for a start)

> I'm explaining why Lisp is hard to learn.

It is not hard to learn in general, there are too many counterexamples of people of all sorts and skills learning it without these issues you are having, learning it as their first, learning it later in their careers... (CL is big, I'll give you that, but each piece can be chewed one at a time and does not seem to be individually that difficult.) So I can hypothesize why it's hard to learn for you. My first guess is still that you aren't meeting Lisp in its own terms and are trying to make Lisp fit your mental model of some other language and its ecosystem. This isn't going to work, and the failure mode (if I'm right) has nothing to do with Lisp but with biases in general heuristics of learning.

You don't need to "unlearn" the way you're used to doing things, but you do need to separate yourself from it for a bit until you actually grasp the Lisp (and its ecosystem's) way(s) and can then see the connections, tenuous and non-existent as some may be. I'll risk raising some of those connections below, but really, things need to be understood on their own terms first or you wind up with misconceptions. (I've seen it multiple times with Java/Python programmers getting confused at the other's "import" statement.)

> strange terminology

It's not Lisp's fault that it's old. Being old means it will have terminology that may be alien to what we have today with nothing today being a perfect fit, or alternatively sometimes it expresses mostly what we say today in a different way. (And when you talk about concepts, not just pure language features, you run into incommensurability. See https://dreamsongs.com/Files/Incommensurability.pdf for an example with Mixins.)

CLOS for example has these things called "slots" which are more or less "fields" or "class/instance variables" in later OOP languages. But it's best to think of them as CLOS slots, so that you don't bring along any (mis)conceptions from other languages. It's sometimes amusing how different other OOP systems are given CLOS was the first to be part of an ANSI standard.

> that took place in 2008

I rather like that I can often find things decades old about Lisp and they are still relevant. Systems are at least as early as the Lisp Machine (1979). Perhaps it's worth going to the original description there? I also sort of like this history diving, even if modern sources obsolete the history in every way that matters. But here is the Lisp Machine manual on the topic: https://hanshuebner.github.io/lmman/maksys.xml "The way it works is that you define a set of files to be a system, using the defsystem special form, described below."

Is that unclear? Systems are first and foremost sets of files. Systems also let you define relations between files, primarily which files depend on which other files, as further sentences reveal.

If you're talking about this page as the first result: https://common-lisp.net/~mmommer/asdf-howto.shtml I agree it's an awful guide. I've never seen it before, it's a shame it's the #1 result. You'd be best served by ignoring it. Systems have nothing to do with CLOS, I assume that guide started trying to use animal parts as a way to elucidate dependencies. (A tail doesn't actually depend on legs though?)

I don't recall how I learned systems, probably because a mix of ASDF's manual (https://common-lisp.net/project/asdf/), this best practices guide linked from ASDF's home page (https://gitlab.common-lisp.net/asdf/asdf/blob/master/doc/bes...), just looking at example asd files of popular libraries and applications (https://github.com/CodyReichert/awesome-cl), a short ebook I occasionally shill (https://www.darkchestnut.com/book-common-lisp-application-de...), and just actually writing enough lisp and making my own library, were in part or all together enough. When you're actually writing software, you can just incrementally compile and load your files (or just eval chunks you've selected with the editor), or if you made a bunch of changes across the whole project then you can just reload your system (if you've defined it) and have everything recompiled and reloaded for you.

It's worth noting that systems are not part of the ANSI Lisp standard, though. Just as Maven is not part of Java. If you jump straight to Maven without first understanding how to create a Java program with multiple files using javac and jars, you might have a hard time later. Lord knows plenty of people get by relatively fine skipping around though (and might not even touch Maven directly, just do everything from an IDE); you can do this with Lisp too, but you seem to want to understand things more fundamentally.

Probably what you need to understand most is the core function "load" (http://www.lispworks.com/documentation/HyperSpec/Body/f_load...). After that you probably want to know about packages (which are akin to namespaces -- bags of symbols, if you already know what 'symbol' means in the CL context). You may wish to know about the "modules" mini-feature enough to know it's deprecated and doesn't really provide anything like what you think a module system should, so no one uses it, and that this mini-feature is independent from something else you might find rarely mentioned in ASDF that is unhelpfully called a 'module'.

> packaging in lisp?

Lisp itself doesn't have a notion of "packaging" in the meaning I'm inferring from you, so your question is wrong on its outset. It just has things like compile-file and load. If you like, you can loosely refer to a directory of files you load one by one as a "package" or a "library". You can define a system for those files with ASDF, and treat "loading the system" as something like "loading the library". When you want to get other "libraries" (directories of files -- just like python eggs or java jars, but lisp libs aren't compressed into zips) from the internet, or publish your own, the community standard is https://www.quicklisp.org/beta/

Sorry if this is just more unhelpful text, I can feel your frustration even if I don't fully understand it. I do agree that being alien is a detriment to Lisp's popularity, but that's not going to change. You might find some leverage by working at CL from the less alien Clojure as a starting point. I always thought this two part talk on Clojure for Java Programmers was really good, but the last person I sent it to dozed off watching it, so your results may vary: https://www.youtube.com/watch?v=P76Vbsk_3J0

There is an ecosystem though https://github.com/CodyReichert/awesome-cl

Have another look at https://github.com/CodyReichert/awesome-cl maybe? There might be more than you think. I know I have regularly discovered great libraries the last years.

A great article on compile-time computing (with CL): https://medium.com/@MartinCracauer/a-gentle-introduction-to-...

There are good references and snippets on the Cookbook: https://lispcookbook.github.io/cl-cookbook/

for libraries, see https://github.com/CodyReichert/awesome-cl (and see the lparallel or lfarm libraries, channels, cl-gserver, the built-in SBCL threading functions, etc)

Also note that CL is not purely functional, you can throw in FP or OOP or iterative code.

Common Lisp seems to tick the boxes. The syntax is stable and it doesn't change. New syntax can be added through extensions (pattern matching, string interpolation, etc). The language is stable, meaning code written in pure CL still runs 20 years later. Then there are de-facto standard libraries (bordeaux-threads, lparallel,…) and other libraries. Implementations continue to be optimized (SBCL, CCL) and to develop core features (package-local-nicknames) and new implementations arise (Clasp, CL on LLVM, notably for bioinformatics). It's been rough at the beginning but a joy so far.

https://github.com/CodyReichert/awesome-cl

I find the package manager actually great. Quicklisp works with monthly "distributions" that are tested to load together, rather than libs that must be strictly pinned and updated separately like everywhere else. I can understand the ecosystem problem, but it might be way better than one thinks: https://github.com/CodyReichert/awesome-cl

Also, Quicklisp can be completed with http://ultralisp.org/, a distribution that builds every 5 minutes and to which it is trivial to add a library. There's also Qlot for local dependencies, and more.

I'd pitch:

- it's all interactive and that's a productivity boost. Write a function, compile it (yes, compile function by function), see warnings or get a debugger on errors, try it right away. Same for web development. No process has to restart to test your changes.

- build a self-contained executable: a joy to deploy.

- strong typing, catches many common errors (and coming: an ML extension for CL: https://github.com/stylewarning/coalton, already used in a large Rigetti codebase)

- stable.

- fast

- take in every language feature you want with libraries

- parenthesis: they help to edit code by structure, by semantic units, instead of by line or characters.

- most flexible language. Like Python's decorators or context managers ? Yet they're limited and have their idiosyncrasies.

- unmatched object system, with generic functions that help maintain your logic small.

And there are libraries :] https://github.com/CodyReichert/awesome-cl

Hey they are on the libraries page: https://common-lisp.net/libraries (taken from https://github.com/CodyReichert/awesome-cl)

I recognize Common Lisp in your expectations :] http://lisp-lang.org/ multiparadigm, efficient, super tools (debugger, repl),…

https://github.com/CodyReichert/awesome-cl

It isn't that bad:

- https://github.com/CodyReichert/awesome-cl - http://quickdocs.org/

I've been exploring CL lately.

- IMO the documentation state is not great, but it's being worked on. (it's said to be non-existent for Haskell :p ) CL has many books to learn from (CL recipes of 2015 being the more interesting to me http://weitz.de/cl-recipes/), but the online documentation is not brilliant. Often the web page isn't attractive at all, not every project provides good documentation, the "official" websites are bad (cliki, others). It's being fixed by https://github.com/CodyReichert/awesome-cl, http://lisp-lang.org/, https://lispcookbook.github.io/cl-cookbook/, http://quickdocs.org/ and http://phoe.tymoon.eu/clus/doku.php

- one can feel the language is dating. It has IMO too many weird semantics: no map and filter but map which takes a second argument telling the type of the structure or mapcar and others, remove-if[-not], etc. Creating hash-tables is too verbose and not consistent, et. That all a lot more are fixed in CL21 http://cl21.org/ (its wiki https://github.com/cl21/cl21/wiki). CL21 also offers more functional-oriented stuff like shorter lambdas, lazy sequences, generic functions, or string interpolation, regexp literals, and more. It's a bit under-documented, but its wiki is ok.

- web dev in CL is another topic. I sugest https://stackoverflow.com/a/42838145/1506338 but what's doable now is very elegant.

- CL has a big ecosystem, we can use Emacs/Vim/Atom, Portacle is straightforward is portable and thus straightforward to use (https://shinmera.github.io/portacle/),…