50 years of Pascal


In the early 1960s, the world was dominated by Fortran (IBM's John Backus) for scientific and Cobol (IBM's Jean Summet and Department of Defense) for commercial use. Programs were written on paper, then perforated on cards, after which the results of their execution were waited for the whole day. Programming languages were considered important assistants and accelerators of the programming process.

In 1960, an international committee published the Algol 601 language specification. For the first time, a language was defined by well-defined constructs and a precise, formal syntax. Two years later, it became clear that some fixes and improvements were required. However, the main task was to expand the range of applications, since ALGOL 60 was intended only for scientific computing (computational mathematics). To work on this project, a Working Group (WG 2.1) was assembled under the auspices of the International Federation for Information Processing (IFIP).

The group consisted of about forty members; almost the same number of opinions and views on what should be the descendant of Algol. This caused extensive discussions, and some of the debates ended rather sadly. In early 1964 I became a member of the group and soon I was asked to prepare a specific proposal. The committee was divided into two factions. One of them was striving for a second, after Algol 60, important milestone - the creation of a language with radically new, untested concepts and tremendous flexibility. It later became known as Algol 68. The other faction set itself a more modest task and focused on realistic improvements to well-known concepts. After all, time was running out: IBM's PL / 1 was about to appear. However, my proposal, despite the technical feasibility, yielded by a slight margin to the majority, who preferred to develop Algol 68.


Pascal Syntax Diagram Poster

It is not enough to simply postulate language on paper. You need to create a reliable compiler, which is usually highly complex program. In this respect, large industrial firms had an edge over our workgroup, which had to rely on enthusiasts from academia. I left the group in 1966 and, with several graduate students from Stanford University, devoted my time to building a compiler for my project. As a result, we got the language Algol W2, which after 1967 began to be used in many places where large IBM computers were used. It turned out to be quite successful. ALGOL 68 was released, but it quickly sank due to its own weight, although some of its concepts were given a second life in new languages.

But in my opinion, Algol W was not good enough. Due to the fact that it was originally developed by a committee, the language contained too many compromises. After my return to Switzerland, I designed the language according to my preferences: it was Pascal. With a few helpers, we wrote the user manual and designed the compiler. In the process of creating it, we decided to take a risky step: we wanted to describe the compiler in Pascal itself, then translate it manually into Fortran, and, finally, compile the first from the second. The result was a devastating failure, because the lack of data structures (records) in Fortran made the translation very cumbersome. After this unsuccessful expensive lesson, the second attempt ended in success - this time we used the local language Scallop (created by M. Engeli) instead of Fortran.
Like its predecessor, the Algol 60, Pascal2 had a clear definition and a limited number of understandable basic elements. Its structure and syntax were formally defined in an extended Backus-Naur form3. Operators described assignment of values to variables, conditional and repeated execution. In addition, the language had procedures and they were recursive. Data types and structures became a significant improvement: the elementary data types were integers and real numbers, boolean values, symbols and enumerations (constants). Arrays, records, files (sequences) and pointers became structures. Procedures have two kinds of parameters - values and variables. Procedures can be used recursively. Most essential was the overarching concept of data type: every constant, variable, or function had a fixed, static type. Therefore, the programs had a lot of redundancy that the compiler could use to check the integrity of types. This facilitated error detection prior to program execution.

As important as the addition of functions, their removal (relative to Algol) has become. Charles Anthony Richard Hoare once said: a language is characterized not only by what it allows the programmer to do, but also by what it can do. does not allow ... In this regard, the language has abandoned the parameter-name of Algol. It was rarely used and caused significant difficulties for the compiler. In addition, the concept of Algol ownership was removed, allowing local variables to be global in order to "survive" the activation of a procedure for which the variable was declared local. The construction for Algol has been greatly simplified, which made it possible to get rid of complex and difficult to understand constructions. However, while and repetition statements have been added for simple and transparent repetition situations. However, the controversial goto operator survived. I decided that the programming community was not yet ready to abandon it. It would be too bad for Pascal to grow in popularity.

