Re: Ripple effect

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

"Robert A Duff" <bobduff@shell01.TheWorld.com> wrote in message
news:wccodtr4jhx.fsf@shell01.TheWorld.com...
> "Randy Brukardt" <randy@rrsoftware.com> writes:
>
> > I guess I disagree -- simply knowing about a type doesn't require
objects to
> > be created.
>
> True.  But if you know about a type, why are you not allowed to create
> objects, or parameters, or do anything else that requires its name?

Knowing about a type is a completely separate issue from knowing its name.
That's required here simply because the syntax of declarations requires
giving the name, not because you actually intend to use that name for
anything.

...
> >... (If the object comes from somewhere else -- a common case, such
> > as when an access to it is passed in -- no with is needed).
>
> I'm not sure I understand.  Can you give a realistic example?

Well, a relistic example would be large and take a long time to create. What
I'm thinking about is cases where you have a private type that is simply
passed through a routine to another layer. I find this sort of thing common
in some designs (it depends on how the low-level types are encapsulated).
So, if you have a routine something like:

     procedure Foo (Obj : in Something; Other_Data : in Integer) is
     begin
           if Other_Data < 0 then
               X.Flob (Obj);
           else
               X.Flub (Obj, Other_Data);
           end if;
     end Foo;

Assume that the parameters of Flob and Flub are classwide (and Something is
tagged). In this case, no other information is needed, and it isn't
necessary to "with" the place where X.Flob's parameter is declared, and drag
all kinds of stuff you're not going to use into visibility. This is quite
common, except that the need to repeat the name of the type in the
subprogram declarations often causes an otherwise unnecessary dependency.
"Limited with" can break that in some cases.

...
> > Huh? I often check for unused with clauses in my programs - by hand, and
> > generally not because of compiler warnings (although we get those, too).
I
> > often try to eliminate things that are used only once. I guess I'd agree
> > more if you said "rarely" as opposed to "ever".
>
> OK, "rarely" then.  It's hard to do that sort of thing by hand.
> It's not just unused with_clauses that accumulate during maintenance,
> but all kinds of other unused things (use clauses, variables, etc).

Unused withs are easy to do by hand if you rarely use 'use' clauses: simply
use your editor to show all occurrences of the name of the unit. If there is
no hit other than the with clause itself, its unused. If there is only a use
clause, (and no other uses), I'll comment out the use clause and see what
happens in a recompile (and add comments if it turns out to be needed so I
don't do it next time).

I generally don't bother eliminating other unused things, although the
technique is the same. Well, I'll do variables if cut-and-paste operations
are potentially creating a lot of them. (Janus/Ada does not have any unused
warnings other than for with clauses; it's almost one-pass design makes that
very hard).

                        Randy.