Thanks, Wesley, for this very appropriate excerpt!

A comment on one part in particular:

>  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.

This describes quite well one stage of the software folly that I've
sometimes called "empirical programming".  The next stage begins
where this description ends: with seeing if it will run.

When the program fails to run, the "engineer" tinkers with it to
try to get it to work, without a clear understanding of the
language or the operation of the program.  Eventually, the program
may seem to work as intended, but it is littered with the debris of
failed experiments, its design (if there was one) muddled.  If
significant testing is done, the failures revealed may lead to
still more tinkering.

This is clearly not the path to reliable, maintainable software,
but it is an approach that can be inadvertently encouraged by
programming environments that promote quick recompilation.  It is
also encouraged by an inadequate understanding of the programming
language, which in turn can be the result of imprecise language
definition, poor language documentation, or lack of training.  The
Ada community is fortunate to have the benefit of an excellent and
readily available reference manual that is taken seriously by the
implementors of compilers.

It is surely difficult for a novice in any language to get started
without some of this kind of experimentation, but the goal should
be to move on to a reasoned approach.

- Jim