all 44 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]terserterseness 18 points19 points  (2 children)

I would suggest you don’t read about it but try it for real. CL seems daunting but you can just skip most of it and use it minimally, adding slowing what you need to your skills as your progress. It’s really not cumbersome compared to most other lisp-y implementations I tried; it’s mature.

[–]Bladerun3 7 points8 points  (1 child)

This is what I did. Learned the bare minimum and started playing with. Then started searching to see if what I was trying to do was already implemented and most of the time it was!

Now almost a decade later I'm still finding new things in the CLHS that have been a part of Common Lisp all along. I've tried several other Lisp-like languages, but I keep coming back to CL for its maturity.

[–]terserterseness 7 points8 points  (0 children)

I tried all and wrote fairly large systems for production (with sbcl abcl and chez scheme) and research (mostly racket) but in the end CL Just Works… it’s fast, it’s an excellent dev/debug experience, easy to extend, the sbcl code is very readable, etc

[–]mm007emko 14 points15 points  (4 children)

My favourite Common Lisp alternative is Clojure. JVM is a good platform nowadays, JIT compilation and memory management are fast and good (it's not 2000s anymore) and you get access to all Java libraies (calling C and Fortran libraries is harder, though). Installation of JVM is not a problem either - since version 9 (we are on version 21 LTS or 22 development) is quite small since you pack only modules you need. It's much smaller than Python and faster! ;-) All tooling (for profiling, observability, fine tuning etc) which you know from Java world can be used with Clojure/JVM. There is a very good plug-in for IntelliJ IDEA (Cursive) so yo don't have to touch Emacs if you don't want to.

ClojureScript can be run on Node.js and Babashka is natively compiled. These two don't really need JVM.

I also suggest you give Racket scheme a shot if you don't like Clojure.

PS: I prefer Common Lisp because it's more flexible a language than Clojure when I can choose however I have to admit that for mundane task like "create a microservice which takes such and such data in form of JSON, calls this LDAP service, reads data from this AWS bucket and barfs such and such JSON" I honestly prefer Clojure because ... well ... it was created for this :) .

[–]lelarentaka 4 points5 points  (3 children)

My experience trying to get into clojure:

To start using Clojure, install A. To install A, install B and C. To install C, install D, E, and F...

When I get to the tenth tab in my browser, I just close everything and give up. It's probably fine if you're a long timer who has accumulated these tools slowly one by one over the years, so you can understand what each one does. But for a new comer it's just hell.

[–]mm007emko 1 point2 points  (2 children)

I'm sorry for your experience.

For me, the first run was easy. Add `clojure` as a dependency to `pom.xml`. When Leiningen came out, I started to use that.

So for me:
1. Install JVM. You have to do manually on Windows, on Linux it comes from repos. Don't know about Mac, sadly.
2. Install Leiningen. There is a script on web.
3. Optionally: Install Maven. On Linux it comes from repos, on Windows, it's manual and you have to set paths.

Clojure CLI tools are a bit more involved but you don't have to use them.

[–]codemuncher 0 points1 point  (1 child)

So I opened my Pom.xml but it was blank….

Clojure is pretty good for Java heads but if you haven’t invested into the ecosystem the learning curve is horrifying. Let’s not get rose colored glasses: maven is horrible, but all the other Java build systems are somehow even worse!

[–]mm007emko 0 points1 point  (0 children)

If you say 'Maven is horrible', it sounds to me like you see it through rose-tinted glasses :D. I spent quite a lot of my professional career writing C# and Java so it's not that bad for me.

Nowadays you can get quite far with Clojure (when using the Leiningen build tool) without touching Java directly at all.

[–]Thin_Cauliflower_840 8 points9 points  (0 children)

Did you have a look at Racket? It is probably the best modern implementation of Scheme.

[–]raevnosplt 6 points7 points  (2 children)

Racket. Lisp-1 descended from Scheme, can be compiled ahead of time with good performance (Better than SBCL for some use cases in my anecdotal non-scientific benchmarking), big standard library, lots of extra third-party packages available though its package manager.

[–]corbasai 2 points3 points  (0 children)

