This is the one article I've looked at that seems to go into most detail question, specifically the section "What makes a programming language REPL-friendly?"

At some point of toyed with trying to do REPL driven dev in Python to see what it was like. PyCharm does have a shortcut for sending things to the REPL window. The biggest difference is that in Clojure, everything is an expression, which means you send any part of your code. Not so with Pythons mix of statements and meaningful white space along side expressions. The other part is the tooling. Sure PyCharm had a shortcut, but compared to what Calva offers in terms of sending various forms, it was night and day.

There's a good demonstration by Sean Corfield on the topic - should be easy to find on YT.

The value, for me, is in incrementally executing code as I write it. Each step along the way I can try things and confirm things are working the way I want. I get the feedback directly in my editor, making the feedback cycle incredibly tight and as fine or coarse grained as I'd like it. That instant feedback is so incredibly valuable. Many other languages try to give you the same thing in different ways: hot reloading, incremental compilation, automatically running tests, etc. These tactics all have positives and negatives but they're all trying to give you a faster feedback cycle. I think Clojure as a language is expecially well-suited to using a REPL to drive development. Specifically, being a functional language that uses immutable data structures lends itself to testing things incrementally and in isolation. Functions typically have all the state they need in order to execute passed in on each call, and functions generally can't change that state because of immutable data structures. This means there's no (or very little) state setup/teardown/reset for each execution of the code you're building.

but to see it you need to follow along with someone else doing development using a REPL, like @U2FRKM4TW pointed you to

I didn't fully get it until I paired with someone tbh

the ability to change a running program is the key detail

python and JS have REPL, but due the way their module systems and bindings work you can't patch a running program

a better way of describing REPL driven development is to relate it to hot module reloading

it's basically first class support in the language for hot module reloading. and can be done at a fine grained level - you can reload individual functions and vars inside of modules without touching the rest of the module

JS does this with a metric ton of awful tooling. same with other langs

clojure you just need a socket connection and an editor that can talk to it

Thank you everyone. These comments are helpful. I think what I may be driving at trying to understand, just to put a finer point on it, is whether there is a characteristic of the language itself that makes Clojure’s REPL great / better. In other words, is it just an accident or a cultural predilection of the community that has led us to have things like CIDER for emacs that allow us to work in the editor. (In other words, is Clojure’s REPL experience better simply because nooone has bothered to build similar tools for other languages?) From the responses here, I think perhaps the notion that “everything is an expression” as well as the the idea that you can “change a running program” are key and seem to be related to the characteristics of the language as opposed to the existence of tooling that makes this possible. I’m trying to wrap my head around the “everything is an expression” idea first because it seems more basic. I wonder how one could illustrate this simply, perhaps making a comparison some other language. @UBHTL6AF3 you mentioned, e.g., that Python has a mix of “statements and meaningful white space.” Is it possible to given an example of what you mean?

By way of analogy, do you restart your machine every time you want to run a new script on it or install a new program? No, the computer is dynamically linked and alive and you can develop on it from within it.

There's a, maybe subtle, difference between LISP REPLs and REPLs of other language paradigms in that with LISPs the REPL is an integral part of the language design. It is how programs are read and made to exist. With Python and JavaScript it is a separate tool. This has implications on the support that CIDER et al can provide on top of the REPL. They reach into the application being developed in a way that JS and Python IDEs just can't do.

Anyway, as has been noted in this thread before. The feedback loop is amazingly tight in Clojure, key contributors: • the running program can be modified • everything is an expression • immutable data • powerful data structures with literal syntax I think a language like SmallTalk is even more dynamic than Cloure, so it ticks the first box there. However, everything is not an expression making it a bit awkward to select the piece of code to send in ti the system. And data immutability is not a key language concept, making the evaluation of something having more side effects than it has in Clojure.

