THIS right here is why I use emacs. Not that something like this is not possible with other open-source software, but the number of steps required to compile, debug, identify change required, compile, rerun, it is usually not worth your time to investigate minor inconveniences. So there is learned helplessness and you compromise and learn to just live with the annoyance.

With Emacs you truly feel to be in control.

Nicely done! Will be playing with that shortly.

I'm always a touch sad that I don't step debug code more than I do. I remember the glory days of people pushing this in Java with the Eclipse compiler literally made to support incremental compilation. I think it was JRebel that was working to do that at large on other installations.

Fast forward a few years, and I would get into conversations with principal level engineers at amazon that didn't know this was possible. Having the debug agent was literally a default for some teams, and they didn't realize what all that enabled.

What happened? Feels that a lot of old school programmers of any language remember doing this. Too many others think this is some sort of magical world dreamed of by lisp enthusiasts that never actually happened.

(Would love to see numbers challenging any of my soft assertions above.)

Yes, this incremental approach was common in Smalltalk and Lisp Machine environments, then obviously in Common Lisp. IBM Visual Age for Java originally was like a Java veneer over the Smalltalk environment, then they came out with VA Micro Edition which, iirc, still supported incremental work. Around this time, Visual Basic 5.0 and later also were supporting an edit and continue approach and Microsoft started trying to get it into Visual C++ 6.0, although it was limited in what you could change before recompiling. By the time Eclipse came out, they were trying to stay competitive. What happened?

The Web. Web 2.0, really. Now you can't easily do the code as you go approach, it needs to be restarted in the server, the client needs to be updated, etc. Any hacks that make it possible are pretty fragile. People still like live-coding, but they don't expect to do it for the whole project.

You could argue that a lot of parts that go into making C (or, more amusingly, cweb is a fun case study) step debug friendly were hacks. Feels that it was almost a deliberate choice not to build in the support into modern frameworks.

I agree that the web was a large part of the problem here. What I don't get is how we haven't been able to bridge that gap by now? From my vantage, it is almost completely explained by every actor involved not having any desire or incentive to work with each other. And it is baffling.

I do grant that distributed systems have always had a lot of difficulty in making things debug friendly. And it is easy to see many websites as a distributed system. But it isn't like they originated this.

Nice enhancement to EDebug.

If anyone is wondering about Nyan Cat in the "after" screen capture: https://github.com/TeMPOraL/nyan-mode

Any idea what theme that is? It looks really nice.

If you mean the one from edebug post, either of these have details.

https://lmno.lol/alvaro/my-emacs-eye-candy https://xenodium.com/my-emacs-eye-candy

If you mean from https://github.com/TeMPOraL/nyan-mode, I don't know ;)

Makes me think of Light Table. Does this exist for Common Lisp?

It makes me think of Lem's `watch` that displays s-expr results in an overlay, much like CIDER's Enlighten, somewhat like LightTable: https://lem-project.github.io/usage/common_lisp/#watch

There's sly-overlay too: https://git.sr.ht/~fosskers/sly-overlay (a couple function changes away to have it on Slime)

but those are not inside the stepper. (edit) oh, there's Sly-stickers: https://joaotavora.github.io/sly/#Stickers

LispWorks has a more graphical stepper / debugger so we might look into it.

There might be sthg on the newer CLOG?

I'm not certain, but Clojure supports this through CIDER's Enlighten mode: https://docs.cider.mx/cider/debugging/enlighten.html

It would be even better if larger values were inspectable, as it becomes challenging to view more complex data types beyond numbers and short strings.

The "inline" thingy can be seen as a popup/tooltip, could span many lines.

For those like me who have never heard of it, I think OP is referring to this: http://lighttable.com

Last touched three years ago. Interesting that someone came a long to give it a coat of paint (Electron update, ClojureScript update... etc.).