Stan Hanks 

· Follow
I've forgotten more languages than I use...Jan 10

Which programming language has the most interesting "backstory"?

We’re going to start in 1953.

Grace Hopper (yeah, that Grace Hopper) was tasked by Rand with the job of making it
easier for businessmen to use computers. She started off trying to teach them
programming with a very mathematical approach and instantly got pushback “throw
out those symbols, we don’t have time to learn those symbols”. This led to her deciding
that the way forward was to use English language keywords.

Her lizard overlords at Rand were not amused, saying that would be too cumbersome
and costly in terms of computer resources. Undaunted, Professor Hopper (y’all did
know she was a professor of mathematics before that whole Admiral thing, right?)
persisted and with her team designed and developed a prototype for a language called
FLOW-MATIC by around 1955.

Most of the nascent field of computer science evolved and communicated via letters
either privately circulated or published in various journals distributed monthly (how,
exactly, do you think that “The Communications of the Association for Computing
Machinery” got it’s name, mmm?). So her work - and the work of others (notably
Laning and Zierler) were not un-noticed. So a bit further up the road, John Backus
submitted a proposal to the Department of No at IBM to set out developing a very
different kind of programming language (which was uncharacteristically was
approved!), focused entirely on mathematical formulas, which were devilishly difficult
to render in assembler without screwing up. This eventually led to the first specification
of The IBM Mathematical Formula Translating System in late 1954.

And the race was on. Hopper was slogging through on how to make it possible for
computers to be more friendly to business users, Backus was slogging through making
computers more friendly for people with numbers to crunch, and that got other people
thinking…. and wow, suddenly a lot of effort was going into thinking about
programming languages

By about 1958, the ACM formed up a working group trying to bring peace to all and
formulate a “universal” computer programming language, in cooperation with the
German Gesellschaft für Angewandte Mathematik und Mechanik ("Society of Applied
Mathematics and Mechanics"). So, in May/June 1958, a conclave was formed in Zurich
at ETH to discuss forming the International Algorithmic Language or IAL.

The name? Kinda blew dead goats, so an alternative was picked — ALGOrithmic
Language. That kind of stuck, and was pushed forward.

The astute will note that despite John Backus being on the team from the ACM, he
continued to develop FORTRAN. Similarly, Dr. Hopper who likely wasn’t invited
continued with COBOL, and now we have this third interloper — which will remain
the focus of the story.

ALGOL was… mmm. ALGOL-58 had some serious deficiencies. Most of those were
rectified in ALGOL-60. And ALGOL-60 was kind of the mothership from whence
many other languages descended — and in the words of Tony Hoare, remained a
significant improvement over many of it’s successors.

In the early 60s at Cambridge, and at University College London, there was much
grumbling about ALGOL-60. Eventually, those researchers pooled their efforts into
what became known as CPL - the Combined Programming Language (or Cambridge
Plus London, if you were so inclined). Unlike ALGOL-60 which was stripped down to
the barest of necessities and relied on elegant design to solve complex problems, CPL
bulked up, adding “real solutions to real problem” found in all manner of computer
usage — there were nods to FORTRAN, to COBOL, to SNOBOL… there were even
hooks for industrial process control. It was, as the cool kids say, a thicc boi.

As such, it required hefty computing resources, and hefty financial support for those
resources, and the more support it got, the more it grew (imagine a great algorithmic
tick, attached directly to a vein of pure cash, expanding with every financial heartbeat).

In any event, by 1967, Martin Richards at Cambridge had had quite enough, and said
“how about if we just strip this down, but even past ALGOL-60”… and gave us, well, a
more basic language. Hey. That’s got a ring to it, a certain je ne sais quoi, right? How
about…. Basic Combined Programming Language. Yeah. That’s the stuff.

And hey! You can write it in itself! And it’s super easy to port because while the
concepts are portable but no claims are made about the programs. It’s all based on core
machine architecture types! And it’s très spiffy for writing systems code and compilers
and the like…

By 1969, there were versions for nearly two dozen completely diverse and different
computer systems, and people were starting to use it to write whole operating systems.
It was the most widely adopted such system for research purposes — noting the
FORTRAN was the number one for anything with math and formulae, and COBOL had
taken the business world by storm.

And one of those systems wound up being at Bell Labs, where Ken Thompson found
that BCPL with it’s machine word orientation was ill suited to the coming wave of
computer systems that were byte-addressable. Like the shiny new PDP-11 sitting in the
corner of the lab that he and Dennis Ritchie were supposed to play with now that their
access to the MULTICS project had been curtailed. So… he re-crafted BCPL to be…
sort of BCPL-lite. Maybe a quarter of BCPL? So we can call it…. B.

B had some strong positive points — it was very like BCPL, but also brought back
some of the ALGOL-60 features around data type handling. His desire was to create as
he put it “BCPL semantics with a lot SMALGOL syntax”. And in that, he succeeded
mightily. But it wasn’t quite right yet.

So starting around 1972, Dennis Ritchie undertook to fix the shortcomings. It was
designed to be more general purpose than B - suitable for writing applications as well
as systems code. And it was designed to take into account the widely divergent sizes
and types of computers coming into being. And by about 1974, he was done and he had
the thing that follows B — which of course was C.

C was the lingua franca of systems development and much of computer science
research for a very, very long time. It’s a non-nonsense get-shit-done programming
language, suitable for teaching as well as crafting very tense and performant code.

However, it was very firmly rooted in the ideas that had sprung from the late 50s, and
the times they were a changing. There was this Alan Kay fellow over in California at a
copier company who had this radically different idea about how programs might be
constructed, and how to even think about computation, and by the late 1970s, that was
catching fire in all sorts of interesting ways.

Even to the point that whacky Danish dude working on a PhD, Bjarne Stroustrup,
decided that hey, you know, maybe nothing as radical as Simula… but what if we
added classes and inheritance and strong typing and inlining to C?
In point of fact, that was the dynamic tension - he wanted Simula, but it was too slow;
and BCPL was lightning fast but onerous to write complex programs (<cough> fucking
lightweight <cough>) so he set out to create a tool that was performant, but also
provided abstraction. His first cut, C with Classes, cleared the bar for his PhD research,
and by 1982 he set out to really solve the problems of distributed computing as well,
which lead to something new entirely. Maybe a little better than C? C, incremented?
You know… C++

Initially, mind you, this was not a whole fully formed language. It was a preprocessor
package for C. The first public release in 1985, Cfront 1.0, was pretty decent but you
could still blow it up in a variety of entertaining ways — and figuring out where things
had gone south meant you had to be expert in C as well as this new C++ thing.

By 1987, GCC 1.15.3 kinds/sorta supported C++, which was a step in the right
direction, and in 1989 Cfront 2.0 dropped which was much better.

That kicked off the feeding frenzy that is an international standards gathering, and in
1990 the ANSI C++ committee was founded and then in 1991 the ISO C++ committee
was founded… and the knives were drawn and backbiting commenced.

Which led eventually to C++98/03 then to C++11 then to C++14 and C++17 and
C++20 and…

All of which started with “no, really, don’t make me learn new stuff”. Which led to a
big language, that led to a small language that led to a big language that led to a small
language that led to… Jesus, can you let me just write this in Java, m’kay?

Interesting? I think so.