I keep flipping between Clojure and CL. I like functional programming, so I really like the workflow of Clojure, but the more-interactive nature of CL is incredibly appealing and I like that it doesn’t put so many constraints on you. I love how you can inspect everything and dig into the core of the language so easily and the interactive debugger is insanely cool.

But I just find it so painful to use, all the functions have strange names, docs are shaky especially for libraries, and I just keep bouncing off. I am going to try Advent of Code in CL this year, but I always get tied up in knots with the data manipulation, especially how you seemingly need to use the loop macro for basically everything since there aren’t that many data structure manipulation methods in the standard library. Hashes are also pretty awkward to work with compared to Java Maps or clojure maps.

Also, I can’t shake the feeling that doing all my data manipulation with linked lists is horribly slow, especially since they aren’t lazily evaluated.

ASDF and the package system is like no other language I’ve ever used, which always ties me in knots, too.

Does anyone have any tips? Is there something I’m missing regarding data manipulation, or is it more a matter of breaking through the pain barrier with practice?

  • dcooper8@alien.topBEnglish
    1·
    10 months ago

    Well, for whatever reason, I’d never really learned loop, then I read Paul Graham’s ANSI Common Lisp where he says “for [reasons] the use of loop cannot be recommended,” and henceforth have used that as an excuse for myself never to learn it up to this day.

    “What is so good about lisp” – well first of all I’m not sure exactly what or whom you’re replying to here - I don’t see where my original comment mentioned anything about Lisp being “so good” or whatever kind of straw man you are attempting to assemble here. But since you’ve asked: if you were to press me to justify my choice of Common Lisp for gendl, I would say I first came for the legacy codebases. I happened to know of legacy industrial codebases (still relying on a Gendl-like system from the 1980s) where i felt we could add value. Switching them to an entirely different underlying language infrastructure would not, in my estimation, have added value (at least not within my capabilities). So that’s what brought me in. But then i stayed with CL for:

    1. ANSI standardization and stability. I regularly fire up 20 year old code and it just works. Customer applications in the KBE categories tend to run for decades; they need to know that they’ll be able to upgrade their OSs and implementations without massively breaking their applications.
    2. Strong open-source library support. I can see where the loosely coordinated world of CL open-source could be daunting for a newbie individual coming in and trying to use raw Lisp. As a vendor of a CL-based system, I consider part of our value added to be the consistent, vetted, and configured Quicklisp/asdf snapshot we ship with our releases. Overall, I think the nature of the CL open-source library ecosystem provides a good balance with the rigid, frozen-in-time ANSI standard for the base language. And it’s a small enough community that you can actually get to know folks.
    3. Strong vendor support (Franz Inc in our case, who are about to celebrate their 40th anniversary).

    Ths above items are justifications, but I think what really keeps me working in CL is more the subjective feeling of the whole environment — the interactive redefinition and test cycle, image-based development where you can fire up an image with everything loaded and “ready to go,” built-in debuggers, profilers, macroexpanders, introspectors, editor servers so you can slime into your running server to test, profile, debug, and hotpatch in-place. Stuff like that.

    • noogai03@alien.topOPBEnglish
      1·
      10 months ago

      Oh I’m absolutely not setting you up for a strawman. I just like to hear why people use such a niche language, especially for 35 years. People tend to have pretty interesting reasons, I had a great conversation with a guy who built a startup on Clojure once for the same reason.

      All of this sounds like an excellent reason to use CL, tbh. The standardization and portability is really impressive. I’ve heard that Franz are extremely solid as a vendor - so you use LispWorks as your runtime?

      I think the interesting thing about the CL package ecosystem is that it doesn’t have the ‘move fast break stuff’ mindset of many other languages such as JavaScript. Some libraries like Bordeaux are essentially just finished and require very little work.

      But on the other hand it’s really cool to see all these new attempts to modernize the language with new syntax, etc - that you can even do that is a testament to the language, I suppose.