Re: What would you like in Ada202X?

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

<sbelmont700@gmail.com> wrote in message 
news:2867357.127.1335561067669.JavaMail.geo-discussion-forums@ynee1...
>procedure Shut_Down_Reactor (Reactor : Reactor_Type) is null;
>
>is quite literally a disater waiting to happen.

Sure, but bad management is not a reason to not include a language feature 
that is useful.

> Ada is all about being explicit,

And this *is* explicit. It says "is null", it doesn't imagine that.

>and takes a harsh stance on things that could be misused or abused to make 
>a program confusing (i.e. overloading, >etc), yet it gives an express lane 
>for writing subprograms that by definition don't do what they intend.

This is a significant misreading of Ada's design. Ada 83 included operator 
overloading, even though it is EASY to abuse that to write a confusing 
program:

     function "*" (Left, Right : My_Type) return My_Type is
     begin
          return Left + Right;
     end "*";

The Ada 83 Rationale has an explicit statement about this; the feature was 
included because it was useful, even though it can be misused.

And there are many other features (new and old) that can be abused.

We've talked about this several times in the ARG, and our feeling is that it 
is not our job (or the language's job) to prevent intentional misuse of the 
language. What Ada strives for is eliminating *unintentional* misuse; it 
hard to see that in this case (this is clearly intentional). There is no 
replacement for sensible and enforced programming style (and management that 
understands that without being heavy-handed).

Null procedures are intended to be used in places where doing nothing is a 
reasonable default action. For instance, when you have a "hook" that you 
wouldn't always use. One example was the (eventually rejected) storage pool 
dereference procedure; most pools would have no use for it, so it could be a 
null procedure; pools that did have a use for it could replace it with 
something interesting.

Note that Ada 95 did that (implicitly) for the Initialize/Adjust/Finalize 
routines of type Controlled. We made that more explicit in Ada 2005, but 
that did not reflect any language change. This is another example of a 
"hook".

Using a null procedure for something that must have an action is a serious 
bug, one that could not fail to be caught by a code review (it's hard to 
miss the very explicit "is null" in the code).

> The phrase "where the default behavior is null" is a contridiction in 
> terms; calling
> a subprogram to achieve the effect of not calling a subprogram is simply 
> bananas.

As noted above, it's common to have "hook" routines that aren't used in most 
implementations. It's impossible in general to remove those calls, so what 
else would you have the subprogram do??

                                      Randy.