4 ms·

Are there people here that prefer Common Lisp to Clojure for webdev specifically and would like to tell us why?

aidenn0 3y ago
Sure: 1. I've been using CL for longer than Clojure has existed 2. SLIME is better than any Clojure dev setup I've seen 3. Maybe I'm misunderstanding things, but if I get how Leiningen works, I need to restart my REPL any time I want to add dependencies? 4. Kind of a minor thing, but working in a Lisp-1 hits the "uncanny valley" of programming for me; I accidentally shadow an important function at least once an hour when working in Clojure or Scheme.
- Capricorn2481 3y ago
  > 3. Maybe I'm misunderstanding things, but if I get how Leiningen works, I need to restart my REPL any time I want to add dependencies? That is correct, though a lot of people are moving to `deps.edn` which recently lets you add dependencies on the fly.
  - koito17 3y ago
    This isn't a tools.deps specific functionality. Pomegranate has always allowed one to dynamically add dependencies to a running Clojure REPL. Now that add-lib was added in Clojure 1.12 alpha, people do not need to use pomegranate to dynamically add dependencies. In fact, Leiningen itself can make use of add-lib.
- capableweb 3y ago
  I'm no CL expert but I've written my fair share of Clojure code, just as a preface. > I accidentally shadow an important function at least once an hour when working in Clojure You mean that you accidentally "overwrite" (declare again) a function with the same name as the one you're now declaring, but you didn't mean to? If so, I'm not sure how that'd be possible. In Clojure you're always in a namespace, and you'd only have one function with that one name in that namespace, and if you're declaring a function with the same name in a different namespace, you now correctly have two functions with the same name, but in different namespaces. Unless your editor<>repl connection somehow ignores the current ns, I'm not sure how you'd end up in that situation. > SLIME is better than any Clojure dev setup I've seen This I'm also curious about, what exactly SLIME gives you that for example Conjure for neovim wouldn't already? Maybe something about continuations perhaps? That seems to be the only feature I've seen from Common Lisp (besides actually being able to compile to binaries) that I'd love to have in Clojure.
  - aidenn0 3y ago
    > You mean that you accidentally "overwrite" (declare again) a function with the same name as the one you're now declaring, but you didn't mean to? I mean I use let to bind a variable with the same name as a function. This is idiomatic in Common Lisp, and totally breaks things in most other languages. > This I'm also curious about, what exactly SLIME gives you that for example Conjure for neovim wouldn't already? Maybe something about continuations perhaps? That seems to be the only feature I've seen from Common Lisp (besides actually being able to compile to binaries) that I'd love to have in Clojure. I watched a video and it does seem rather complete, but [1] indicates there is no debugger? That's a rather glaring omission. I also don't see a profiler mentioned, and SLIME with SBCL gives me a profiler (down to the assembly level if needed). I'm sure Java in general has great profiling tools, but how are the integrated into the Clojure system? As an aside, by "continuations" did you mean "restarts"? First-class continuations are a feature of scheme, not CL. Indeed a huge boost to CL productivity is simply allowing you to handle an exception before the stack is unwound. 1: https://github.com/Olical/conjure/wiki/Client-features https://github.com/Olical/conjure/wiki/Client-features
    - capableweb 3y ago
      > I mean I use let to bind a variable with the same name as a function. This is idiomatic in Common Lisp, and totally breaks things in most other languages. Aha, that should be working fine? (defn add [x y] (let [add clojure.core/+] (add x y))) The `let` binding is local, so it's referring to clojure.core/+, and outside the function `add` I can use the name `add` to call it. Seems it's handling that case correct? > I watched a video and it does seem rather complete, but [1] indicates there is no debugger? I think debuggers tend to be used as a library across many different editors, rather than the editor/plugin providing that functionality. Personally, I don't use debuggers much as the functions I write tend to be small and evaluating small executions with the repl tends to reveal the issue quickly. Sometimes when refactoring others code I've used https://github.com/philoskim/debux https://github.com/philoskim/debux to various degrees of success. I do think cider (https://github.com/clojure-emacs/cider https://github.com/clojure-emacs/cider) has stuff regarding stepping debuggers, but I'm not sure how common it is to use it. Maybe other Clojure users can fill me in :) > . I also don't see a profiler mentioned Yeah, as you said, the Java ecosystem basically covers that. For OSS stuff, I use VisualVM, and for professional stuff I use YourKit, both of them work well with Clojure and points out my user-space code with ease. And I've never been paid anything for actually writing/maintaining Java code, so even with that, seems I'm able to use those tools just for Clojure :) > As an aside, by "continuations" did you mean "restarts"? Ah yes, of course. The condition system and restarts :) Thanks!
