4 ms·

I only had deeper interactions / usage with two Lisps so far: Racket and Clojure. CL must have some unique appeal that I'm missing. It's community seems to pra

by dgb23 6y ago

I only had deeper interactions / usage with two Lisps so far: Racket and Clojure. CL must have some unique appeal that I'm missing. It's community seems to praise it's properties, but is rather quiet otherwise: Interesting talks, projects and companies are be eluding me, especially when compared to the above two Lisps.

lispm 6y ago
> some unique appeal It's a standard for the main Lisp language with multiple very different implementations, including commercial offerings. For example at least two quantum computer companies use Common Lisp deep in their stuff. Currently D-Wave is looking for a Lisp developer for their processor group: https://jobs.lever.co/dwavesys/eca1f300-d90b-460f-9b7e-2660b154ead2 https://jobs.lever.co/dwavesys/eca1f300-d90b-460f-9b7e-2660b...
- nerdponx 6y ago
  The big appeal for me is that Lisp is just weird enough to be fun, and dynamic enough to be expressive with rapid prototyping, but also has mechanisms to write more-structured programs and has quite a lot of batteries included, even if they are somewhat oddball or not necessarily portable across implementations. SBCL with Qlot feels almost like Python to me in terms of how quickly I can bang out a simple but working program. But unlike Python I get to use macros and powerful iteration constructs like DO.
