flow-storm-debugger VS scope-capture

Tracing debuggers give you the best of both worlds. I've recently started using Flow-storm [0], by @jpmonettas), and it's been quite transformative. You can still easily see the values flowing through your system (better than just "prints"), and it can handle multi-threaded / async scenarios quite nicely. You don't need to manually step through code, you can just "see" your data flow, and when you have loops or some other form of iteration, you can see the data for each pass. Coupling this with a good data visualization tool (such as Portal [1]) really feels like magic. I've been doing Clojure for quite a few years now, and was very happy with my plain REPL-driven workflow, but this is way better.

[0] https://github.com/jpmonettas/flow-storm-debugger

[1] https://github.com/djblue/portal

This is another example, a tracing time travel debugger for Clojure https://github.com/jpmonettas/flow-storm-debugger

Supports a bunch of stuff described there and more.

Lisps have some good tooling around debugging, for example clojure's flowstorm or common lisp which has built into the language most of what this article is talking about.

There's some good debugging tooling for Clojure as well. A recent entrant is https://github.com/jpmonettas/flow-storm-debugger and of course there's the estabilished pretty full featured debugging features in CIDER (Emacs), Calva (VS Code) and Cursive (IntelliJ). And for barebones tracing from REPL there's goo old clojure.tools.trace.

For Emacs there is something already if you use the Emacs integration described here https://github.com/jpmonettas/flow-storm-debugger/tree/flow-docs/editors.

Awesome tools.

Personally I can't imagine coding in clojure without scope capture

https://github.com/vvvvalvalval/scope-capture

I haven't tried it myself. I generally just use truss for runtime constraint checking. I use a modified version that integrates scope-capture. And malli validation for more complex cases, but I try to limit that. For me it is better to validate individual attributes as needed, vs validating an entire "type"/collection of attributes. So each function only cares about the attributes that it needs, and validates only as needed.

Use scope-capture to observe the actual data flowing through the system

Scope capture library https://github.com/vvvvalvalval/scope-capture automates this approach.

Is anyone aware of any prior art along the lines of this? I've seen scope-capture but it's more about instrumenting existing programs than writing new ones interactively.

I am not advocating against the use of a compiler. I am going to illustrate how to reproduce the scope of a program and replay it in the REPL as it is done for instance in Clojure with scope-capture. In some use cases, I find this approach is simpler than using a debugger. This approach is possible only because the data is immutable.