I love this theory that not having a decent debugger is somehow a good thing - here's Giles Bowkett:
Asking why Ruby has weak debugger support is like asking why a dolphin doesn't have gills. Ruby has weak debugger support because Ruby programmers shouldn't be using a debugger. Ruby supports TDD and BDD better than any other language except possibly Smalltalk. Debugger support is for languages that you can't run tests against gracefully.
Yes, Smalltalk supports it better, in large measure because we have a debugger. For instance, have a look at this short (unnarrated) screencast. The summary: The Smalltalk debugger can support TDD:
So no Giles, the absence of a debugger is not a feature - it's a fairly significant lack in your toolset.
Update: I love this. I left a short comment on Giles' blog, with a tinyurl link back here. His justification for deleting my comment:
when I said write politely or post in your own blog, I didn't mean that links to rude blogs were somehow not rude. I wish you people were more respectful with my time. There was a very reasonable counterargument, complete with excellent screencast, which I had to delete. Please understand, if your comments are rude, I will delete them, no matter how well-reasoned they are, no matter how polished their presentation, no matter how much I might respect you. I do not tolerate rudeness on my blog, and there are no exceptions. Please respect my time and your own. Posting comments I'm guaranteed to delete is wasteful.
Sounds a little odd, especially when we we get here:
For a quick summary, the commenter did a screencast of the Smalltalk debugger. The screencast showed the debugger in action. I admit, it looks cool. However, it still looks like a crutch to me. The screencast's argument was basically, look, here's the Smalltalk debugger, see how cool it is? Therefore it can't be a crutch. Of course it can. Haven't you ever met a beautiful woman who was mean to people, or a highly intelligent alcoholic? People make crutches out of their best features in real life all the time. Somehow it's impossible in computers? Of course not. Haven't you ever seen a useless but fun high-tech toy? A feature can be cool and still a crutch nonetheless.
Hmm. Yes, my post here is snarky. However, if Giles thinks I was just showing something cool, he missed the entire point of the post: the Smalltalk debugger supports TDD. Watch it again, Giles - I wrote a test, ran it. It failed. I debugged the test, had the debugger create the missing method for me - whereupon I wrote the code for the method in the debugger, and ran the test again. That's not a crutch: it's taking TDD to the next level.
Face it, Giles - you have the worst of this argument. Ruby ought to have a Smalltalk style debugger, and if it did, every Ruby developer would use it. The fact that Ruby doesn't have such a debugger is not a feature. Does this mean that Ruby sucks? No, of course not. I just think the argument that not having a debugger is a good thing is lame.
Update2: When you know you've lost, just close comments to make sure you get the last word. Oh, and make sure to swear (see his update stream for that) while you're at it - that shows 'em:
Although I am aware that the Smalltalk debugger works in the context of TDD, and was initially aware of that when I wrote the post, before any comments were made, because anyone with any knowledge of Smalltalk's history or the history of TDD knows that, it doesn't change my opinion that debuggers work backwards. Debuggers are based on the idea that the code base has enough places bugs could happen that the work of locating the bug is involved enough to justify machine assistance. This is not true of well-tested code. More importantly, the whole point of [T|B]DD is that you identify the bugs before you write the code. As tools which track down bugs in existing code, debuggers presume and encourage a workflow which is exactly backwards.
Umm, yeah - because we all write perfect code the first time, right out of the gate. Sure. And stop/restart is ever so much more productive than what I showed in the screencast, where you never leave the context of your code. Sure Giles - it's far more productive to do the test/run/break/test/run/break cycle than what I showed. You keep believing that - I'll be over here, being productive :)Update 3:
Oh, this just takes the cake - In the comments, Giles says:
Why on earth would I? How is supporting me rude? Why would I be offended by an offer of support?
So it's pretty simple, really - suck up to him, and it's open season. Disagree, and you get edited out. I've seen that behavior on political blogs, but sheesh.
smalltalk, ruby, debugger