patrec 6y ago
Well, I have a cynical take about the unique appeal of Common Lisp, but even cynicism aside Common Lisp is not going to lose to Racket in the "interesting companies" department, I think. Google Flights is still powered by Common Lisp. Clasp is somewhat interesting (and there is a Google Tech Talk about it, too). And instead of learning "How to Design Programs" from people with unclear experience in designing interesting programs, you can read a book full of small interesting programs written by someone with pretty clear track record of doing interesting things (https://github.com/norvig/paip-lisp https://github.com/norvig/paip-lisp).
- dgb23 6y ago
  Fantastic reference thank you!
agumonkey 6y ago
I'm no real lispser, but I walk in this circle regularly. CL most cited value: more featured repl, better live debugging
simias 6y ago
The Lisps core appeal is that it's an extremely flexible and dynamic language family. They got an unparalleled macro system that lets you effectively design your own DSLs trivially for any scenario you may encounter. It's also the reason I could never really enjoy CL (or lisps in general): everybody basically ends up using their own dialect of Lisp with their own idiosyncrasies. Some people love the "loop" macro and use it everywhere, some others thing it's ugly and use the equally powerful but syntactically very different "do" construct instead. You can look at some lisp code and have no idea of what it does if you don't expand a few layers of macros first. That can be true of any language of course, you can abuse overloading, references and macros in C++ if you want, but Lisp really pushes it to the limit in my experience. Beyond that there's also the problem that the ecosystem is not quite as developed as other more mainstream scripting languages. It doesn't help that the community is split across half a dozen lisp/scheme implementations with often incompatible packages. Do you want to use SBCL? Chicken Scheme? Racket? Guile? Emacs lisp? CLISP? ECL?
- travv0 6y ago
  > You can look at some lisp code and have no idea of what it does if you don't expand a few layers of macros first. I've not once expanded a macro in order to see what it does. The only reason I can think of that one would do that is to see how it works, but one also has to look at e.g. the definition of a function to see how that function works, and that should almost never be important. How are macros different? Just like functions, one often has to read the documentation to know how to use a macro, but I'm not sure how being a macro makes (loop for i from min to max do ...) harder to read than a function would be.
  - simias 6y ago
    Functions can be opaque of course, but macros are worse because anything goes. I think the standard loop macro is a good example of this: (loop repeat 10 for x = (random 100) if (evenp x) collect x into evens else collect x into odds finally (return (values evens odds))) This macro is actually fairly well designed, so you can guess what all of this does just by interpreting the names (assuming that you understand English well at least) but it's barely Lisp. Just figuring out what parts of this call are keywords and what part are just normal symbols is hard to figure out. (return ...) looks like a function call, but I don't think it is(?). Is collect a loop-ism or can I replace it by any function name? I think it's the former. Is "into" just here to make grammatical sense or are there other keywords I can use here? If `evens` and `odds` already exist as variable names outside of the loop, will they be used or is it a new local binding? If it is a local binding, how do I tell it to use some existing variable name instead? Basically it's like printf format strings, it's a language within a language, and idiomatic Common Lisp is often full of that stuff in my experience.
TurboHaskal 6y ago
I have used both CL and Clojure professionally. If you're just into functional programming and expressiveness, Clojure blows CL out of the water. Scheme also feels more cohesive, at least R(4,5)RS which is what I know. The appeal of Common Lisp (to me) are CLOS, the condition/restart system, commercial portable GUI toolkits and specially the low level capabilities. Compared to it, Clojure just feels like a verbose APL. Depending on the camp you are, Dylan, Factor and Julia are better Lisps than Scheme and Clojure, even if they are not s-expression based.
dreamcompiler 6y ago
CL is more of an "industrial strength" Lisp. It compiles to the metal [0] so no VM is needed which makes it very fast and also appropriate for embedded applications (e.g. home automation on an RPi or Odroid). It has excellent numerical functions so it's nice for scientific computing (I use it for research others might use Matlab or Julia for), and it contains CLOS, which is probably the most powerful O-O system ever built. If you need to write a Very Large Lisp program for an industrial application with a lot of moving parts that has to run fast, you probably want Common Lisp. [0] Racket is now compiled to the metal now too with the recent Chez compiler integration.
- dietlbomb 6y ago
  I've tinkered with CL for numerical analysis, but always have had trouble picking good libraries to help. Do you have any recommendations for good libraries for scientific computing (especially some that will run in Windows)?
  - dreamcompiler 6y ago
    I mostly just write my own stuff directly in CL like Runge-Kutta solvers, FFT, etc. Here's a library I trust for linear algebra that uses BLAS and LAPACK. I haven't tried it on Windows. https://github.com/rigetti/magicl https://github.com/rigetti/magicl And of course there's always Maxima, the clone of Macsyma which was the grandfather of Mathematica: https://en.wikipedia.org/wiki/Maxima_(software) https://en.wikipedia.org/wiki/Maxima_(software)
mmcdermott 6y ago
I've done a mixture of Scheme, Common Lisp and Clojure for fun. I've skimmed the Racket docs, but never took the plunge, in part because the license weirds me out a bit. Scheme always struck me as the better designed language, but Common Lisp tends to be more pragmatic. The latest Scheme reports only made the problem worse by further fragmenting the community. The main problem I tended to have when starting projects in CL/Scheme was library support. Sure, I could wrap whatever libraries I needed in SWIG or the implementation's FFI, but that was work taken out of my all-too-small pool of time to work on something that wasn't the problem that interested me. Clojure solves this problem by being hosted while also making a lot of the language changes I once dreamed of making to Scheme and Common Lisp.
remexre 6y ago
Versus the other two, I'd say it's much less of a functional programming language; you have arrays, mutation, and powerful loop syntax (that expands to gotos!). My experience (writing CL at work and for personal projects) is that CL is the perfected form of Python, whereas when I used Racket in the past it felt more like a cousin of ML.

by dgb23 6y ago

lispm 6y ago

> some unique appeal It's a standard for the main Lisp language with multiple very different implementations, including commercial offerings. For example at least two quantum computer companies use Common Lisp deep in their stuff. Currently D-Wave is looking for a Lisp developer for their processor group: https://jobs.lever.co/dwavesys/eca1f300-d90b-460f-9b7e-2660b154ead2 https://jobs.lever.co/dwavesys/eca1f300-d90b-460f-9b7e-2660b...

nerdponx 6y ago
The big appeal for me is that Lisp is just weird enough to be fun, and dynamic enough to be expressive with rapid prototyping, but also has mechanisms to write more-structured programs and has quite a lot of batteries included, even if they are somewhat oddball or not necessarily portable across implementations. SBCL with Qlot feels almost like Python to me in terms of how quickly I can bang out a simple but working program. But unlike Python I get to use macros and powerful iteration constructs like DO.

patrec 6y ago

Well, I have a cynical take about the unique appeal of Common Lisp, but even cynicism aside Common Lisp is not going to lose to Racket in the "interesting companies" department, I think. Google Flights is still powered by Common Lisp. Clasp is somewhat interesting (and there is a Google Tech Talk about it, too). And instead of learning "How to Design Programs" from people with unclear experience in designing interesting programs, you can read a book full of small interesting programs written by someone with pretty clear track record of doing interesting things (https://github.com/norvig/paip-lisp https://github.com/norvig/paip-lisp).

dgb23 6y ago
Fantastic reference thank you!

agumonkey 6y ago

I'm no real lispser, but I walk in this circle regularly. CL most cited value: more featured repl, better live debugging

simias 6y ago

The Lisps core appeal is that it's an extremely flexible and dynamic language family. They got an unparalleled macro system that lets you effectively design your own DSLs trivially for any scenario you may encounter. It's also the reason I could never really enjoy CL (or lisps in general): everybody basically ends up using their own dialect of Lisp with their own idiosyncrasies. Some people love the "loop" macro and use it everywhere, some others thing it's ugly and use the equally powerful but syntactically very different "do" construct instead. You can look at some lisp code and have no idea of what it does if you don't expand a few layers of macros first. That can be true of any language of course, you can abuse overloading, references and macros in C++ if you want, but Lisp really pushes it to the limit in my experience. Beyond that there's also the problem that the ecosystem is not quite as developed as other more mainstream scripting languages. It doesn't help that the community is split across half a dozen lisp/scheme implementations with often incompatible packages. Do you want to use SBCL? Chicken Scheme? Racket? Guile? Emacs lisp? CLISP? ECL?

travv0 6y ago
> You can look at some lisp code and have no idea of what it does if you don't expand a few layers of macros first. I've not once expanded a macro in order to see what it does. The only reason I can think of that one would do that is to see how it works, but one also has to look at e.g. the definition of a function to see how that function works, and that should almost never be important. How are macros different? Just like functions, one often has to read the documentation to know how to use a macro, but I'm not sure how being a macro makes (loop for i from min to max do ...) harder to read than a function would be.
- simias 6y ago
  Functions can be opaque of course, but macros are worse because anything goes. I think the standard loop macro is a good example of this: (loop repeat 10 for x = (random 100) if (evenp x) collect x into evens else collect x into odds finally (return (values evens odds))) This macro is actually fairly well designed, so you can guess what all of this does just by interpreting the names (assuming that you understand English well at least) but it's barely Lisp. Just figuring out what parts of this call are keywords and what part are just normal symbols is hard to figure out. (return ...) looks like a function call, but I don't think it is(?). Is collect a loop-ism or can I replace it by any function name? I think it's the former. Is "into" just here to make grammatical sense or are there other keywords I can use here? If `evens` and `odds` already exist as variable names outside of the loop, will they be used or is it a new local binding? If it is a local binding, how do I tell it to use some existing variable name instead? Basically it's like printf format strings, it's a language within a language, and idiomatic Common Lisp is often full of that stuff in my experience.

TurboHaskal 6y ago

I have used both CL and Clojure professionally. If you're just into functional programming and expressiveness, Clojure blows CL out of the water. Scheme also feels more cohesive, at least R(4,5)RS which is what I know. The appeal of Common Lisp (to me) are CLOS, the condition/restart system, commercial portable GUI toolkits and specially the low level capabilities. Compared to it, Clojure just feels like a verbose APL. Depending on the camp you are, Dylan, Factor and Julia are better Lisps than Scheme and Clojure, even if they are not s-expression based.

dreamcompiler 6y ago

CL is more of an "industrial strength" Lisp. It compiles to the metal [0] so no VM is needed which makes it very fast and also appropriate for embedded applications (e.g. home automation on an RPi or Odroid). It has excellent numerical functions so it's nice for scientific computing (I use it for research others might use Matlab or Julia for), and it contains CLOS, which is probably the most powerful O-O system ever built. If you need to write a Very Large Lisp program for an industrial application with a lot of moving parts that has to run fast, you probably want Common Lisp. [0] Racket is now compiled to the metal now too with the recent Chez compiler integration.

dietlbomb 6y ago
I've tinkered with CL for numerical analysis, but always have had trouble picking good libraries to help. Do you have any recommendations for good libraries for scientific computing (especially some that will run in Windows)?
- dreamcompiler 6y ago
  I mostly just write my own stuff directly in CL like Runge-Kutta solvers, FFT, etc. Here's a library I trust for linear algebra that uses BLAS and LAPACK. I haven't tried it on Windows. https://github.com/rigetti/magicl https://github.com/rigetti/magicl And of course there's always Maxima, the clone of Macsyma which was the grandfather of Mathematica: https://en.wikipedia.org/wiki/Maxima_(software) https://en.wikipedia.org/wiki/Maxima_(software)

mmcdermott 6y ago

I've done a mixture of Scheme, Common Lisp and Clojure for fun. I've skimmed the Racket docs, but never took the plunge, in part because the license weirds me out a bit. Scheme always struck me as the better designed language, but Common Lisp tends to be more pragmatic. The latest Scheme reports only made the problem worse by further fragmenting the community. The main problem I tended to have when starting projects in CL/Scheme was library support. Sure, I could wrap whatever libraries I needed in SWIG or the implementation's FFI, but that was work taken out of my all-too-small pool of time to work on something that wasn't the problem that interested me. Clojure solves this problem by being hosted while also making a lot of the language changes I once dreamed of making to Scheme and Common Lisp.

remexre 6y ago

Versus the other two, I'd say it's much less of a functional programming language; you have arrays, mutation, and powerful loop syntax (that expands to gotos!). My experience (writing CL at work and for personal projects) is that CL is the perfected form of Python, whereas when I used Racket in the past it felt more like a cousin of ML.