Pascal was easy to teach and could be used in a wide variety of applications, which was a significant advantage over Algol, Fortran and Cobol. Pascal's System module was efficient, compact and easy to use. The language was strongly influenced by the new discipline of structured programming, the main preacher of which was E. Dijkstra, who thus sought to avoid the threat of the software crisis (1968).

Pascal was published in 1970 and was first used in courses at the Swiss Higher Technical School of Zurich (ETH). We even defined a subset of Pascal-S and created a more compact compiler to save time and space on our CDC computer and reduce processing cycle times for students. In those days, machine time and memory were in short supply.
Pascal's distribution and popularity
Soon Pascal was noticed by several universities and interest in its use in teaching increased. We have received requests for help in implementing compilers for other computers. I came up with the idea of postulating a hypothetical computer that could be easily implemented on different mainframes, for which we would create a compiler at the Zurich School of Technology. This hypothetical computer could be easily implemented with relatively little labor costs using ready-made tools (assemblers). This is how the Pascal-P (P for portable) architecture came into being, and this technique has been extremely successful. Our first clients were from Belfast (C.E.R. Hoare). Two assistants brought two heavy cardboard boxes of punched cards to Zurich, and they recorded a compiler designed for the ICL computer. At the border, they were interrogated because it was suspected that the punched cards might contain secrets subject to customs duties. All this happened without international design organizations, without bureaucracy and research budgets. This would not be possible today.

An interesting consequence of this development was the emergence of user groups, mainly composed of young enthusiasts who wanted to promote and distribute Pascal. The core of these groups was run by Andy Mikel of Minneapolis, where they regularly published the Pascal Newsletter. This movement contributed significantly to the rapid spread of Pascal.

A few years later, the first microcomputers appeared on the market. These were small computers, the processor of which was integrated into a single chip, and had 8-bit data buses, affordable even to individuals. It turned out that thanks to its small compiler, which can fit in a small amount of memory (64 KB), Pascal is suitable for their processors. The team led by Ken Bowles of the University of San Diego and Philip Kahn of Borland Inc. Santa Cruz created a simple operating system for our compiler, a text editor, and routines for detecting and diagnosing errors. They were selling this package on floppy disks for $ 50 (Turbo Pascal). Thanks to this, Pascal spread instantly, especially in schools and universities, becoming for many an entry point into programming and computer science. Our Pascal guide has become a bestseller.

This spread was not limited to America and Europe. Russia and China were also enthusiastic about Pascal. I found out about this only later, during my first trips to China (1982) and the USSR (1990), when I was shown a version of our manual written in incomprehensible (for me) symbols and letters.
Pascal's heirs
But time did not stand still. Computers were rapidly getting faster, so the requirements for applications, as well as for programmers, grew. Programs were no longer developed by one person; now they were created by teams. In languages, constructs were to appear to support teamwork. One person can design a part of the system called a "module" quite independently of the rest of the modules. Later modules can be linked and loaded automatically. Even Fortran already had such a feature, but now the linker had to check the integrity of data types between module boundaries. It was not an easy task!

Modules with cross-border type integrity checking became the main extension of Pascal's first successor called Modula-24 (short for modular language, 1979). The language was an evolutionary development of Pascal, as well as Mesa, a language developed at Xerox PARC for systems programming. Mesa itself also descended from Pascal. However, Mesa was developing too chaotically and had to be tamed. Modula-2 also contained elements for system programming, allowing constructs depending on the specific properties of the computer, since they were necessary for interfaces with peripheral devices or networks. Because of this, the very essence of high-level languages had to be sacrificed, namely machine-independent programming. Fortunately, such parts could now be localized in specific "low-level" modules, and therefore isolated accordingly.

In addition, Modula contained constructs for programming parallel processes (or quasi-parallel threads). "Parallel programming" was a major theme in the 1970s. In general, Modula-2 has gradually become quite complex and, in my opinion, overcomplicated for teaching programming. I felt that the language needed improvement and simplification.

