Re: Separate Compilation in Programming Languages

[Brian Drummond <brian_drummond@btconnect.com>]

On Fri, 22 Feb 2008 17:35:33 GMT, <adaworks@sbcglobal.net> wrote:

>Recently, I have been engaged in some conversations with colleagues about the 
>value of
>separate compilation.    This is one of my favorite features in Ada.   In fact, 
>as nearly as
>I can tell, none of the other popular languages includes this feature in as 
>well-developed
>a form as Ada.  

One language which does have an equivalent mechanism (perhaps not surprisingly,
given its origin), and in which a similar debate is currently active, is VHDL.

There, the separation takes the form of the "component" specification, within
the consumer of a component. The consumer can instantiate a "component",
(similar to declaring a variable of a type defined separately) whose interface
is guaranteed consistent with its use by the compiler - and at this stage,
nothing is known about the implementation.

Separately, the component is defined as an "entity", and implemented as an
"architecture", which are again guaranteed consistent with each other during
compilation.

It is only at elaboration that an attempt is made to find an "entity" to match
each "component" specification; if there are any failures to match, of course,
elaboration fails with an error.

But there is also a way to bypass separate compilation by direct entity
instantiation, in which an entity specification is embedded in the consumer, in
the place of the component specification. In this case, the matching entity must
be found (already compiled and correct) for the consumer to compile.

Interestingly, in comp.lang.vhdl, the concensus seems to be that direct
instantiation is to be preferred where possible. (google comp.lang.vhdl for
"direct entity instantiation" if you need more of the debate). Two reasons are
usually mentioned: the component specification is just one more piece of code to
write and maintain; (and VHDL is perceived as verbose enough without it), and
forcing the entity/arch to compile concurrently with the consumer is perceived
as catching any errors earlier (i.e. compile time vs elaboration). In other
words, as said here for Java, compilation is cheap.

>This morning, after an especially interesting argument about this feature and, 
>"Why would
>anyone want to do such a thing?" style questions, I decided to approach this 
>forum.  What
>is your view of Ada-style separate compilation when compared to that in other 
>languages?
>Do you find it useful in your own practice?  

I am  out on a limb in still using components, and I'm not entirely clear why I
do, other than mild personal preference, and because the toolset I use
encourages it; it works perfectly well for me. Though I have occasionally had
elaboration failures due to component mis-specification, they haven't caused any
real headaches.

I'm not clear why the theoretical advantages of separate compilation aren't seen
as advantages in practice (in the VHDL world); the outspoken critics are
respected consultants and trainers; possibly they are in one-man or small-team
environments rather than million line projects. 

Possibly separate compilation was a big win when you had 8K of core and a drum
store, but a bit less important nowadays? (coming back to "compilation is cheap"
again)

I'm in a one-man project environment myself, where I can't see a clear win for
either side of the debate; separate compilation certainly doesn't impose
significant drag, except where tool bugs prevent making good use of packages and
libraries. But that's another issue...

- Brian