- mksybr 3y ago
  > 3 https://github.com/clj-commons/pomegranate https://github.com/clj-commons/pomegranate https://stackoverflow.com/questions/16409182/any-way-to-add-dependency-to-lein-project-without-repl-restart https://stackoverflow.com/questions/16409182/any-way-to-add-... => (use '[cemerick.pomegranate :only (add-dependencies)]) nil => (add-dependencies :coordinates '[[incanter "1.2.3"]])
  - fiddlerwoaroof 3y ago
    This works except when it doesn’t: my experience is that it seemed like the JVM is fundamentally static at its core in a way that makes it hard to implement a CL-style environment using Clojure’s hosting strategy. Boot build comes really close, here, but the community never really adopted it.
deleted 3y ago
[deleted]
mmmm2 3y ago
I started off with Clojure and then moved to Common Lisp. They're both good languages. My Clojure is rusty, so I'll just list some positive things I found about using Common Lisp. This is from my experience creating a small website that runs on AWS with: - nginx - SBCL - hunchentoot - easy-routes - cl-json - cl-sqlite - ... Most of the positives come from Common Lisp's condition system and built in debugger. I like the ability to hit an unexpected condition, pause, poke around at things, re-compile, and retry the code. This can be very useful for something interactive like a website. It took me a while to get the hang of it, but once you learn it it's quite powerful. You can also apply the same techniques to the production server with minimal fear you're going to break stuff. Common Lisp is designed with the idea that developers will change state on the fly, so it has mechanisms in place to make this easy and reasonably safe. SBCL is also "fast", at least when compared to Python or Ruby, but I imagine Clojure is too. I would assume most other benefits would be similar with Clojure (Macros, html generation, etc.)
- fulafel 3y ago
  Would you or someone else happen to have a link to a screencast with this dev flow? The restarts sound vaguely useful but how they concretely help (vs reloading based workflow) could be cool to see.
  - vindarel 3y ago
    That's a short video I made to show this: https://www.youtube.com/watch?v=jBBS4FeY7XM https://www.youtube.com/watch?v=jBBS4FeY7XM It's a feature that is useful everyday, if only to speed up trivial things.

Sure: 1. I've been using CL for longer than Clojure has existed 2. SLIME is better than any Clojure dev setup I've seen 3. Maybe I'm misunderstanding things, but if I get how Leiningen works, I need to restart my REPL any time I want to add dependencies? 4. Kind of a minor thing, but working in a Lisp-1 hits the "uncanny valley" of programming for me; I accidentally shadow an important function at least once an hour when working in Clojure or Scheme.

Capricorn2481 3y ago
> 3. Maybe I'm misunderstanding things, but if I get how Leiningen works, I need to restart my REPL any time I want to add dependencies? That is correct, though a lot of people are moving to `deps.edn` which recently lets you add dependencies on the fly.
- koito17 3y ago
  This isn't a tools.deps specific functionality. Pomegranate has always allowed one to dynamically add dependencies to a running Clojure REPL. Now that add-lib was added in Clojure 1.12 alpha, people do not need to use pomegranate to dynamically add dependencies. In fact, Leiningen itself can make use of add-lib.
