"regulars" do not use debuggers

[jacob navia]

Mr Richard harter says in the thread

Modifying the arguments to a function is a bad idea

> I don't use debuggers.

Mr "pete" ([email protected]) replies:

> Me neither.

This proves that the "regulars" are a highly sophisticated
elite. Probably they do not debug their programs (of course
they will tell us that they do not have bugs) etc etc.

Obviously discussing with those kind of people is
a waste of time, specially when you are speaking about
debuggers.

I send this just as a reminder of what kind of
*attitude* hides behind the arguments of the "regulars"

 

[BGB / cr88192]

Mr Richard harter says in the thread

Modifying the arguments to a function is a bad idea


Mr "pete" ([email protected]) replies:


This proves that the "regulars" are a highly sophisticated
elite. Probably they do not debug their programs (of course
they will tell us that they do not have bugs) etc etc.

Obviously discussing with those kind of people is
a waste of time, specially when you are speaking about
debuggers.

I send this just as a reminder of what kind of
*attitude* hides behind the arguments of the "regulars"

dunno...


I use debuggers though, as otherwise it is damn near impossible to figure
out what is crashing and why (trying to track down a random bug in
potentially a few hundred kloc of code or so...).

without a debugger, it is a pain trying to narrow down the bug, even to the
50-kloc range, much less find the offending line...

or such...

 

[jacob navia]

dunno...


I use debuggers though, as otherwise it is damn near impossible to figure
out what is crashing and why (trying to track down a random bug in
potentially a few hundred kloc of code or so...).

without a debugger, it is a pain trying to narrow down the bug, even to the
50-kloc range, much less find the offending line...

or such...

Yes of course. I use a debugger too. But apparently here there is a
group of people that do not use debuggers!!!

Of course the software they write doesn't have any bugs!

 

[Ben Pfaff]

without a debugger, it is a pain trying to narrow down the bug, even to the
50-kloc range, much less find the offending line...

If a tool that can extract a backtrace from a core file is a
debugger, or if valgrind is a debugger, then I use debuggers all
the time.

If only GDB and tools of similar ilk are debuggers, then I don't
use them very often.

 

[Tom St Denis]

I send this just as a reminder of what kind of
*attitude* hides behind the arguments of the "regulars"

Out of curiosity, does picking fights count as a good or bad
attitude? I'm trying to keep score here.

Tom

 

[Flash Gordon]

Out of curiosity, does picking fights count as a good or bad
attitude? I'm trying to keep score here.

If your name is Jacon Navia it is a good habit. Otherwise anything less
positive then massive praise is a person attack on Jacob Navia and a bad
habit. HTH.

Mind you, I now know that I'm not and never have been a regular, since I
first used a debugger before I started programming in C.

 

[Flash Gordon]

jacob navia wrote:

This proves that the "regulars" are a highly sophisticated
elite.

Ah well, I'm not a regular then, since as you've already read I do
sometimes use debuggers.

Probably they do not debug their programs (of course
they will tell us that they do not have bugs) etc etc.

That isn't what they said. There are plenty of other techniques, such as
using logic analysers (which can give you a trace up to the point of a
crash which you can look back over), static analysis, tools like
Valgrind, debug logging etc.

Obviously discussing with those kind of people is
a waste of time, specially when you are speaking about
debuggers.

Well, debuggers are not part of C. In fact, most debuggers I've used can
be used for languages other than C. So try discussing debuggers in a
group about them (or more general programming).

I send this just as a reminder of what kind of
*attitude* hides behind the arguments of the "regulars"

It's more of a reminder of how you misrepresent people. Here you have
lumped in all the regulars as not using debuggers directly after
receiving evidence that some DO use them. You have also misrepresented
the position of people who do not use debuggers as being a claim that
the code they write never has bugs.

 

[Flash Gordon]

No, it proves that they don't do any real work.

Not necessarily.

In real work, you use a debugger, if you have one.

