Re: What is wrong with Ada?

[Markus E Leypold <development-2006-8ecbb5cc8aREMOVETHIS@ANDTHATm-e-leypold.de>]

"Chad  R. Meiners" <chad.rmeiners@gmail.com> writes:

> On Apr 10, 12:12 pm, Jean-Pierre Rosen <r...@adalog.fr> wrote:
>> Markus E Leypold a �crit :> Pascal Obry <pas...@obry.net> writes:
>>
>> >> Markus,
>>
>> >>>> Why do they like unreadable code?
>> >>>> Why do they like to play with a debugger ?
>> >>> Good question. That "real Ada software engineers" (like "real men")
>> >>> never need a debugger might be the reason why gdb is so badly
>> >>> integrated with Gnat. That's a thought.
>> >> gdb is used with Ada just not so often.
>>
>> > Right. But when it is used, it is sorely needed, since this then is
>> > one of the conceptual bugs I mentioned.
>>
>> Sorry, but I beg to disagree here. Conceptual bugs are found by
>> reasonning on the source, not with a debugger. Every now and then you
>> may need to check the value of a variable at some point in execution to
>> validate or invalidate an hypothesis, but even there, I find a proper
>> trace message much faster and more precise than using a debugger.
>> --
>> ---------------------------------------------------------
>>             J-P. Rosen (r...@adalog.fr)
>> Visit Adalog's web site athttp://www.adalog.fr
>
>
> I disagree. Sometimes trace messages add line noise and maintaince
> requirements to the code base, 

And in sad reality, exactly the tracing you need to find that special
bug, ist not in place at the given moment. Also the idea to instrument
for tracing every piece of source strikes me a s remarkably similar to
the philosophy of inserting checks for overflows and invalid pointers
over the whole source base: I thought that we had done away with stuff
of that kind -- "for every piece if source you should also ..." --
exactly by delegating that to tools: Either the compiler or a
debugger.

Which reminds me, that I wished that the compiler and the debugger
would work well enough together that I could just say: I now want a
trace (including parameters) of every call to modules M, M', ... and
would get it without too much fiddling. This is in my eyes what
debuggers are (should be) good for.

> and it is much easier to trace through
> the algorithm step by step (using conditional breaks when necessary).
> It is particularly handy to use a debugger when interfacing to other
> people's component libraries.  That being said, trace messages are
> usually very efficient too.

They are. But why do I have to insert them by hand instead of attach
them via a suitable source level debugger?

> cavat: I have found debuggers more useful in languages like C++ than
> Ada, but then again Visual Studios has an excellent debugger.

And the gnat-gdb is notoriously bad.

My experience generally is the same. Of course, I don't need a
debugger this often in other languages. The C debuggers are often
rather good (due to the close correspondence between generated machine
code and source), the Gnat gdb was nuisance and the ocaml debugger was
impressive (but i don't need it so often, since my development style
there is much more incremental -- continous testing and recompilation
comes much more natural in functional languages IMHO).

Regards -- Markus