Re: Your wish list for Ada 202X

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

"Niklas Holsti" <niklas.holsti@tidorum.invalid> wrote in message 
news:brepivFq9kcU1@mid.individual.net...
> On 14-04-19 00:28 , Randy Brukardt wrote:
>> "Niklas Holsti" <niklas.holsti@tidorum.invalid> wrote in message
>> news:brdegqFi62jU1@mid.individual.net...
...
>> One of
>> the things that attracted me to Ada in the first place is that it forces 
>> me
>> to specify enough that it prevents many of my worst impulses.
>
> I learned programming with Algol and did not encounter C until I had
> experienced various forms of BASIC, COBOL, and Fortran (plus a few
> assembly languages). This shielded me, I think, from being tempted to
> use C-style short-cuts. So, perhaps unusually, I don't feel at all
> constrained by Ada's requirements on explicitness, careful
> specification, and strong typing.

Well, I started with various programmable calculator "languages" (really a 
machine language), then Fortran, then various Basics, then Z80 assembler, 
then a language survey class, then a class with C language assignments. The 
only school assignment that I didn't get to work by the due date was in C. I 
spent several hours after presenting it to the professor trying to figure 
out why one of the guns wouldn't fire (it was supposed to a game on a vector 
display, which we had to demonstrate -- I chose something vaguely like Space 
Invaders, which was new at the time). It proved to be an access beyond the 
end of an array that corrupted the firing table. I think I've written 7 or 8 
lines of C since. :-) [C is now pretty much a read-only language for me, 
sort of like French.]

But for me, I don't the languages used would make that much difference. My 
Dad is a tinkerer who would rather try for 4 hours to start a malfunctioning 
chain saw than to just take it to a repair shop and do something else. 
(That's the story from this past weekend, so some things change little!) I 
certainly learned that from him, and I *know* I'd dream up insane ways to 
get the job done if the language didn't impose some sanity. Maybe a little 
less so than in years past, but probably not enough to actually accomplish 
anything.

...
>> I'd prefer a much simpler declaration of inheritance, something like:
>>    type Child is new Parent with ...
>>       with inherits => Foo, Bar, Blech;
>>
>> where names not listed are hidden from all visibility unless overridden.
>
> This form would probably strongly discourage overloaded operation names.

Possible, although in many instances, all of the overloaded routines do 
essentially the same thing and thus either all need overriding or none do. 
(After all, if you have overloaded routines doing *different* things, 
something is wrong!)

>> Whether that's enough or if some alternative with optional profiles is
>> necessary, I don't know. Most operations aren't overloaded, after all, so
>> the profile is just noise.
>
> I have quite a few overloaded primitive operations, perhaps because I
> tend to use named association in all calls so that the parameter names
> extend and clarify the brief operation name.

Yes, that works. But still, you probably don't have too many Open operations 
that close objects. :-) As I said, I've found that it's common that you need 
to override all of the Open operations (because they all need to set a new 
component, for instance, or call a different Open routine that does that), 
or the original versions are all good enough. Perhaps that's different if 
multiple inheritance gets involved, but it certainly seems true for single 
inheritance.

But I don't claim to know the best way to do this, and it's pretty 
irrelevant for Ada anyway (it would be way too incompatible to require for 
derivations unless a new kind of derivation was involved - and it would take 
some imagination to figure a reason for needed a new kind of derivation).

                                     Randy.