Stories
Slash Boxes
Comments

SoylentNews is people

posted by Fnord666 on Saturday May 16 2020, @02:39AM   Printer-friendly
from the near-the-root-of-the-programming-language-tree dept.

ALGOL 60 at 60: The Greatest Computer Language You've (Probably) Never Used:

2020 marks 60 years since ALGOL 60 laid the groundwork for a multitude of computer languages.

The Register spoke to The National Museum of Computing's Peter Onion and Andrew Herbert to learn a bit more about the good old days of punch tapes.

ALGOL 60 was the successor to ALGOL 58, which debuted in 1958. ALGOL 58 had introduced the concept of code blocks (replete with begin and end delimiting pairs), but ALGOL 60 took these starting points of structured programming and ran with them, giving rise to familiar faces such as Pascal and C, as well as the likes of B and Simula.

"In the 1950s most code was originally written in machine code or assembly code," said Herbert, former director of Microsoft Research in Cambridge, with every computer having its own particular twist on things.

[..] "Fortran," said Herbert, "emerged as the first real programming language for scientific and numeric work. That convinced people that having higher-level languages (as they called them then – they were pretty primitive by modern standards) made programmers more productive."

[...] "And a bunch of people thought you could do better."

[...] One group started on the design of what was then called an "Algorithmic Language": a language for writing algorithms. The output, in 1958, described the language "ALGOL 58". However, as engineers began to create compilers for the new system, they found "all kinds of things hadn't really been thought about or worked through properly," recalled Herbert.

[...] Eventually, Herbert told us, "they published the ALGOL 60 report, which is the baseline that everyone then worked to."

[...] "People were sorting out some of the things that we now take for granted like ideas in structured programming, data structures, data types," he added.

[...] Alas, those seeking a handy-dandy "HELLO WORLD" example will be disappointed. The Achilles' heel of the language that would go on to inspire so many others was that it lacked standard input/output capabilities.

[...] Oh dear. The omission pretty much did for vendor independence as manufacturers naturally went their own way, leaving large chunks of code incompatible between systems. There were also elements of ALGOL 60 that were open to interpretation, leaving it a little compromised from the start.

While ALGOL ploughed its furrow, Fortran continued to be developed in parallel. "People in the Fortran world," explained Herbert, "saw ideas in ALGOL they quite liked and brought them across." As the decades passed, Fortran remained the centre of gravity for scientific computing while ALGOL became more of an academic language, used for teaching computer science ideas.

[...] The story of ALGOL 60 is not so much of the language's eventual fate, but also of those that it inspired. ALGOL W, based on a proposal for ALGOL X, by Niklaus Wirth and QuickSort creator Tony Hoare would go on to inspire Wirth's Pascal and Modula-2. Pascal's influence continues to be felt today.

ALGOL 60 also heavily influenced the Combined Programming Language (CPL), developed in the 1960s but not implemented until the following decade. CPL in turn led to Basic CPL (BCPL), from which B descended. The B language was further developed to become C.

[...] As for taking the ALGOL 60 itself out for a spin today, there are a few options for those not fortunate enough to have an Elliott 803 or 903 to hand. MARST will translate ALGOL 60 to C or one can get a feel for the whole 803 experience via a simulator.

This humble scribe did not have occasion to use ALGOL, but did spent the better part of two years programming PASCAL professionally. At a time when it seemed all other languages had a limited — and finite — set of data types, PASCAL was different. It encouraged the creation of whatever data types and data structures that best matched the task at a hand.


Original Submission

 
This discussion has been archived. No new comments can be posted.
Display Options Threshold/Breakthrough Mark All as Read Mark All as Unread
The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
  • (Score: 2) by hendrikboom on Saturday May 16 2020, @06:00PM (2 children)

    by hendrikboom (1125) Subscriber Badge on Saturday May 16 2020, @06:00PM (#995081) Homepage Journal

    I read the first 10 Algol Bulletins, which contain some of the deliberations while they were puttinig Algol 60 together.

    How they invented block structure with local and global variables?

    It started out as a generalization of Fortran's COMMON storage!

    Step One was eliminating problems with declaring COMMON variables differently in different functions by letting them be declared only once, and outside the functions.

    You can guess the rest.

    Starting Score:    1  point
    Karma-Bonus Modifier   +1  

    Total Score:   2  
  • (Score: 2) by maxwell demon on Sunday May 17 2020, @08:42AM (1 child)

    by maxwell demon (1608) on Sunday May 17 2020, @08:42AM (#995282) Journal

    Yeah, FORTRANS's COMMON blocks got a worse reputation than they deserved. Their main problem was the missing type safety, but that problem was shared by everything passed between functions in FORTRAN.

    But COMMON blocks were superior to global variables in one important respect: You only had to look at the single function's declarations to know exactly what the function could modify (note that since FORTRAN also didn't have pointers, you couldn't change anything else through indirection).

    --
    The Tao of math: The numbers you can count are not the real numbers.
    • (Score: 2) by hendrikboom on Sunday May 17 2020, @08:54PM

      by hendrikboom (1125) Subscriber Badge on Sunday May 17 2020, @08:54PM (#995457) Homepage Journal

      The problem with COMMON blocks is that you had to repeat the declarations identically in each function.
      If you got them wrong in one function, the code looked fine, but that function would be reading and writing variables in the common block that were not the ones evidently named in the function.

      Locality without glitches of this sort weren't really solved until we got languages with module syntax, explicit imports and exports, and some kind of link-time or run-time check that the imports and exports matched up properly.

      -- hendrik