Ah, there you are, that could work in environments where they *don't*
have a debugger. I have in the past. I've also sometimes found other
tools to be a *lot* more powerful. For instance, a properly set up logic
analyser on a processor which does not have a cache can be incredibly
useful. The debugger in Delphi (which I know is not C), on the other
hand, can be completely useless for certain types of problems (namely
the ones I had).

 

[Lew Pitcher]

Mr Richard harter says in the thread

Modifying the arguments to a function is a bad idea


Mr "pete" ([email protected]) replies:


This proves that the "regulars" are a highly sophisticated
elite. Probably they do not debug their programs (of course
they will tell us that they do not have bugs) etc etc.

Obviously discussing with those kind of people is
a waste of time, specially when you are speaking about
debuggers.

Obviously, discussing debuggers with these people is a waste of time. And,
of course, is off topic in comp.lang.c

Again, Jacob, you take personal affront to someone who does not agree with
you wholeheartedly. Personally, in over 30 years of programming banking
applications, I've only used a debugger once or twice, and never *needed* a
debugger.

Now, what does that mean?

It means that, in 30+ years of writing code, I've never needed a debugger to
determine the cause of an error in development code. It does not mean that
I've never encountered or solved an error in development code. It means
that *I KNOW HOW* to solve errors in development code *WITHOUT A DEBUGGER*.

It means that, in 30+ years of testing code, I've never needed a debugger to
determine the cause of an error in QA code. It does not mean that I've
never encountered or solved an error in QA code. It means that *I KNOW HOW*
to solve errors in QA code *WITHOUT A DEBUGGER*.

It means that, in 30+ years of maintaining operating code, I've never needed
a debugger to determine the cause of an error in production code. It does
not mean that I've never encountered or solved an error in production code.
It means that *I KNOW HOW* to solve errors in development code *WITHOUT A
DEBUGGER*. It also means that, in our production environments, we were *NOT
PERMITTED* to use a debugger. And, when you are resposible 7/24/365 for a
production system, and get that 2AM call that something crashed, you *have*
to fix the code *right now*. So you learn *how* to fix code without a
debugger.

While it would be nice if code were properly structured so that a debugger
could be used exclusively to fix problems, most languages don't give you
that option, and most programmer's styles don't either.

What you rail against (in another thread) is that some programmers style
makes it hard for you to use a debugger. Well, tough! Learn to debug
properly, and you won't need to depend on a debugger, and therefore won't
care what the other programmer's style is.

And, no, this has nothing to do with your status as a vendor or not, whether
your C compiler is standards compliant or not, or whether your personal
choice is to use length-delimited strings or not. This is about your
beligerant postings to this newsgroup.


--
Lew Pitcher

Master Codewright & JOAT-in-training | Registered Linux User #112576
http://pitcher.digitalfreehold.ca/ | GPG public key available by request
---------- Slackware - Because I know what I'm doing. ------

 

[jacob navia]

It means that, in 30+ years of writing code, I've never needed a debugger to
determine the cause of an error in development code. It does not mean that
I've never encountered or solved an error in development code. It means
that *I KNOW HOW* to solve errors in development code *WITHOUT A DEBUGGER*.

Sure sure. Never used a debugger.

GREAT Superman!!

What else you want me to say?

You do not need a debugger, and like others in this thread
you debug without it...

Great Batman!

Not even Spiderman can catch you.

 

[Lew Pitcher]

jacob navia said:


I believe him.

FWIW, a symbolic dump of a program in ABEND, along with a copy of the source
code, and a copy of the input data, is/was generally all I needed.

Only Kenneth Iverson could invent a "write-only language" (APL). Most other
language designers (Kernighan, et al, included) designed languages that not
only could be written by a programmer, but *read* and *understood* by a
programmer.

Debugging is a simple matter of following the logic paths that end at the
ABEND location, with the data that the program used at the ABEND location,
and determining what caused the ABEND to occur. *Fixing* programs was much
harder, as you often had to refactor the offending logic, and create logic
on the fly that would solve the business requirement without encountering
further errors.

