Re: Separate Compilation in Programming Languages

[Ray Blaak <rAYblaaK@STRIPCAPStelus.net>]

"John W. Kennedy" <jwkenne@attglobal.net> writes:
> Actually, this doesn't accomplish as much as you wish, in practice, as it will
> eventually be necessary to have a constructor for the real class, or else a
> static factory method.

That is true. There are ways around this. The simplest way is to have a
factory class that is dynamically loaded by some other startup class that
client code does not see. That way clients are never affected by the
implementation classes.

interface IWidgetFactory
{
  // Root client API methods:
  public IWidget createWidget(blah, blah) {...}
  ...
}

class WidgetFactoryAccess
{
  static private IWidgetFactory instance = null;

  static public IWidgetFactory getInstance() {return instance;}

  // Called by start up logic.
  static public void register(IWidgetFactory f) {instance = f;}
}

You can also do tricks like dynamically loading the implementation class at
runtime from some environment-specified jar. That way there are also no
compilation dependencies.

Again, all this takes effort and discipline. For larger applications, one also
needs to take the trouble to control the subsystem layering, since a good
orthogonal design actually improves compilation times when the dependencies
are minimized.

This kind of thing is easier in Ada.

-- 
Cheers,                                        The Rhythm is around me,
                                               The Rhythm has control.
Ray Blaak                                      The Rhythm is inside me,
rAYblaaK@STRIPCAPStelus.net                    The Rhythm has my soul.