One thing that I dislike about typical debuggers
One of the things that I hate about typical debuggers is that they want me to hold their hand all the time. Okay, this is not entirely fair; they default to having me hold their hand, and generally don't do a really good job of supporting hands-off operation.
This is not really their fault, because debuggers have a different
view of how they're going to be used than I do. A classical debugger
gdb) expects to be used by people who are carefully narrowing
in on the bug, taking cautious step after cautious step, and for
this of course you want to interact with the debugger all the
time (because ultimately you are looking for an anomaly, which
requires a human's eye).
I don't use debuggers that way. Instead, I use them to extract a bunch of information from the program which I will then stare at for a while, so I want to set things up (simply, please) and then fire off a run without further intervention. The last thing I want to do is to slow down the process by having to interact with the debugger all the time.
Modern debuggers sort of support this; you can write command sets for
breakpoints and so on that automatically dump information and then
continue. But my impression is that both the command language and the
interface is awkward, and in practice when I've tried to use
this sort of thing I've wound up getting lost in the complexity of
managing all of the breakpoints and so on by hand. I would actually
rather have a script-driven debugger where I had to edit a file and then
reload it to change what I was monitoring, because that's easier to keep
track of and to modify.
(Having to keep changing a file and reloading it would of course be intolerable for the step by step 'narrowing in' style of debugging, which is why I don't expect debuggers to support it any time soon.)