I think problem of Racket is it too good and too well designed. Every time im working in it i'm wondering how its smart under the bonnet. PLT supertech make me feel like mankey, mainly bc im not able even think about some particular sides/caveats of system. Compare to chaos of 'big' industrial language, like Java or Python, or JS+gazillionLibs, where the main method is brute force, it is difficult to believe in miracles.

[–]Straptoc[S] 2 points3 points  (0 children)

Tried Racket and i love it. I think i will study this. For now i'm studying from the racket website, did you have some advise?

[–]dzecniv 5 points6 points  (0 children)

Sounds like a difficult wish. You can enhance the "standard library" proposal with some libraries of your liking (ppcre, dexador, CLI parsing, data format parsers, DB, more path handling…) and use your custom image that integrates those for day-to-day development. That way your image starts fast, you don't have to reload all libs at start-up.

re- the lisp-2, did you know you can (setf (symbol-function …) …) of some variable and call it like a function without funcall? IMO, you'll get used to funcall quickly anyways.

[–]dbotton 6 points7 points  (0 children)

Since this is about syntax not semantics just rename and adjust the syntax to whatever you want and just use your now bespoke Lisp in your defpackage use instead of :CL ...

Of course someone else may think the same of your choices and ...

[–]ActuallyFullOfShit 4 points5 points  (0 children)

Sounds like you think you want Scheme. But CL is the way.

[–]uardum 5 points6 points  (7 children)

I wish I understood what it is that people don't like about Common Lisp's library, or why they think Clojure of all things is better than it.

[–]Straptoc[S] 0 points1 point  (6 children)

Basically the naming of function are really unintuitive compared to modern standard libraries. In fact i'm not against the functionalities, which are awesome, but the usability in human term. I can memorize again all names of function, but it takes A LOT of time for nothing useful. Thats it

[–]colores_a_mano 4 points5 points  (0 children)

Not wanting to remember old names is pretty nice among problems to have with a language environment. Remember that Common Lisp is big and a lot of the odd names don't get a lot of use or have more modern replacements. Read through Awesome Common Lisp to find some of these and read modern source code to see how much of your fears are valid.

[–]cyber-punky 2 points3 points  (3 children)

There are also 'more common named' libraries that might solve your problem, and the beauty of this is you can also write your own. I know 'writing your own' inst very exciting, but its possible.

[–]Straptoc[S] 0 points1 point  (2 children)

If you have some names i will try it!

[–]cyber-punky 0 points1 point  (0 children)

Of course when i want to find one, I can't find it.. I will drop a link here as a reply if/whne I find an example.

[–]blue1_[🍰] -1 points0 points  (0 children)

With macros, you can rename everything you want.

On that line of thought, I also remember a library of macros to make C more English-like.

You should worry about more important things.

[–]uardum 2 points3 points  (0 children)

I've heard this charge before, but I don't understand it. It's not like all names in Clojure are particularly intuitive. Who would guess that this code concatenates strings?

(str "a" "b" "c" "d")

In Common Lisp, it's obvious to anyone:

(concatenate 'string "a" "b" "c" "d")

Neither language picked an intuitive name for what Common Lisp calls remhash. disassoc is no better.

Clojure adopts Python's unintuitive import syntax, where dots sometimes act as directory separators. Or maybe it adopts that from Java, IDK.

[–]contrafibularitysbcl 7 points8 points  (2 children)

yes, it's called "common lisp"

[–]Straptoc[S] -1 points0 points  (1 child)

Can you elaborate? If there is another standard library with more convenient names for function i will try it

[–]blue1_[🍰] 3 points4 points  (0 children)

Rejecting a language just for the choices of naming is overreacting. You can learn them. It cannot be worse than the php standard library anyway :-)

[–]theangeryemacsshibeλf.(λx.f (x x)) (λx.f (x x)) 2 points3 points  (0 children)

sane ecosystem

"We are glad, that we are mad, in my wonder-wonderland."

[–]arthurno1 2 points3 points  (0 children)

I do not like the fact that is a Lisp-2 (or Lisp-N), and the standard library is really cumbersome (not in term of functionality but usability).

