I love the concept of the REPL and live editing and such, but my everyday work experience using a debugger sounds like it’s about 80% of the way there?
I can break, inspect, run expressions and generally figure out what’s going on by experimenting. Maybe not edit code directly, but I honestly never feel the need. Looking and poking around is in the vast majority of cases all I need.
I suggest: do you find yourself often quitting the debugger and re-running the same test, the same task from the start? You can avoid that in CL. Just leave the debugger open, go to the buggy line ("v" on a stacktrace in Slime), fix the function, re-compile it on the fly (C-c C-c in Slime), come back to the debugger, resume the program from the stackframe you want, now it passes.
If the first steps were taking 10 minutes, you just saved yourself some time.
You don't need special needs for that, it's a fast workflow I use everyday.
Another important point: we debug everything while keeping the current state in memory (in the image). We don't have to re-create our test data. All the program state is kept live, until we restart the image.
In a lot of cases... probably not in my experience. I think it can make a big difference in some cases though.
What REPL were you using though? Something to think about is that the Lisp and Smalltalk REPLs are a lot more powerful than Python in that I think when an expression fails, the program itself can be edited and it will start where it left off. You can't do that with Python.
Edit: the article does a good job of explaining this as "It's like if you could run your code in a debugger with a breakpoint at every single line that only activates if something goes wrong!"
Modern (proprietary) tooling comes really close to that experience, but I can see how it is liberating compared to editing text files, waiting for compilation and preying it works. I guess modern tools learned from the best.
You have probably never even considered writing a function that calls another, not yet defined function, and just moving on because your trail of thought is headed elsewhere at that very moment. Fifteen minutes later you are testing your new function and the debugger breaks on the call to your still undefined function. "Oh right", you think, "I need to transmogrify the foo here". So you define the transmogrify-foo function and continue debugging right there.
This isn't contrived or exotic in any way. It's just second nature when writing lisp in an interactive fashion.
I can break, inspect, run expressions and generally figure out what’s going on by experimenting. Maybe not edit code directly, but I honestly never feel the need. Looking and poking around is in the vast majority of cases all I need.
Am I missing something incredible?