History of languages: the freewheeling fifties

“Programming in the America of the 1950s had a vital frontier enthusiasm virtually untainted by either the scholarship or the stuffiness of academia”
John Backus

The 1950s were the pioneering days of programming languages. Much of the code written until the 1970s would be unstructured. Many of the modern language constructs were yet to be designed, and compilers were often closely linked with the particular memory requirements of a machine. The 1950s heralded the move away from programming by means of machine language to languages with a more “English-like” syntax. Here’s what John Backus had to say about the 1950s:

“Just as freewheeling westeners developed a chauvinistic pride in their frontiersman-ship and a corresponding conservatism, so many programmers of the freewheeling 1950s began to regard themselves as members of a priest-hood guarding skills and mysteries far too complex for ordinary mortals”.

Of major note was the development of Fortran. Backus states that Fortran did not evolve out of some “brainstorm about the beauty of programming in mathematical notation”, but rather simple economics: programming/debugging costs > running costs. Part of the issue was dealing with floating-point calculations. In 1954, the IBM 704 was released, the first mass-produced computer with floating-point arithmetic hardware. This had the effect of speeding up floating-point calculations (by a factor of 10), so effort was now diverted to making the job of the programmer easier. The goal of the FORTRAN Project was “to enable the programmer to specify a numerical procedure using a concise language like that of mathematics”. At the time it was expected that such as system would reduce the coding and debugging task to less than one-fifth of what it had been.

By the late 1950s, programming language design was in its heyday. In 1958 a committee was formed to design a universal, machine-independent programming language. The result was ALGOL, or ALGOrithmic Language, what we now know as Algol58.  ALGOL became the blueprint for the way languages would evolve for the next three decades (and spawn some crazy languages: MAD, JOVIAL, and NELIAC). ALGOL used bracketed statement blocks and was the first language to use begin end pairs for delimiting them. 1959 (specifically May 28/29) saw the start of work on COBOL, a language dedicated to business computing. By 17 August 1960 the first Cobol compiler was completed. Cobol, unlike both Algol and Fortran relied heavily on the use of “English”-like syntax. The same year of 1958 also saw the birth of Lisp, designed by John McCarthy.

The end of the decade saw the four distinct families of languages emerge: Fortran, Algol, Cobol, and Lisp. Whilst the use of Algol would eventually diminish, it likely had a greater influence on the future programming languages than its contemporaries Fortran and Cobol, who would themselves evolve, but who influenced far fewer languages. Lisp would also evolve, but in a more niche way in the sphere of artificial intelligence.

Ironically, the major influence of Fortran and Cobol (and Algol) was PL/I, who would itself slowly disappear – well not quite, IBM still makes a PL/I compiler, which likely means there is some serious code out there written in PL/I.

[1] Backus, J.W., Beeber, R.J., Best, S., Goldberg, R., Haibt, L.M., Herrick, H.L., Nelson, R.A., Sayre, D.,  Sheridan, P.B., Stern, H., Ziller, I., Hughes, R.A., Nutt, R., “The FORTRAN automatic Coding System”, Proc. Western Joint Computer Conference, (1957).

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s