Re: memory management in Ada: tedious without GC?

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Georg Bauhaus <see.reply.to@maps.futureapps.de> writes:

> Robert A Duff wrote:
>> I see zero advantage to allowing arbitrary order for
>> the calls to Initialize and Finalize.  And one huge disadvantage -- if
>> you depend on the order, either on purpose or by accident, you might get
>> a bug introduced years later, when you switch compilers (or even
>> compiler versions).  It will be very hard to detect and to fix that
>> bug!
>
> OTOH, defining finalization order just by referring to
> the order of components in the source text seem the weakest
> mode of expression.  It is also in the way of ordering
> components in source text by grouping criteria unrelated
> to finalization.

Well, when I write:

    procedure P (...) is
        This : ...;
        That : ...;
    begin
        ...
    end P;

This and That are initialized in order, and finalized in reverse order.
I don't find that strange.  So why shouldn't record components
be the same?

> When finalization order is important, couldn't the language
> enable the programmer to just state the order?
>
>   for T'Finalization_Order use
>     record
>       Component_1;
>       Component_3;
>       select
>          Component_4 or Component_5;
>       end select;
>       Component_6;
>     end record;

It could, but it seems like a lot of mechanism.

Part of my point is that you might write a program that depends on
finalization order by accident.  You write the program, test it, and it
does what you want.  You don't want the order to change in the future,
but since it's by accident, you can't be expected to write
"for T'Fin_Order...".

> The "or" would mean any order is fine.
> Omitting a component would mean the compiler is free to choose
> when to finalize.

I can't think of any advantage to allowing the compiler to choose the
order.

- Bob