Re: List Container Straw Man

["Nick Roberts" <nickroberts@adaos.worldonline.co.uk>]

"Ted Dennison" <dennison@telepath.com> wrote in message
news:AyTG7.18995$xS6.30775@www.newsranger.com...
> In article <9seup4$12h0ar$3@ID-25716.news.dfncis.de>, Nick Roberts says...
> >
> >Not really. My approach (as Ted's) uses generic packages instantiated
with
> >the element type. I use a hierarchy of tagged types to represent
iterators
> >(of gradually increasing complexity) based on that element type: it is
this
> >which ensures a common (iterator) interface.
>
> I don't really have any major problems with this approach in a component
> facility in general. The main issue I have with it for the effort we are
talking
> about is that it requires those multiple generic instantiations. That was
the
> complaint with Booch that started this whole effort. If people can live
with
> those, then my vote is for Booch. Otherwise, I think we are forced to
design
> things using only independant generic packages.

But I really feel this is like someone trying to argue that an aeroplane
would be much less complex if it didn't have any wings. In real software, I
am certain, my design would save great quantities of programming (writing
the same old thing over and over again for different container types). Ada
is supposed to be about software re-use; wouldn't it be a great shame if a
common containers library for Ada failed to facilitate re-use?

> My ideal component library, like yours, would be much more complex than
the
> strawman. Heck, it may even be the same as yours. But we aren't shooting
for
> ideal here. We are shooting for something *simple* that Ada newbies can
figure
> out w/o much trouble, but which is still usable for most serious
applications.

Well, I've shown a few examples of using my design. It basically requires
two instantiations (one generic parameter each). Students could learn this
pattern by rote until they got to understanding it (just like Sequential_IO
and Direct_IO). I can't believe that it's too complicated for anyone.

> If you can find a way to default things so that there's a way to use it w/
only
> one instantiation, I'd like to see it.

There is a way (you put the abstract types package instantiation inside the
container package), but this trick is poor design in most cases, since it
doesn't decouple the software so much. (A general principle of good software
engineering is to maximise the decoupling of the modules.) The user should
just do the two instantiations and not complain! It's only a bit of typing*.

--
Nick Roberts





*and Ada is a strongly typed language (sorry ;-)