REPL-based development doesn't require typing directly into the REPL. It's usually a text editor side-by-side with the REPL. Most LISP IDEs have a command to send forms over to the REPL to be evaluated. In this manner, you develop your code iteratively with the REPL almost as if having a conversation with the REPL. You try a form, and if it doesn't work, you change and iterate, line by line of your code. Through this "conversation", you've gone from a single form, to an entire function that works, than a module. You build from the bottom up. There is no, code-compile-test cycle, it's always instantaneous. With some REPLs (like Common Lisp), you can even break from an exception, update your code and resume the code from the point before the exception. It's much more than the REPL most people are used to with Python or Ruby.

Then you should upgrade your imagination ;-)

REPL-based development in a language that does not have large scopes of nested things is just so great. You can redefine everything on the fly. That is incomparable to restarting whole programs. Scala also has a repl but it not nearly as useful with idiomatic Scala code, because lot's of stuff is defined in nested scopes and by inheriting and extending trait. After a simple code change you have to recreate lot's of state. That does not happen in Clojure when you work primarily with builtin data types and lots of functions. This advantage is not only based on the REPL, but also on the way the syntax of is designed.

No way man. REPL is *more* useful the bigger, more massive the project.

I work on massive C# website that takes forever to warm up and get running. Stuck on old .net framework. A rebuild/rerun of the website after each little change is incredibly frustrating and slows down the feedback loop. Fortunately Microsoft implemented hot reload, and it has been a game changer. It still has all sorts of quirks and gotchas, but despite that I love it.

If there is one thing to take from common lisp, it's the live image development style. It's unfortunately hard to bolt on to languages not designed for it from the ground up.

To add on to what others have said, a good repl lets you point it at at a minimum of a file and load its contents into active state (so if you want access to a bunch of functions you load that file based on the command of the language you are in). You can then do the one lines you are talking about, but you could also update the file if you find you want to tweak a function and usually highlight and ctrl+enter to re-evaluate that one function, updating its state in the live environment. This way instead of recompiling the entire system you recompile that one function and anything using it now points to the new version.

F# actually has this and while it probably is not as powerful as Slime with CL it can give an idea of the power you are missing (and F#'s has gotten some nice improvements in the script side of .fsx files such as being able to add nuget files with a line in the script in newer versions).

> I can't imagine REPL-based "development" is good for anything other than one-liners and quick-n-dirty one-off stuff.

Perhaps your imagination would benefit from some elevation. Try shrooms or something :) I think your understanding of what a REPL actually is might be somewhat skewed due to a shallow understanding of how it works with Lisp dialects. The experience of working with the REPL in Python, for example, is not equal to the experience in e.g., Clojure.

There are many different companies that leverage Lisp dialects to build their businesses. Companies like Cisco, Apple, Walmart, Nubank, Grammarly, Funding Circle, Pitch.com, Rate.com, and many others are not using it for "quick-and-dirty one-off stuff"