Thanks to this reasoning, the Oberon5 language arose, also originally created at Xerox PARC. Mainframes were no longer used, replaced by powerful workstations with high-resolution displays and interactivity. For them, PARC developed the Cedar language and interactive operating system. Once again, the designers found significant simplification and consolidation desirable, so an operating system, compiler, and text editor were written for Oberon at ETH. The task was completed by only two programmers - Wirth and Gutknecht in their spare time for six months. Oberon's publication took place in 1988. The development of the language was influenced by a new discipline - object-oriented programming. However, it does not have any new features other than the type extension. Consequently, for the first time a language was created that not only did not become complicated, but even simplified, and at the same time became more powerful than its predecessor.

Even today, Oberon is used successfully in many different places. However, the revolution, as in the case of Pascal, did not happen. Complex commercial systems are too widely used and therefore ingrained. Yet it can be said that many such languages like Java (Sun Microsystems) and C # (Microsoft) were heavily influenced by Oberon or Pascal.

Around 1995, electronic components that were dynamically reprogrammable at the logic gate level appeared on the market. These field programmable gate arrays (FPGAs) can be configured to virtually any digital circuit. The distinction between software and hardware became increasingly blurred. I developed Lola (logic language) with Oberon-like elements and similar structure for describing digital circuits. Schemes are increasingly being defined by formal texts replacing graphical schematic diagrams. This simplifies the design of hardware and software, which is becoming increasingly important in practice.
Comments and conclusions
The fundamental task of high-level languages is to increase the level of abstraction from the layer of machine instructions. For example, data structures instead of arrays of words in memory, or conditional and loop statements instead of jump instructions. An ideal language should be defined in terms of mathematical logic, axioms, and rules of inference. It should not require any reference to any computer or mechanism to understand it. This is the foundation of portability. Algol's designers saw this goal, but it is most difficult to achieve without sacrificing the power of expressiveness. However, each new language should be measured by the degree to which it approaches this goal. The sequence "Pascal-Modula-Oberon" was a testament to my desire to achieve it. Oberon is close to her, but nothing is perfect.
1. Naur, P. Revised report on the algorithmic language Algol 60. Commun. ACM 6, (Jan. 1963), 1–17.

2. Wirth, N. and Hoare, C.A.R. A contribution to the development of ALGOL. Commun. ACM 9 (June 1966), 413–432.

3. Wirth, N. The programming langage Pascal. Acta Informatica 1, (1971), 35–63; https://doi.org/10.1007/BF00264291

4. Wirth, N. What can we do about the unnecessary diversity of notation for syntactic definitions? Commun. ACM 20, 11 (Nov. 1977).

5. Wirth, N. Programming in Modula-2. Springer-Verlag 1982.

6. Wirth, N. The Programming Language Oberon. Software–Practice and Experience 18, (Jul. 1988), 671–690; https://doi.org/10.1002/spe.4380180707
KlauS 9 march 2021, 14:17
Vote for this post
Bring it to the Main Page


Leave a Reply

Avaible tags
  • <b>...</b>highlighting important text on the page in bold
  • <i>..</i>highlighting important text on the page in italic
  • <u>...</u>allocated with tag <u> text shownas underlined
  • <s>...</s>allocated with tag <s> text shown as strikethrough
  • <sup>...</sup>, <sub>...</sub>text in the tag <sup> appears as a superscript, <sub> - subscript
  • <blockquote>...</blockquote>For  highlight citation, use the tag <blockquote>
  • <code lang="lang">...</code>highlighting the program code (supported by bash, cpp, cs, css, xml, html, java, javascript, lisp, lua, php, perl, python, ruby, sql, scala, text)
  • <a href="http://...">...</a>link, specify the desired Internet address in the href attribute
  • <img src="http://..." alt="text" />specify the full path of image in the src attribute