Jacob: If you couldn't find and fix a S0C4 at 2AM, you weren't a programmer.
You were the gofer for the programmer ("gofer coffee. Gofer a pencil" Gofer
lunch.")

I guess that makes Jacob a gofer, doesn't it ;-)
--
Lew Pitcher

Master Codewright & JOAT-in-training | Registered Linux User #112576
http://pitcher.digitalfreehold.ca/ | GPG public key available by request
---------- Slackware - Because I know what I'm doing. ------

 

[BGB / cr88192]

If a tool that can extract a backtrace from a core file is a
debugger, or if valgrind is a debugger, then I use debuggers all
the time.

If only GDB and tools of similar ilk are debuggers, then I don't
use them very often.

recently I have been using WinDbg...

I sort of miss gdb and gprof, but then again, neither really supports Win64
as of yet...

 

[BGB / cr88192]

BGB / cr88192 wrote:
[...]

I use debuggers though, as otherwise it is damn near impossible to figure
out what is crashing and why (trying to track down a random bug in
potentially a few hundred kloc of code or so...).

without a debugger, it is a pain trying to narrow down the bug, even to
the 50-kloc range, much less find the offending line...

or such...

On the other hand, there are times when a debugger is not available. For
example, when logging into the client's system, or having them send us
files to duplicate in-house, would he a HIPAA violation.

Those can be fun (FSVO), though fortunately, those are the rare exception.

yes, ok...


sometimes I use non-debugger strategies, namely:
making the code get really verbose whenever anything "suspect" starts going
on;
"hidden" verbosity (such as logs or annotated output);

(these can help find bugs without needing to use the debugger in many
cases...).


there are also "trace" messages (telling where execution is at, what are the
values of certain variables, ...), which are typically not used, as they are
both ugly an tedious to use (as I have to go and insert them all over the
place to try to locate the bug...).

 

[James Kuyper]

Lew Pitcher wrote:
....

Only Kenneth Iverson could invent a "write-only language" (APL). Most other
language designers (Kernighan, et al, included) designed languages that not
only could be written by a programmer, but *read* and *understood* by a
programmer.

APL was my second computer language, and it fitted my way of thinking
about things perfectly - I'm not sure what that says about me. I learned
it from a single pass through an IBM manual I wrote some APL code in
1976, used APL for the last time in the early 80s. In the late 90s I
found some printouts from 1976. I not only was able to read it, but even
to understand it. I'm not sure I could write it anymore without a
reference manual, though.

 

[Nick Keighley]

Quite right.  I am a member of a highly sophisticated elite.  We are better
programmers than you; we are better software designers than you; we are
more literate than you; and we are probably better looking than you.

we worship You
we fall at Your Feet
we are unworthy

 

[Nick Keighley]

jacob navia wrote:

Ah well, I'm not a regular then, since as you've already read I do
sometimes use debuggers.


That isn't what they said. There are plenty of other techniques, such as
using logic analysers (which can give you a trace up to the point of a
crash which you can look back over), static analysis, tools like
Valgrind, debug logging etc.

- activity logging
- assertions
- reasoning about programs
- unit testing

Well, debuggers are not part of C. In fact, most debuggers I've used can
be used for languages other than C. So try discussing debuggers in a
group about them (or more general programming).


It's more of a reminder of how you misrepresent people. Here you have
lumped in all the regulars as not using debuggers directly after
receiving evidence that some DO use them. You have also misrepresented
the position of people who do not use debuggers as being a claim that
the code they write never has bugs.

a certain degree of Pots and Kettles

 

[Nick Keighley]

FWIW, a symbolic dump of a program in ABEND, along with a copy of the source
code, and a copy of the input data, is/was generally all I needed.

Only Kenneth Iverson could invent a "write-only language" (APL). Most other
language designers (Kernighan, et al, included) designed languages that not
only could be written by a programmer, but *read* and *understood* by a
programmer.

Debugging is a simple matter of following the logic paths that end at the
ABEND location, with the data that the program used at the ABEND location,
and determining what caused the ABEND to occur.

easy!

Of course the ones that scribbled all over the stack before they died
were less fun. Or even better ones that trashed the code...

Then there's timing dependent bugs. Interupt routines.

*Fixing* programs was much
harder, as you often had to refactor the offending logic, and create logic
on the fly that would solve the business requirement without encountering
further errors.

I often noticed hard to find bugs had relativly easy fixes.

Jacob: If you couldn't find and fix a S0C4 at 2AM, you weren't a programmer.
You were the gofer for the programmer ("gofer coffee. Gofer a pencil" Gofer
lunch.")

I guess that makes Jacob a gofer, doesn't it ;-)

<snip>

 

[Richard Bos]

Only Kenneth Iverson could invent a "write-only language" (APL).

Oh, Dis and Malbolge, no! Such Brainfucks are hardly limited to APL, as
any Rube knows. All you need is to eliminate Whitespace.

Richard

(_Seriously meant_ write-only languages is another matter, although even
there you might find other people creating Perls of wisdom.)

 

[Thomas Matthews]

Mr Richard harter says in the thread

Modifying the arguments to a function is a bad idea


Mr "pete" ([email protected]) replies:


This proves that the "regulars" are a highly sophisticated
elite. Probably they do not debug their programs (of course
they will tell us that they do not have bugs) etc etc.

Obviously discussing with those kind of people is
a waste of time, specially when you are speaking about
debuggers.

I send this just as a reminder of what kind of
*attitude* hides behind the arguments of the "regulars"

I'll admit that I am not a regular and I use debuggers
so I can validate that each line of new or modified code
behaves as it should and have no side effects.

However, I have had problems using debuggers in multi-thread
and multi-tasking environments. Most debuggers stop one
thread but let the others keep going. Also, single stepping
all the threads at once is difficult.

Even when I use test frameworks, I still like to single
step through the code to validate it.

--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.learn.c-c++ faq:
http://www.comeaucomputing.com/learn/faq/
Other sites:
http://www.josuttis.com -- C++ STL Library book
http://www.sgi.com/tech/stl -- Standard Template Library

 

[jameskuyper]

io_x wrote:
....

Can you explain what kind of error you can fix without a debugger?

Almost any kind of error; debuggers aren't magical ; they don't give
you any needed information you couldn't extract by other methods;
they're merely much more convenient (in many cases) than other
methods. It isn't a question of whether you can fix it without a
debugger, it's a question of whether using a debugger is a better
choice than the other available methods.

A debugger is the first thing I use when the symptom is a bus error or
a memory segment violation, or any bug that appears to have rendered
my normal error messages inoperable. However, if one of my programs
manages to get out one last error message before it dies, I usually
start with the error message, and I've learned to make my error
messages sufficiently informative that I often have no need to follow
up with a debugger session.

....

"Barry Schwarz" seems to me the only people here
can debug code without a debugger

I can assure you that there are many people here who can debug code
without a debugger. A debugger can be a useful tool for debugging
code, but it is not the only such tool, nor is it always the best tool
to use. Those who claim that it is are insufficiently well informed
about the existence, nature or advantages of the other tools. Your
brain is the single most important such tool, and in some cases all
you need to do in order to debug your code is apply your brain to the
symptoms of the failure, and you'll be able to deduce the cause.

For instance, recently someone posted some code that was supposed to
read and print three records. However, instead what it actually did
was read three records, print them out, and then print out the last
record one more time. Examining the code was sufficient for me to
identify the precise cause of the bug (misuse of feof()), I had no
need to use a debugger. However, someone else figured it out without
even reading the code, just from the symptoms (he needed no more
information about the problem than what I've just given you).