$a ='foo'
print $a

syntax error at - line 2, near "print"
[download]

$a = 'foo'
print $a

Error you idiot.  Your code has been deleted, you no longer
have permission to use this compiler, and all the other
computers and programmers on the network have been informed 
of your imcompetence!
[download]

e-mail neshura

Your plane crashes in the jungle. Everyone lives, but is captured by rebels. The leader of the rebels asks you to kill one of the passengers. If you don't, he will kill them all. The question: do you kill someone? If so, how do you select the person?

I realized that all moral dilemmas that he came up with always stemmed from a previous immoral action over which you have no control. In the case of the problem above, the previous immoral action is the rebel leader deciding that some or all survivors will be murdered.

Though the parallel is tenuous, it's there.

In debugging, we are attempting to apply logic to a previous breakdown in our logic. It's the poor choices of ourselves or others that lead us down the path of debugging. Is there a universal logical approach to resolving breakdowns in logic, or is it more of an art?

I debug well, but I don't always succeed. Your comment "hackers gain insite into life by how they debug" is very applicable to me. Oftimes, when faced with my breakdowns in logic, I am tempted to just run to others for help (hence, some of my posts to Perl Monks). Sometimes, I just want an answer, rather than figure out what's going on. Hmmm... now I'm seeing parallels to religion. I'll stop now before this becomes a full-fledged rant.

Is there a universal logical approach to resolving breakdowns in logic, or is it more of an art?

It's both. While there has to be an organized, test-one-thing-at-a-time approach for debugging anything more complex than a one-timer, art and experience come in when you have to figure out exactly where and what the error is. The more mistakes you make -- and fix -- the more easily you can recognize new ones.

Some people are so good at this, it appears to be magic. It's like the Knuth series -- though programming is essentially breaking a complex task down into little chunks and then describing them as succinctly AND in as much detail as necessary, it's a creative process. That's why it's an Art.

There is no spoon.

Seriously though, I beleive that the flash that you where refering to is when you realize that you did it wrong in the 1st place. I rarely use perl's debugger. At most, I run -c just to see if I don't have a typo somewhere, but TRUE debugging, very rare. Mind you, that, I'm not a programing super-hero or anything of the sort. Its just my way of doing things.

When scoping through code, instead of trying to find the logic in what was just written, I find it more productive to review the logic itself and what it was I was trying to accomplish in the 1st place (ie: read it as if I were reading perlmonks). This is a habbit I aquired when reviewing trainees' coding. I always ask myself, "How would I do it?" even if the code is mine. I just pretend it isn't.

Invariably, I'll hit the bad spot (if it isn't just a typo) during the 1st run through. Else, I give it to someone else to read and come back to it later. It also helps to explain out loud why each line is written the way it is.

Just my R$0.02 (Brazilian two cents) worth.

I used to debug a lot like you do, it works fine. Another good trick is to abuse Data::Dumper for debugging when diving into data structures and objects. But these all can be trememdously slower sometimes, especially if the original code is not yours. I did not really start using debuggers until I got to my current job where some of the programs are 30k lines long, none of which were written by me. They are not a bad sized programs, but some were written in the most bizzare way, and no strict. Yet I still have to fix the bugs that are reported.

It is hard to get into debuggers at first, but investigate some of the gui ones like Devel::ptkdb or DDD. Getting really familiar with a good debugger is (in my opinion) one of the most advantageous things any programmer can do.