4 ms·

Inline previous result in Emacs Lisp

134 points by clircle 2y ago

anonzzzies 2y ago
Makes me think of Light Table. Does this exist for Common Lisp?
- thenonameguy 2y ago
  I'm not certain, but Clojure supports this through CIDER's Enlighten mode: https://docs.cider.mx/cider/debugging/enlighten.html 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.
  - medstrom 2y ago
    The "inline" thingy can be seen as a popup/tooltip, could span many lines.
- darby_nine 2y ago
  For those like me who have never heard of it, I think OP is referring to this: http://lighttable.com http://lighttable.com
  - slowmovintarget 2y ago
    Last touched three years ago. Interesting that someone came a long to give it a coat of paint (Electron update, ClojureScript update... etc.).
- vindarel 2y ago
  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 https://lem-project.github.io/usage/common_lisp/#watch There's sly-overlay too: https://git.sr.ht/~fosskers/sly-overlay 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 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?
neilv 2y ago
Nice enhancement to EDebug. If anyone is wondering about Nyan Cat in the "after" screen capture: https://github.com/TeMPOraL/nyan-mode https://github.com/TeMPOraL/nyan-mode
- jayemar 2y ago
  Any idea what theme that is? It looks really nice.
  - xenodium 2y ago
    If you mean the one from edebug post, either of these have details. https://lmno.lol/alvaro/my-emacs-eye-candy https://lmno.lol/alvaro/my-emacs-eye-candy https://xenodium.com/my-emacs-eye-candy https://xenodium.com/my-emacs-eye-candy If you mean from https://github.com/TeMPOraL/nyan-mode https://github.com/TeMPOraL/nyan-mode, I don't know ;)
taeric 2y ago
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.)
- projektfu 2y ago
  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.
  - taeric 2y ago
    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.
alex_smart 2y ago
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.

134 points by clircle 2y ago

anonzzzies 2y ago

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

thenonameguy 2y ago
I'm not certain, but Clojure supports this through CIDER's Enlighten mode: https://docs.cider.mx/cider/debugging/enlighten.html 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.
- medstrom 2y ago
  The "inline" thingy can be seen as a popup/tooltip, could span many lines.
darby_nine 2y ago
For those like me who have never heard of it, I think OP is referring to this: http://lighttable.com http://lighttable.com
- slowmovintarget 2y ago
  Last touched three years ago. Interesting that someone came a long to give it a coat of paint (Electron update, ClojureScript update... etc.).
vindarel 2y ago
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 https://lem-project.github.io/usage/common_lisp/#watch There's sly-overlay too: https://git.sr.ht/~fosskers/sly-overlay 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 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?

neilv 2y ago

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

jayemar 2y ago
Any idea what theme that is? It looks really nice.
- xenodium 2y ago
  If you mean the one from edebug post, either of these have details. https://lmno.lol/alvaro/my-emacs-eye-candy https://lmno.lol/alvaro/my-emacs-eye-candy https://xenodium.com/my-emacs-eye-candy https://xenodium.com/my-emacs-eye-candy If you mean from https://github.com/TeMPOraL/nyan-mode https://github.com/TeMPOraL/nyan-mode, I don't know ;)

taeric 2y ago

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.)

projektfu 2y ago
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.
- taeric 2y ago
  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.

alex_smart 2y ago

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.