[beders]

The Clojure (or any Lisp) journey is very different, not because of the language per se, but because of the developer experience.

In Clojure, there's no appreciable compilation time. During my work week I barely, if ever, restart the application I'm working on: I'm working inside of it via a REPL connection.

It's an entirely different ball game and if you just compare language features you are missing out on an incredible interactive coding experience.

[labrador]

Does it scroll? Because I like to scroll around when thinking about my program. I always imagine Lips REPL ppl saying they keep the entire program in their head but that can't be right. That's doing things the hard way.

[weikju]

You have files and editors for your files, eg emacs or vim or vscode.

Your editor is also directly connected to your running application and can compile individual functions or pieces of code to update the application without a full edit/compile/run/test loop. It happens way faster and more interactively while you code. You can directly inspect the running program and its data within that same framework and with the exact same tools and functions you use to code.

To answer another way, you don’t code your application in a REPL, like by line , but with all the tools you’d expect (editor or ide, git, etc) PLUS that live connection to your software.

[skydhash]

The nice thing about REPLs is that you can try random snippets code. And as the sibling comments put it, you rarely switch to the prompt interface. Instead you `eval` a bit of code and it got sent to the running state of your program as if you've typed it as the prompt. It's more like brainstorming a program using a mood board.

You kinda have to keep track of the state, but the latter can be easily inspected so there's no need to keep it your head.

[bandrami]

I'd even say it gives you an incentive to not keep a lot of opaque state lying around and this is a good thing

[asa400]

You tell your editor to evaluate any arbitrary part of the source file you currently have open, and it does so in the context of your running application without stopping it.

Then you see the result in another pane of your editor.

It's pretty revelatory. You're molding your program while it's running.

[andreicap]

Can confirm! Once I started doing this (now mainly with iPython interactive in VSCode) my output speed increased dramatically

[pjmlp]

To note that the same experience is shared with Smalltalk, and modern IDEs still are lacking of both.