Here is a story from the world of programming…
The story revolves around a very prodigious programmer, Mel, who was ahead of his time. He would use the qualities of the hardware in order to improve his code. Later on, his friend, the storyteller, refused to correct Mel’s bug because he discovered that he made a very clever trick.
A recent article devoted to the macho side of programming
made the bald and unvarnished statement:
Real Programmers write in FORTRAN.
Maybe they do now,
in this decadent era of
Lite beer, hand calculators, and “user-friendly” software
but back in the Good Old Days,
when the term “software” sounded funny
and Real Computers were made out of drums and vacuum tubes,
Real Programmers wrote in machine code.
Not FORTRAN. Not RATFOR. Not, even, assembly language.
Raw, unadorned, inscrutable hexadecimal numbers.
Lest a whole new generation of programmers
grow up in ignorance of this glorious past,
I feel duty-bound to describe,
as best I can through the generation gap,
how a Real Programmer wrote code.
I'll call him Mel,
because that was his name.
I first met Mel when I went to work for Royal McBee Computer Corp.,
a now-defunct subsidiary of the typewriter company.
The firm manufactured the LGP-30,
a small, cheap (by the standards of the day)
and had just started to manufacture
the RPC-4000, a much-improved,
bigger, better, faster — drum-memory computer.
Cores cost too much,
and weren't here to stay, anyway.
(That's why you haven't heard of the company,
or the computer.)
I had been hired to write a FORTRAN compiler
for this new marvel and Mel was my guide to its wonders.
Mel didn't approve of compilers.
“If a program can't rewrite its own code”,
he asked, “what good is it?”
Mel had written,
the most popular computer program the company owned.
It ran on the LGP-30
and played blackjack with potential customers
at computer shows.
Its effect was always dramatic.
The LGP-30 booth was packed at every show,
and the IBM salesmen stood around
talking to each other.
Whether or not this actually sold computers
was a question we never discussed.
If you want to continue reading the story, check this link:
Behind the story
According to Wikipedia, the Story of Mel details the extraordinary programming prowess of a former colleague of his, “Mel Kaye”, at Royal McBee Computer Corporation.
Although originally written in prose, Nather’s story was modified by someone into a “free verse” form which has become widespread.
The story as written by Nather involved Kaye’s work on a request by his company sales executives. They wanted to modify a program so that they could cause the program to lose and the user to win. Kaye reluctantly acceded to the request. To his own delight, he got the test wrong. In other words, the program would instead cause itself to win every time.
Subsequent to Kaye’s departure, Nather was asked to fix the bug. While examining the code, he was puzzled to discover something peculiar. Precisely, it contained what appeared to be an infinite loop, yet control did not remain inside the loop.
Eventually he realized that Kaye was using self-modifying code to process elements of an array, and had coded the loop in such a way as to take advantage of an overflow. Adding 1 to the address field of an instruction that referred to address x normally just changed the address to x+1. But when x was already the highest possible address, not only did the address wrap around to 0, but a 1 was carried into the bits from which the opcode would be read—in this case changing the opcode to “jump to” so that the full instruction became “jump to address 0”.
This impressed Nather so much that, out of respect, he gave up the task and reported that he could not find the bug.
Little is known about Mel Kaye. He was credited with doing the “bulk of the programming” on the 1959 ACT-1 compiler for the Royal McBee LGP-30 computer.
If you have enjoyed this article, please share it! More interesting articles will be coming soon. So enjoy reading with Enicarthage Press and stay safe!