In 1966, Kenneth Iversen came to New Jersey to give some lectures
about his
programming language called APL, which was causing a small
sensation. This programming language required a large symbol set (the
sort you found on a fine IBM typewriter rather than an ordinary card
keypunch machine). It was, I think, one of the first programming
languages to define operations in turns of the data to be processed.
For example, the same symbol for summation could cause two numbers,
or two vectors, or two matrices to be summed. The language used terse
symbols to invoke powerful operations on data, and consequently, very
powerful programs could be written in just a few abstruse symbols.
I went to one of the lectures on APL, examined the handouts, and
hung on Mr Iversen’s every word. In the Q&A session, I asked a
question. The handouts suggested that there was no way to call a
subroutine in APL. How in fact, would I create APL functions and
subroutines?
Kenneth Iversen frowned at me. What in the world made me, a young
software punk, think that his elegant language required subroutines?
Subroutines were
old hat; no modern software system would
ever require them again. Clearly, my question marked me as a
slow-footed relic of the past.
My remark did more than annoy Iversen. A number of other people in
the audience, well-dressed professors, agreed with him and expressed
their annoyance in angry stage whispers. How could anyone think that
APL, with all its concise power, might require subroutines?
I felt awful. I think of myself as a quick thinker, and here I was
revealed as a dumbhead. All those important people agreed. No one
defended me. And I felt even worse, because, well, I was sure that in
order for APL to be useful, the language would need functions and
subroutines.
The ability to write functions and subroutines was added to APL a
year later.
After two days of banqueting, my weight has jumped to an alarming 219.4. I expect it to get back to 217 pretty soon.