capableweb 3y ago
I'm no CL expert but I've written my fair share of Clojure code, just as a preface. > I accidentally shadow an important function at least once an hour when working in Clojure You mean that you accidentally "overwrite" (declare again) a function with the same name as the one you're now declaring, but you didn't mean to? If so, I'm not sure how that'd be possible. In Clojure you're always in a namespace, and you'd only have one function with that one name in that namespace, and if you're declaring a function with the same name in a different namespace, you now correctly have two functions with the same name, but in different namespaces. Unless your editor<>repl connection somehow ignores the current ns, I'm not sure how you'd end up in that situation. > SLIME is better than any Clojure dev setup I've seen This I'm also curious about, what exactly SLIME gives you that for example Conjure for neovim wouldn't already? Maybe something about continuations perhaps? That seems to be the only feature I've seen from Common Lisp (besides actually being able to compile to binaries) that I'd love to have in Clojure.
- aidenn0 3y ago
  > You mean that you accidentally "overwrite" (declare again) a function with the same name as the one you're now declaring, but you didn't mean to? I mean I use let to bind a variable with the same name as a function. This is idiomatic in Common Lisp, and totally breaks things in most other languages. > This I'm also curious about, what exactly SLIME gives you that for example Conjure for neovim wouldn't already? Maybe something about continuations perhaps? That seems to be the only feature I've seen from Common Lisp (besides actually being able to compile to binaries) that I'd love to have in Clojure. I watched a video and it does seem rather complete, but [1] indicates there is no debugger? That's a rather glaring omission. I also don't see a profiler mentioned, and SLIME with SBCL gives me a profiler (down to the assembly level if needed). I'm sure Java in general has great profiling tools, but how are the integrated into the Clojure system? As an aside, by "continuations" did you mean "restarts"? First-class continuations are a feature of scheme, not CL. Indeed a huge boost to CL productivity is simply allowing you to handle an exception before the stack is unwound. 1: https://github.com/Olical/conjure/wiki/Client-features https://github.com/Olical/conjure/wiki/Client-features
  - capableweb 3y ago
    > I mean I use let to bind a variable with the same name as a function. This is idiomatic in Common Lisp, and totally breaks things in most other languages. Aha, that should be working fine? (defn add [x y] (let [add clojure.core/+] (add x y))) The `let` binding is local, so it's referring to clojure.core/+, and outside the function `add` I can use the name `add` to call it. Seems it's handling that case correct? > I watched a video and it does seem rather complete, but [1] indicates there is no debugger? I think debuggers tend to be used as a library across many different editors, rather than the editor/plugin providing that functionality. Personally, I don't use debuggers much as the functions I write tend to be small and evaluating small executions with the repl tends to reveal the issue quickly. Sometimes when refactoring others code I've used https://github.com/philoskim/debux https://github.com/philoskim/debux to various degrees of success. I do think cider (https://github.com/clojure-emacs/cider https://github.com/clojure-emacs/cider) has stuff regarding stepping debuggers, but I'm not sure how common it is to use it. Maybe other Clojure users can fill me in :) > . I also don't see a profiler mentioned Yeah, as you said, the Java ecosystem basically covers that. For OSS stuff, I use VisualVM, and for professional stuff I use YourKit, both of them work well with Clojure and points out my user-space code with ease. And I've never been paid anything for actually writing/maintaining Java code, so even with that, seems I'm able to use those tools just for Clojure :) > As an aside, by "continuations" did you mean "restarts"? Ah yes, of course. The condition system and restarts :) Thanks!
mksybr 3y ago
> 3 https://github.com/clj-commons/pomegranate https://github.com/clj-commons/pomegranate https://stackoverflow.com/questions/16409182/any-way-to-add-dependency-to-lein-project-without-repl-restart https://stackoverflow.com/questions/16409182/any-way-to-add-... => (use '[cemerick.pomegranate :only (add-dependencies)]) nil => (add-dependencies :coordinates '[[incanter "1.2.3"]])
- fiddlerwoaroof 3y ago
  This works except when it doesn’t: my experience is that it seemed like the JVM is fundamentally static at its core in a way that makes it hard to implement a CL-style environment using Clojure’s hosting strategy. Boot build comes really close, here, but the community never really adopted it.

deleted 3y ago

[deleted]

mmmm2 3y ago

I started off with Clojure and then moved to Common Lisp. They're both good languages. My Clojure is rusty, so I'll just list some positive things I found about using Common Lisp. This is from my experience creating a small website that runs on AWS with: - nginx - SBCL - hunchentoot - easy-routes - cl-json - cl-sqlite - ... Most of the positives come from Common Lisp's condition system and built in debugger. I like the ability to hit an unexpected condition, pause, poke around at things, re-compile, and retry the code. This can be very useful for something interactive like a website. It took me a while to get the hang of it, but once you learn it it's quite powerful. You can also apply the same techniques to the production server with minimal fear you're going to break stuff. Common Lisp is designed with the idea that developers will change state on the fly, so it has mechanisms in place to make this easy and reasonably safe. SBCL is also "fast", at least when compared to Python or Ruby, but I imagine Clojure is too. I would assume most other benefits would be similar with Clojure (Macros, html generation, etc.)

fulafel 3y ago
Would you or someone else happen to have a link to a screencast with this dev flow? The restarts sound vaguely useful but how they concretely help (vs reloading based workflow) could be cool to see.
- vindarel 3y ago
  That's a short video I made to show this: https://www.youtube.com/watch?v=jBBS4FeY7XM https://www.youtube.com/watch?v=jBBS4FeY7XM It's a feature that is useful everyday, if only to speed up trivial things.