watchpoints VS flow-storm-debugger

It's sad that Python does not really support some of these debugging methods.

E.g. you cannot really watch variable changes. There are some workarounds, like writing a custom __setattr__ or __setattribute__ in case of an object, or checking all STORE_* operations. https://youtrack.jetbrains.com/issue/PY-30387 https://github.com/gaogaotiantian/watchpoints

Reverse debugging is also sth I would like to have, and there are a few projects to support this, but it's not really well supported in standard CPython. https://foss.heptapod.net/pypy/revdb https://pytrace.com/

There is also the watchpoints module to track changes to variables, but I don't think you can use the two of them together since they both use the same underlying callback in Python.

It uses Python's built-in inspect module to get the caller frame. https://github.com/gaogaotiantian/watchpoints/blob/68bc13716...

It then uses sys.settrace (which is intended as an interface for debuggers) to step through the code and check whether the variable has been changed. Documentation on sys.settrace: https://docs.python.org/3/library/sys.html#sys.settrace

Python exposes most of its guts as part of the standard library, making clever hacks like this possible.

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.