Hacker News Reader

Comment by ReleaseCandidat | Hacker News Reader

> People rave about their repl, but it feels like they're comparing it to a script iteration loop rather than static analysis tooling.

You do know that statically typed languages have REPLs too? Like the ML family, including Haskell.

And when using something like a Jupyter notebook with a kernel for your compiled language https://github.com/gopherdata/gophernotes you can do similar interactive programming.

REPLs are about trying out ideas or changes.

Lisp REPLs take that a step further, as you interact with and in your whole actually running program.

View on HN

> Lisp REPLs take that a step further, as you interact with and in your whole actually running program

With python, I can add a signal callback which calls the inbuilt breakpoint() function. This means I can send my application a given signal, let's say SIGTERM, and it'll drop into they python debugger whereby I can then drop further into the python REPL.

Does Lisp provide more than that out of interest?

Edit: ah I see hot reloading is a thing. Not explored that in python.

Many early Common Lisp systems had impressive error handling. Certain exceptions would automatically break to an interactive Lisp window.

But Common Lisp also has a fancy system for recovering from exceptions. So after you replaced the broken function, you'd often see a list of "restart" points from where you could retry a failed operation.

So even if you failed in the middle of a complex operation, you could test out a fix without needing to abandon the entire operation in progress.

I'm not entirely certain if this was as useful as it sounds, in practice, but it was certainly very impressive.

There was a book published just last year about the CL condition system for anyone who wants to better understand it (disclaimer: it's sitting on my desk but I haven't read it yet): https://link.springer.com/book/10.1007/978-1-4842-6134-7

It's like CSI vs Dr House. Debugging in python is forensic; you can figure out why your program died, but you can't really fix it. In common lisp, debugging can be curative as well as forensic. If you hit a problem like you call foo from bar, but foo isn't defined you can just write an implementation in your editor, send it to the running lisp and continue with the current execution. If a class is missing something, you can change the definition and not onl y have it take effect for all live instances, but you can also say how to transform the existing instances in your program. Have a look at the example given in the "docs": http://clhs.lisp.se/Body/f_upda_1.htm; you should get the gist even without knowing lisp.

I'm overgeneralizing (I've had remote repls in production python application and used them to hotfix things), but only a little. You will appreciate the difference if you work with long running computations, where you don't want to have to start over from scratch if something went wrong right at the end.

Yes, it was mentioned in the post: you normally get prompted not just when there's a breakpoint, but when your code calls something that doesn't yet exist, for example, or try to access a non-defined variable [1]... you have the option to "fix" the issue and continue from the same point, continue with a different value, or just let it crash... and there's stuff like profiling and de-compiling [2] which are all available directly from the REPL as well.

[1] https://lispcookbook.github.io/cl-cookbook/debugging.html

[2] https://lispcookbook.github.io/cl-cookbook/performance.html

> You do know that statically typed languages have REPLs too? Like the ML family, including Haskell.

I do, but that I don't see how that relates to the bit of my post which you've quoted. I certainly didn't claim or imply that REPL and static type systems were mutually exclusive, only that REPLs are a poor substitute for many static analysis tasks.

> And when using something like a Jupyter notebook with a kernel for your compiled language https://github.com/gopherdata/gophernotes you can do similar interactive programming.

Yeah, I'm aware. I operate a large JupyterHub cluster (among many other things) at work. :)

> Lisp REPLs take that a step further, as you interact with and in your whole actually running program.

That sounds nice, but it's too abstract to persuade IMHO. Personally, it seems like REPLs can make certain feedback loops a bit faster, and to that extent they seem like a modest quality of life improvement; however, considering how lisp folks positively rave about them, I assume I'm missing something.

> that REPLs are a poor substitute for many static analysis tasks.

Maybe I should have asked you what you use the REPLs of statically typed languages for.

I actually never used REPLs for that (neither in Python, CL, Clojurescript nor Elixir).

> That sounds nice, but it's too abstract to persuade IMHO.

Of course it is. I also didn't get it until I've tried it myself. That actually has been the main cause why I tried (Common) Lisp at all (well I had been using Emacs Lisp before, but that doesn't really count ;).

> Maybe I should have asked you what you use the REPLs of statically typed languages for.

I don't really use them, which is kind of my point. Once in a great while I'll do some quick testing in the rare case that using a REPL is actually faster than just running the program, but to even call that a marginal improvement in my quality of life would risk overemphasis.

I use repls a lot, both when I used clojure and now when I mainly use python. The reason for me is language exploration. I write my program and don’t always know how to do something and the internet is ambiguous.

With a nice repl I can rapidly iterate trying different things and doing micro in-situ experiments to explore and understand how the language (or library more frequently) works.

It’s very edifying.

> I assume I'm missing something.

You are indeed, Rackets REPL is very barebones. Use Common Lisp with either SLime or Sly and Emacs.

> You are indeed…

How puzzling that you do not spell-out exactly what you believe they are missing.

It should be obvious? He uses Racket, Racket has a very simple REPL, as opposed to CL which allows him to use the features he has heard mentioned about Lisp. Interactivity, short feedback loop, etc. This has been written thousands of times on here, I don't intend to repeat it here.

Are you saying the Racket REPL does not support "Interactivity, short feedback loop" ?

Not when compared to the CL REPL, yes.

Reply on news.ycombinator.com