I'll plug some videos where I try to make the case for Interactive Programming. • Solving FizzBuzz with the CLojure REPL: https://www.youtube.com/watch?v=U-cys75qaCw (short, w/o narration) • FizzBuzz again: https://www.youtube.com/watch?v=d0K1oaFGvuQ (longer, narrated) • Developing a mobile app as it is running: https://www.youtube.com/watch?v=5ZyAhGv55V0&t=1559s The mobile app example makes it more obvious than the FizzBuzz videos, that the program is actually bing modified as it is running.

https://clojurians.slack.com/archives/C03RZGPG3/p1646021494348129?thread_ts=1646014042.105639&cid=C03RZGPG3 @U4YGF4NGM are you talking specifically about vars now?

https://clojurians.slack.com/archives/C03RZGPG3/p1646022878947789?thread_ts=1646014042.105639&cid=C03RZGPG3 @U3RGL6XNF hi :) In addition to expression orientation I'd add plain, serializable data with literals. Just being able to type values in without "constructing them" is of great help. Usually, we can just paste values back in and they are still "right". Edit: just as @U0ETXRFEW noted!

Just a good essay about using Lisp, but Paul Graham describes how the ability to live changing the code in production using the REPL was helping him to fix bug while at the phone with customers. http://www.paulgraham.com/avg.html

@U3X7174KS yes, vars and the namespace system is what I was referring to

this video I think is very relevant https://www.youtube.com/watch?v=3HxVMGaiZbc

While I agree, some of this is possible to achieve in Python using importlib.reload (redefine module without restarting process) and by catching NameError (hacky defonce for Python). I've written a tool for developing Python without restarting the interpreter: https://github.com/teodorlu/hotload It has a real advantage if you're using libraries that take a long time to start up, or if you're working with a system that has an embedded Python scripting layer and you don't want to loose context (such as https://en.wikipedia.org/wiki/Abaqus). File watcher + process restarts is a lot simpler, though. And the rest of the ecosystem doesn't really use in-process reloads.

https://nextjournal.com/mk/rich-hickey-on-repls I think Rich Hickey's comments on REPLs also offer some insight here - chiefly that the extensibility of Lisp readers, combined with the ability to read forms as data, make all Lisp-based REPLs more capable than the consoles of other languages. I really like the nested read example at the end, too.

I told a coworker once about a nightmare I had where I was putting a line of code between 2 csharp lines and then needed to start the program to try it out. I literally woke up with a "noo!"

Something that's not been mentioned in the thread so far, is that once you're in a REPL it feels much more like playing with code than actually working. Building something feels far more like playing with lego than grappling with a codebase. Other languages' workflow is "look at the types, look at the code, figure out what's going on, then make changes. Don't actually run the code, it won't give you much unless you're going into a debugger" With a REPL it's more "just run the code, look at what it's doing, move some things around to give yourself better understanding. Knock the tower over, build it up brick by brick till you see how it works."

And "feels like play" typically means you can focus on just exploring / learning. Not do arbitrary tedious work. Faster learning speed ➡️ faster iteration cycles ➡️ win!

On a meta-note: I believe reflecting deeply on what the REPL is to be the key to understanding what's good with Clojure. It feels really hard to separate the REPL discussion from "how to use Clojure effectively".

I've read that Rich Hickey on REPLs before and didn't quite understand much. Read it again now, hoping things would have cleared up, but I still don't get it. It feels like I should, being a REPL tool smith and all.

Yeah, I think the whole "I just use inf-clojure" might be the right attitude for Clojure / Common Lisp experts. But I would never have been able to learn Clojure without friendlier tools like Cider and Calva.

I posted a link to this post in the new #growth channel.

I encounter a website that simply can't work without third-party cookies once a year, if not less frequent. I have never seen such a widget - perhaps because I use uBlock Origin with a rather strict selection of rules.

some of the "annoyances" lists included in ublock origin might block that

could be. I've used annoyances in the past but IIRC it often broke sites e.g. modals would become uncloseable

which is why I'm thinking of a "network-level" solution