* The Emperor's Old Clothes
* Author: C.A.R. Hoare

Hoare has a lot to say about programming language design, system
design, and software engineering.

Programming Languages: Hoare believes languages should be safe,
i.e. nocore dump should be possible for a program that passes the
compiler.  They should also be possible to optimize in the sense of
producing small object code and very efficient procedure calls.
Compilers should be single pass.

Second Systems: This lesson is also in The Mythical Man Month.  After
one success, systems builders think too grand and their second systems
are too large and complex to be realized.  Another lesson is that a
system will only work as a coherent whole if it can be fit into a
*single* person's head.  In TMMM this idea leads to the surgical team
analogy; for Hoare it corresponds to his realization that he must
personally understand what his programmers are doing in order to
ensure that projects will be completed.

There are many memorable quotes from this paper:

"I would have it regarded as the highest goal of programming language
design to enable good ideas to be elegantly expressed."

On array bounds checking: "In any respectable branch of engineering,
failure to observe such elementary precautions would have long been
against the law."

On software engineering: "You know what went wrong?  You let your
programmers do things which you yourself do not understand."

"Earlier attention paid to quite minor requests of our customers might
have paid as great dividends of goodwill as the success of our most
ambitious plans."

"...the design of a program and the design of its specification must
be undertaken in parallel by the same person, and they must interact
with each other."

"You know, you shouldn't trust us intelligent programmers.  We can
think up such good arguments for convincing ourselves and each other
of the utterly absurd."

From Turing himself: "How can one check a large routine in the sense
of making sure it's right?  In order that the man who checks may not
have too difficult a task, the programmer should make a number of
definite assertions which can be checked individually, and from which
the correctness of the whole program easily follows."

"There are two ways of constructing a software design.  One way is to
make it so simple that there are obviously no deficiencies, and the
other way is to make it so complicated that there are no obvious
deficiencies."

"Programmers are always surrounded by complexity; we cannot avoid
it.... If our basic tool, the language in which we design and code our
programs, is also complicated, the language itself becomes part of the
problem rather than part of its solution."

"There is nothing a mere scientist can say that will stand against the
flood of a hundred million dollars.  But there is one quality that
cannot be purchased in this way--and that is reliability.  The price
of reliability is the pursuit of the utmost simplicity."

Other things in the paper:

The spectacular failure of the Elliot Mark II system: they failed to
make plans for the efficient global use of scarce memory.  The part
completed, a compiler for Algol 60, thrashed (it compiled 4-8
chars/sec).  There was no virtual memory system.

A partial redemption after the failure: they started listening to
their customers.  They assigned small groups of programmers to work on
specific types of customers.  No feature requiring more than three
months was undertaken.  No project was undertaken unless Hoare himself
understood it.

A tirade against Algol 68, PL/I, and ADA: All marred by too many
features, overwhelming complexity, and unclear specifications.  Hoare
thought ADA scary because of its application to military systems.

What is the meaning of the final story?

What specific lessons can we take away?