At 11:08 PM 4/11/98 -0500, W. Wesley Groleau x4923 quoted:
> Contrast this method with the more common approach where once the
> program is coded, the engineer immediately tries to compile it. The
> compiler then leads the engineer by the nose from one problem to the
> next. When the program finally compiles, the engineer is so relieved
> that the immediate desire is to see if it will run. One of the best
> clues that a shop follows this approach is complaints about how slow the
> compilers are."
> -- Watts S. Humphrey
> A Discipline for Software Engineering
How true it is, but especially with Ada 83 there was another similar
phenomenon that showed up. If poor abstraction results in compilation
units with hundreds of with clauses, you hear about ow slow the compiler is
and the contractor starts looking for another compiler vendor. In my role
at MITRE, I often used to get called in on those problems, and a few days
work with the contractor could reconfigure things to take compile times
from hours to minutes.
But there was a side effect which always surprised the contractors, and
I could never understand why. (Why they were surprised, not why it
happened.) The number of recompiles dropped dramatically.
So I argued during the 9X development process that fixing this
"problem" in Ada would be misguided. Unfortunately, one of the side
effects of the GNAT approach to program libraries is that the penalty for
too many with clauses is much reduced, although it doesn't go away
entirely. I've actually had to convince projects to accept guidelines...
(More than six withs on a package spec, or fifteen on a package body
indicates that there is restructuring that should be considered. There are
good arguments for having more withs on the main program, but a with on a
subunit is almost always an indication of a design problem.)
Robert I. Eachus
function Message (Text: in Clever_Ideas) return Better_Ideas is...