Re: Ada95 tutorials with sample code.

[Ted Dennison<dennison@telepath.com>]

In article <3AA48DE9.A0650F21@emw.ericsson.se>, Sven Nilsson says...
>
>(which I'm sure has been discussed countless times before) BUT
ohhhhh yeah.....

>This use-thingy. Is it really ant good? I've only ever used Ada in HUGE
>projects with loads of people writing the code and I've found that the
>use-clause can be a real pain as it dosn't give you a clue as to where
>things are declared. Right now I'm teaching new arrivals about Ada 95
>and I invariably tell them NOT to use the use-clause. 
>Now, there're a lot of very clever and skilled people reading this
>news-group and I'd be interested in your feelings on "use". Is it a Do
>or Don't? Generally speaking?

That's a subject of much (often vitrolic) debate. Personally, I'm with you. Most
of my Ada projects are in the >100KSLOC range and I *lothe* use clauses. This is
probably partly because I often get called in to try to figure out what's going
on in the worst-written code in the system, thus I don't get a chance to see
them used well (assuming there really is such a thing. :-) ).

I should also mention that none of this goes for the "use type" feature of
Ada95, which IMHO is the best thing since sliced bread. :-)

I see that most of the other responses so far are along this same line. Its a
shame Dr. Dewar (of NYU and Gnat fame) never came back after Deja went under,
because he could probably give you the best pro-use argument. If I remember
right, one of the main pro-use compaints is that with the new child package
feature, names just get rediculous if you are pedantic about "no uses". 

The common example used is Ada.Strings.Unbounded.To_Unbounded_String. Even I
have to admit this looks stupid. However, I'd claim that the stupidity is
entirely a result of stupid naming on the designers part. They quite easily
could have named the routine Ada.Strings.Unbounded.To, rather than repeating the
names of two parent packages in the subprogram's identifier.

Another point I remember Dr. Dewar making is that some modern compilers (eg:
Gnat) have features that allow you to find the declaration of any object in the
editor. My argument is that this only works if you are always reading the
sources in the editor (eg: no printouts), and only when the code is in a
compilable state. Also, it doesn't help with those situations where a reader
might incorrectly think that they know where an object is comming from and
therefore not check.

Rather than teach folks that "use is evil" (as I do :-)  ), I'd suggest that you
take the following approach:

o  Point out that many (most?) large projects either forbid or severly restrict
the use of this feature due to supposed maintainability issues. 

o  Try to mention all sides of the debate. Feel free to give your personal
stance as well. :-)

o  You may want to consider making a class style-guide for assigned work, if one
style particularly bothers you.

o  Emphasise that anyone writing software that might be used by someone else
operating under different use-clause rules (eg: reusable components or
libraries) should be very sensitive to the names they give things. In
particular, restating the name of the package (or a parent package) in an
identifier should be avioded. If the names of the parent packages is considered
important, the user can use the full notation. 

---
T.E.D.    homepage   - http://www.telepath.com/dennison/Ted/TED.html
          home email - mailto:dennison@telepath.com