Re: How to get Ada to ?cross the chasm??

[Paul Rubin <no.email@nospam.invalid>]

gautier_niouzes@hotmail.com writes:
> Which extra work do you expect without GC ?

For example, in your "corporate bullshit generator" I see functions like:

   function Sentences (Possible_Dialog_Mark : String) return String is
   begin
      case R100 is
         when  1 ..  33 =>  --  Recursion stops in this case. Prob = p.
            return Sentence;
         when 34 ..  80 =>
            return Sentences (Possible_Dialog_Mark) & Sentence;
         when 81 .. 100 =>
            return
               Sentences (Possible_Dialog_Mark) &
               Paragraph_End_Mark & Paragraph_Mark &
               Possible_Dialog_Mark & Sentence;
      end case;
   end Sentences;

This function appears to call itself recursively, generating a bunch of
strings and concatenating them together.  I'm not sure but it looks to
me like these concatenations are done by copying the strings around,
which is quite inefficient once the strings get large and the recursion
gets deep.

What the function is really generating is a tree structure, with nodes
that can be expanded into further nodes or to sentences.  So you should
really represent those sentences as trees, where you print a sentence by
traversing the tree recursively.

You can do the same thing with job titles: they are really structures
too.  If Alice is the co-assistant-vice-president of whatever, then
Alice's assistant would be the assistant-co-assistant-vice-president of
whatever, and so on.  She could have senior and junior assistants,
co-assistants, and executive assistants, they'd have assistants of their
own, etc.

Now let's say Alice's job title is X (represented as a tree).  She hires
Bob as an assistant, so Bob's title is assistant-X.  Bob's job title
should be a node with a field saying "assistant" and a pointer to
Alice's job title.  The company directory has an entry for Alice
containing her name and a pointer to her title, and a similarly entry
for Bob.  Note that Alice's title is a subtree of Bob's title, so they
share structure in memory.

Next, Alice leaves the company.  Bob doesn't get a promotion (keeping in
the spirit of your program, he's an assistant who happens to not assist
anybody) and he is still in the directory.  So you have to keep Alice's
title around until all of her assistants have also left or been promoted
or whatever.  But then you have to free the memory, or else your program
has a leak.

There are various ways you can deal with this storage management issue.
So you can think up a workable approach, implement and debug it, write
regression tests and monitoring for it, etc.  Or you can just not think
about it at all, allocate new data whenever you want, and let GC take
care of freeing it.

I vote for GC :).