The Battle Hum

Home Back to humor page

This song was written in the spring of 1971.  I am trying to track down the exact authorship, but I can say that I had nothing to do with it.  The authors were some subset of  Roy Levin, Chuck Weinstock, Mady Bauer, Chuck Pierson, and maybe a few other of the "DEC/5" group from the Computer Science Department.

This song is incomprehensible to anyone who didn't actually take the test, or at least know someone who did.  Here's the backstory:

Alan Perlis, one of the three founders of the Computer Science Department at Carnegie Mellon University, decided to retire from being department head.  He also decided that his presence would make it uncomfortable for any new department head to come in; "it would be like living with your mother-in-law," he said.  So he accepted a position as a faculty member at Yale University, in New Haven, Connecticut. But his parting shot was to construct the "24-hour qual", a Ph.D. qualifying exam that was given out at 10am one day and was to be returned no later than 10am the next day.  You could any resources you wanted to answer the questions, but could not consult with any other person.

I was one of the seven people who took this exam.  Four of us passed, and I was one of the four.

One of the questions involved the "Ackermann number" of a programming language.  The "Ackermann number" was defined as the largest value of the second argument to Ackermann's Function that could be computed by a single line in the programming language.  There was a careful definition of the meaning of "line", but, for example, in Algol, a function that contained more than one semicolon contained more than one line.

We were asked to give the Ackermann Number of languages such as FORTRAN, APL, LISP, Algol, and Snobol.  Then we were given some extensions to the languages, such as the "execute" operator, which allowed you to take a string and execute it, and asked to compute the Ackermann number under these extended languages.  LISP was infinite, as was APL and Snobol with "execute" extension.  FORTRAN was 1, and I think Algol was 2, but I no longer remember.

We also had to discuss Gödel number encodings, and answer some additional questions on APL and Snobol.

When someone asked Alan why he had created such a downright miserable exam, he said, "The List," by which he meant the list of Ph.D. candidates, "is much too long."  So his purpose was to filter out the weaker students.

For those who don't know the semantics of Algol-60, a concept called "call-by-name", which we would recognize today as the concept of "closure" in some languages, involved evaluating a formal parameter   Instead of pass-by-value (which we have in C and C++), or pass-by-reference (which is pass-by-value, except the value is the pointer to the object, and is either the type & or type * style of parameter in C++), this actually involved evaluating the expression each time it was used.  So if the expression involved a variable that was global to the called function, and the called function modified the global variable, then each time the formal parameter was used, the latest value of the global variable.  If you will, imagine that in C++, if you wrote

int i;
void f(int byname e)
   {
    int sum = 0;
    for(int k = 0; k < limit; k++)
      {
       i++;
      sum += e;
     }
   }

then if it were called as

int data[SomeLimit];
// load data values
f(data[i]);

then each time that formal parameter e was evaluated, the expression passed in, "data[i]", would be re-evaluated!  So it would always reflect the current value of i in this evaluation.

Needless to say, this is incredibly complicated to evaluate, especially if there was a line of the form

e = expression;

because then the current element of data[i], given whatever the current value of i, will change!

This involved writing two subroutines, a "fetch" subroutine and a "store" subroutine.  The "store" subroutine had to evaluate to a distinct location; if it couldn't, this was a fatal runtime error.  These little pieces of code were called "thunks" by their inventor, P.Z. Ingermann.  Back around 1990, I tracked him down and asked him the history of the name, and he said "it represents that past tense of "think", as in, "we thunk about it".  I did this because at that time I was contributing to The New Hacker's Dictionary, and the alternative story, which was equally credible, was that "thunk" was the sound the value made as it hit the accumulator.  But this myth was busted by the man who named them.

The final part of the third verse deals with the acquisition of the IBM 360/67 computer.  CMU was one of the first six sites in the world to have an IBM 360/67, the first of IBM's virtual memory machines.  It came with IBM's TSS/360 operating system.  TSS was a dog.  Big, slow, clunky.  Far less efficient than the old standby, OS/360, which was already big, slow and clunky.  But OS/360 did not support interactivity.  The IBM Cambridge Research Laboratory had come up with a new operating system, "CMS".  I don't recall all of the acronym, but the original meaning of the "C" was "Cambridge".  It was lean, mean and efficient.  It was also one of the earliest instances of what we would now recognize as a "Virtual Machine Environment"; CMS allowed multiple instances of operating systems to run.  They could be trivial little single-user interactive environments, like a BASIC system, or a full-fledged OS, such as OS/360.  The "C" was later renamed to something else and the OS was made more generally available.

At that time, CMU was looking at increasing the availability of computing to the general campus environment.  Originally, the 360/67 was paid for by the ARPA research grant, but due to changes in the rules for grants, the machine had to be used exclusively for Computer Science research, and could not be used for general-purpose campus computing.  So control of the 360/67 was transferred to the general University computing facility, and Computer Science acquired a DECSystem-10 (a KA-10, to be model-specific), a highly-effective computing environment.  We made the case that the University should also acquire several KA-10s to support campus computing.  But one person, who shall remain nameless, had staked his reputation on the 360/67, running TSS/360 (not CMS) was the Future Of Computing.  So behind the scenes, hastily, he committed to several long-term contracts for peripheral devices, such as the disk drives.  So, unfortunately, it was not cost-effective to acquire the KA10s, because of the defaults if the disk drive contracts were cancelled.  For the next several years, the University was stuck with a machine that was essentially obsolete at the time of its acquisition (early 1971).

Now "acquisition" was a new concept to IBM.  IBM never sold computers; they only leased them.  But by 1971, this was no longer sustainable as a business practice.  So IBM was happy to unload this dead old hulk, originally worth about $10,000,000, for a mere $2,000,000.  And it was overpriced for its value.

In the summer of 1967, Carnegie Institute of Technology, know as "Tech", changed its name.  It merged with the formerly private research institute, Mellon Institute, and became Carnegie-Mellon University.  Some years later, the hyphen was dropped.  I was accepted as a student by Carnegie Tech, attended and graduated from Carnegie-Mellon.  I sometimes get twitted for spelling it with the hyphen, but my diploma spells it that way.  The fact that it is now Carnegie Mellon (no hyphen) does not change the name of the place I attended!  But in 1971, it was still widely known as "Tech".

Send mail to newcomer@flounder.com with questions or comments about this web site.
Copyright © 2010 Joseph M. Newcomer,  All Rights Reserved.
Last modified: May 14, 2011