Re: How to get nice with GNAT?

["Randy Brukardt" <randy@rrsoftware.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:1adpj5cs8xtkf$.hqv9tsofbfgz$.dlg@40tude.net...
> On Wed, 3 Dec 2014 15:41:12 -0600, Randy Brukardt wrote:
...
>> Huh? The thing passed is an access-to-a-symbol, which is an
>> access-to-variant-record in an untagged design, or an
>> access-to-class-wide-symbol in a tagged design.
>
> The subprogram you pass it should have been a primitive operation.

Not practical. I explained why later.

>> Either way, you'll get a run-time error.
>
> Yes, because it is weakly-typed. I would even dare put up a definition:
>
>   Typing is weak when type errors are run-time errors
>
>   (Untyped is when type errors are run-time bugs)

By this definition (which is not the typical definition of the phrase), any 
realistic program is weakly-typed.

>> In Ada 2012, you could use a predicate on the parameter in
>> order to make the check sooner, but it still will be a runtime check.
>
> And this still be weakly-typed, which is why dynamic predicates are so
> dangerous. They add nothing but another possibility for having a bug.
>
>> In may experience, most problems come down to managing combinations of
>> several kinds of objects (in the abstract sense, not the Ada sense), and
>> it's not sensible to try to do that in any sort of statically typed 
>> manner.
>
> Which is using Ada as if it were C. The combinations of objects should be
> handled in a way allowing to map combinations onto the language items
> allowing static checks. Yes, it is not always possible, and where not
> possible it becomes a C program in Ada, partially of course.

Not at all. C has no run-time checks; you'll never get any sort of error 
from it unless you write it explicitly yourself. I'm never going to have 
enough fortitude to write thousands of pages of checks by hand; I've got to 
have language support to make those checks.

In any case, your vision of strong typing (which is many times stronger than 
what I could stand) is completely impractical for me. I tried it in the Claw 
builder, and the result is very hard to extend. To add a new kind of window 
object, one has to write implementations for roughly 80 primitive 
subprograms; roughly 5000 lines of code. To add a new capability, one has to 
add implementations of new primitive operations to all of the existing kinds 
of window objects (around 20 at last count). Either of those takes multiple 
days of work before anything can be compiled. Since I'm "agile" to my core 
(and long before such a thing even had a name), spending more than 4 hours 
or so writing anything without a compile/run/test cycle is scary. Especially 
as I can't really remember what I did if it goes longer than that; debugging 
takes much longer if more code is involved. (In such a case, you have to 
re-remember what your plan was for particular problems -- it's much more 
like debugging existing code than something you just finished writing.)

Anyway, I think we just have to agree to disagree on this one.

My goal is to bring more static detection of what are formally run-time 
errors in Ada. I don't think calling that "typing" is helpful in any way, 
because the mechanisms are so different. YMMV.

                                              Randy.