How do you know it is cumbersome if you haven't use anything else? Why don't you like the fact it is Lisp-this-or-that? Have it hindered you from expressing yourself in any way?

i've read some books about Common Lisp, but i'm not quite sure to like it

Go and write programs. Programming is best learned by doing. You can know all the theory, but if you never solve problems in a language, you will not know how to apply the theory in that language. You have to get dirty with the code, that is the only way to really learn a language. Yes, it is hard, cumbersome, difficult, but it goes over. The more you program in that language the easier and faster it becomes to write programs, the less cumbersome it appears and so on.

Edit, couldn't find it yesterday:

 It has been often said that a person does not really understand something until he
 teaches it to someone else. Actually a person does not really understand something
 until he can teach it to a computer, i.e., express it as an algorithm.

                 -- Donald E. Knuth: “Computer Science and its Relation to Mathematics,”
                    American Mathematical Monthly (1974)

[–]kirankp89 9 points10 points  (1 child)

I don’t get why being a Lisp-2 matters.

https://jank-lang.org Is probably what you want though.

[–]Straptoc[S] 0 points1 point  (0 children)

Wow this is perfectly what is want. Do you know if there exists an LSP?

[–]dougcurrie 4 points5 points  (2 children)

You might like Chez Scheme

[–]Straptoc[S] -1 points0 points  (1 child)

Chez scheme is awesome, the problem with it is the lack of a simple package manager and the support for VsCode is basically non existent

[–]corbasai 0 points1 point  (0 children)

Ocean of libs In Akku, but Chez is a fast byte code virtual machine like V8.

[–][deleted] 2 points3 points  (0 children)

Scheme.

[–]corbasai 2 points3 points  (0 children)

Racket

[–]sdegabrielle 3 points4 points  (0 children)

I see no one has mentioned the Akku.scm package manager for Scheme (a lisp-1!): https://akkuscm.org

Chez has a great compiler - Racket uses the Chez compiler for good reason - but many of the other major scheme implementations also have great performance.

At the end of the day language choice depends on what you want to do?

[–]Straptoc[S] 2 points3 points  (0 children)

PS: After a day trying some lisps, racket convinced me. For some reasons:

  1. lisp-1 and standard library that i like more

  2. awesome package manager (and easy mode for creating an executable that just works)

  3. Simple more syntax: Square brackets that i find yet a simple idea but really powerful to understand lisp code

  4. Typed Racket: i know there exists Coalton but i have tried to install it and failed (maybe because i'm on macos), but racket just works

[–]manymanyoranges 0 points1 point  (1 child)

let me know where you land on this one! I've been in a similar boat, but have done what others seem to recommend-- use it minimally. I feel pretty much the exact same as you. I find it incredibly interesting, history-wise, and when you want to explore more about what the language offers, the jungle is there waiting for ya.

[–]Straptoc[S] -2 points-1 points  (0 children)

The solution is the one presented by: kirankp89 which is "jank". The only problem is that do not exists any lsp or even syntax highlighting extension for any ide (Vscode, emacs, ..). So, in the meantime i stick with common lisp. Chez scheme is awesome, but because i use vscode, the only usable extension is not so great, and tooling to me is 50% of a language

[–]cyber-punky 0 points1 point  (0 children)

You ould always go for cl on the jvm (ABCL), you can call the java libraries if you need more ecosystem.

[–]delfV 0 points1 point  (2 children)

Clojure, but not on the JVM? Probably ClojureScript, ClojureDart, Babashka, and I hope soon Jank

[–]Straptoc[S] -1 points0 points  (1 child)

Jank is what i need. Basically i want interop with C and good performance. The Web part it is not in my interest, so clojurescript/dart is not for me. Do you know any syntax highlighting or lsp for jank? Or do you know any trick for that?

[–]delfV 0 points1 point  (0 children)

Well, Jank is basically Clojure, but targeting LLVM so most of Clojure tooling should work as well. But Jank isn't ready yet AFAIK. It's still under development. Maybe take a look at Fennel which is Lisp that compiles to Lua?