Fifty years of Pascal

I don’t know you but it seems yesterday for me I started to code with Basic on my VIC20 and Pascal a couple of years later and now we celebrate fifty years of Pascal. Can’t believe that.

The beginning

In the early 1960s, the languages Fortran (John Backus, IBM) for scientific, and Cobol (Jean Sammet, IBM, and DoD) for commercial applications dominated. Programs were written on paper, then punched on cards, and one waited a day for the results. Programming languages were recognized as essential aids and accelerators of the programming process.

In 1960, an international committee published the language Algol 60. It was the first time a language was defined by concisely formulated constructs and by a precise, formal syntax. Two years later, it was recognized that a few corrections and improvements were needed. Mainly, however, the range of applications should be widened, because Algol 60 was intended for scientific calculations (numerical mathematics) only. Under the auspices of IFIP a Working Group (WG 2.1) was established to tackle this project.

The group consisted of about 40 members with almost the same number of opinions and views about what a successor of Algol should look like. There ensued many discussions, and on occasions the debates ended even bitterly. Early in 1964 I became a member, and soon was requested to prepare a concrete proposal. Two factions had developed in the committee. One of them aimed at a second, after Algol 60, milestone, a language with radically new, untested concepts and pervasive flexibility. It later became known as Algol 68. The other faction remained more modest and focused on realistic improvements of known concepts. After all, time was pressing: PL/1 of IBM was about to appear. However, my proposal, although technically realistic, succumbed to the small majority that favored a milestone.

Poster of Pascal's syntax diagrams strongly identified with Pascal - Fifty years of Pascal
Poster of Pascal’s syntax diagrams strongly identified with Pascal

The group

It is never sufficient to merely postulate a language on paper. A solid compiler also had to be built, which usually was a highly complex program. In this respect, large industrial firms had an advantage over our Working Group, which had to rely on enthusiasts at universities. I left the Group in 1966 and devoted myself together with a few doctoral students at Stanford University to the construction of a compiler for my proposal. The result was the language Algol W,2 which after 1967 came into use at many locations on large IBM computers. It became quite successful. The milestone Algol 68 did appear and then sank quickly into obscurity under its own weight, although a few of its concepts did survive into subsequent languages.

But in my opinion Algol W was not perfectly satisfactory. It still contained too many compromises, having emerged from a committee. After my return to Switzerland, I designed a language after my own preferences: Pascal. Together with a few assistants, we wrote a user manual and constructed a compiler. In the course of it, we had a dire experience. We intended to describe the compiler in Pascal itself, then translate it manually to Fortran, and finally compile the former with the latter. This resulted in a great failure, because of the lack of data structures (records) in Fortran, which made the translation very cumbersome. After this unfortunate, expensive lesson, a second try succeeded, where in place of Fortran the local language Scallop (M. Engeli) was used.


Like its precursor Algol 60, Pascal featured a precise definition and a few lucid, basic elements. Its structure, the syntax, was formally defined in Extended BNF. Statements described assignments of values to variables, and conditional and repeated execution. Additionally, there were procedures, and they were recursive. A significant extension were data types and structures: Its elementary data types were integers and real numbers, Boolean values, characters, and enumerations (of constants). The structures were arrays, records, files (sequences), and pointers. Procedures featured two kinds of parameters, value-and variable-parameters. Procedures could be used recursively. Most essential was the pervasive concept of data type: Every constant, variable, or function was of a fixed, static type. Thereby programs included much redundancy that a compiler could use for checking type consistency. This contributed to the detection of errors, and this before the program’s execution.


Just as important as addition of features were deletions (with respect to Algol). As C.A.R. Hoare once remarked: A language is characterized not only by what it permits programmers to specify, but even more so by what it does not allow. In this vein, Algol’s name parameter was omitted. It was rarely used, and caused considerable complications for a compiler. Also, Algol’s own concept was deleted, which allowed local variables to be global, to “survive” the activation of the procedure to which it was declared local. Algol’s for statement was drastically simplified, eliminating complex and hard to understand constructs. But the while and repeat statements were added for simple and transparent situations of repetition. Nevertheless, the controversial goto statement remained. I considered it too early for the programming community to swallow its absence. It would have been too detrimental for a general acceptance of Pascal.

Pascal was easy to teach, and it covered a wide spectrum of applications, which was a significant advantage over Algol, Fortran, and Cobol. The Pascal System was efficient, compact, and easy to use. The language was strongly influenced by the new discipline of structured programming, advocated primarily by E.W. Dijkstra to avert the threatening software crisis (1968).

Pascal was published in 1970 and for the first time used in large courses at ETH Zurich on a grand scale. We had even defined a subset Pascal-S and built a smaller compiler, in order to save computing time and memory space on our large CDC computer, and to reduce the turnaround time for students. Back then, computing time and memory space were still scarce.

Pascal’s Spread and Distribution

Soon Pascal became noticed at several universities, and interest rose for its use in classes. We received requests for possible help in implementing compilers for other large computers. It was my idea to postulate a hypothetical computer, which would be simple to realize on various other mainframes, and for which we would build a Pascal compiler at ETH. The hypothetical computer would be quickly implementable with relatively little effort using readily available tools (assemblers). Thus emerged the architecture Pascal-P (P for portable), and this technique proved to be extremely successful. The first clients came from Belfast (C.A.R. Hoare). Two assistants brought two heavy cartons of punched cards to Zurich, the compiler they had designed for their ICL computer. At the border, they were scrutinized, for there was the suspicion that the holes might contain secrets subject to custom fees. All this occurred without international project organizations, without bureaucracy and research budgets. It would be impossible today.

An interesting consequence of these developments was the emergence of user groups, mostly of young enthusiasts who wanted to promote and distribute Pascal. Their core resided under Andy Mickel in Minneapolis, where they regularly published a Pascal Newsletter. This movement contributed significantly to the rapid spread of Pascal.

First microcomputer

Several years later the first microcomputers appeared on the market. These were small computers with a processor integrated on a single chip and with 8-bit data paths, affordable by private persons. It was recognized that Pascal was suitable for these processors, due to its compact compiler that would fit into the small memory (64K). A group under Ken Bowles at the University of San Diego, and Philippe Kahn at Borland Inc. in Santa Cruz surrounded our compiler with a simple operating system, a text editor, and routines for error discovery and diagnostics. They sold this package for $50 on floppy disks (Turbo Pascal). Thereby Pascal spread immediately, particularly in schools, and it became the entry point for many to programming and computer science. Our Pascal manual became a best-seller.

This spreading did not remain restricted to America and Europe. Russia and China welcomed Pascal with enthusiasm. This I became aware of only later, during my first travels to China (1982) and Russia (1990), when I was presented with a copy of our manual written in (for me) illegible characters and symbols.

Pascal’s Successors

But time did not stand still. Rapidly computers became faster, and therefore demands on applications grew, as well as those on programmers. No longer were programs developed by single persons. Now they were being built by teams. Constructs had to be offered by languages that supported teamwork. A single person could design a part of a system, called a module, and do this relatively independently of other modules. Modules would later be linked and loaded automatically. Already Fortran had offered this facility, but now a linker would have to verify the consistency of data types also across module boundaries. This was not a simple matter!

Modules with type consistency checking across boundaries were indeed the primary extension of Pascal’s first successor Modula-2 (for modular language, 1979). It evolved from Pascal, but also from Mesa, a language developed at Xerox PARC for system programming, which itself originated from Pascal. Mesa, however, had grown too wildly and needed “taming.” Modula-2 also included elements for system programming, which admitted constructs that depended on specific properties of a computer, as they were necessary for interfaces to peripheral devices or networks. This entailed sacrificing the essence of higher languages, namely machine-independent programming. Fortunately, however, such parts could now be localized in specific “low-level” modules, and thereby be properly isolated.

Apart from this, Modula contained constructs for programming concurrent processes (or quasiparallel threads). “Parallel programming” was the dominant theme of the 1970s. Overall, Modula-2 grew rather complex and became too complicated for my taste, and for teaching programming. An improvement and simplification appeared desirable.


From such deliberations emerged the language Oberon, again after a sabbatical at Xerox PARC. No longer were mainframe computers in use, but powerful workstations with high-resolution displays and interactive usage. For this purpose, the language and interactive operating system Cedar had been developed at PARC. Once again, a drastic simplification and consolidation seemed desirable. So, an operating system, a compiler, and a text editor were programmed at ETH for Oberon. This was achieved by only two programmers—Wirth and Gutknecht—in their spare time over six months. Oberon was published in 1988. The language was influenced by the new discipline of object-oriented programming. However, no new features were introduced except type extension. Thereby for the first time a language was created that was not more complex, but rather simpler, yet even more powerful than its ancestor. A highly desirable goal had finally been reached.

Even today Oberon is successfully in use in many places. A breakthrough like Pascal’s, however, did not occur. Complex, commercial systems are too widely used and entrenched. But it can be claimed that many of those languages, like Java (Sun Microsystems) and C# (Microsoft) have been strongly influenced by Oberon or Pascal.

Around 1995 electronic components that are dynamically reprogrammable at the gate level appeared on the market. These field programmable gate arrays (FPGA) can be configured into almost any digital circuit. The difference between hardware and software became increasingly diffuse. I developed the language Lola (logic language) with similar elements and the same structure as Oberon for describing digital circuits. Increasingly, circuits became specified by formal texts, replacing graphical circuit diagrams. This facilitates the common design of hardware and software, which has become increasingly important in practice.

Borland Turbo Pascal

Turbo Pascal 7.1 box
Turbo Pascal 7.1 box

Borland Turbo Pascal is definitely the most successful and popular Pascal compiler ever. Comfortable Integrated Development Environment (IDE), elegant syntax, fast compilation and effective generated code are some of the strongest points of Turbo Pascal – a powerful programming tool which has contributed to the popularity of Pascal programming language.

Turbo Pascal was the programming tool of choice for many years. The original Pascal syntax was upgraded with objects and some other constructs which enabled programmers to use Turbo Pascal for games, scientific programming, commercial software, and any other task possible with computers.

Blaise Pascal
Blaise Pascal

Pascal was originally developed by a Swiss computer scientist Niklaus Wirth in late 1960s. He named the language after French philosopher and mathematician Blaise Pascal. In addition to the programming language, the name Pascal has been given also to the SI unit for pressure and Pascal’s law (the principle of transmission of fluid-pressure). Blaise Pascal lived in 17th century and contributed to mathematics (Pascal’s triangle showing binomial coefficients, mathematical theory of probabilities), hydrodynamics and hydrostatics (the principles of hydraulic fluids, he invented hydraulic press and the syringe), he also invented the mechanical calculator and was supporter of the scientific method. Therefore, the Pascal language is always written with its first letter in uppercase. Initially the purpose of Pascal programming language was to teach structured programming.

Niklaus Wirth
Niklaus Wirth

It was and still is used in many schools as the first high-level programming language. Wirth based Pascal on Algol programming language which was developed in 1950s and was also used to describe algorithms in the literature. Wirth tried to create a language that would be easy to compile and would generate efficient code. He used the principle of structured programming and added support for records, enumerations, subranges, dynamically allocated variables with associated pointers, and sets. Wirth later also developed programming languages Modula 2 and Oberon. Pascal uses reserverd words like ifthenelsewhileforuntil and many others for control statements which makes it easy to read and understand. Therefore, Pascal programming language is suitable also to describe algorithms with very little additional comments.

Anders Hejlsberg
Anders Hejlsberg

Many Pascal compilers for many different platforms were developed in the 1970s like UCSD Pascal, IP Pascal and Lisa Pascal to name only a few of them. In 1980 Anders Hejlsberg developed Blue Label Pascal which was offered for the PC platform under different names. This compiler was later licensed by a software company Borland which added user interface and editor, changed the name to Turbo Pascal and offered it for a competitive price. Fast compiler (it was written in assembly language), integrated development environment which enabled fast edit-compile-run cycles and low price contributed to the popularity of Turbo Pascal. Borland later offered this compiler also as part of the high-end Borland Pascal package which included also additional libraries and other tools. The last released version was Borland Pascal 7.

I am a big fan of Pascal. Pascal programming language is easy to write and easy to read. I was impressed by the compilation speed of Borland Pascal and was wondering how it works. On the other hand I was interested in compiler theory so I started studying compiler construction books. At some point I decided to create a compatible compiler – Turbo Pascal compiler written in Turbo Pascal. The goal was to create a compiler that would use the same algorithms and data structures as the original compiler. The compiler would then compile programs with Borland syntax and would generate the same code. I was not interested in the IDE so I focused on command-line compiler. After some time I managed to create a complete compiler that reveals Turbo Pascal internals and shows all the beauty of the legendary Borland compiler. I really enjoyed working on this compiler. I must admit that Anders Hejlsberg and Borland have significantly contributed to my passion for Pascal.

Download and run Turbo Pascal in DosBox

Now, if you want to run Turbo Pascal on your Windows 10 machine, you need an virtual environment where MS-DOS (Microsoft Disk Operating System) can run under Windows.

So, I found DosBox Frontend Reloaded. D-Fend Reloaded is a graphical environment for DOSBox. DOSBox emulates a complete computer including the DOS command line and allows to run nearly all old DOS based games on modern hardware with any of the newer Windows versions.

With DOSBox there is no need to worry about memory managers or free conventional RAM, but the setup of DOSBox is still a bit complicated. The configuration of DOSBox via textbased setup files might be difficult for beginners. D-Fend Reloaded may help and create these files for you. Additionally the D-Fend Reloaded installation package contains DOSBox (including all lanuage files currently available), so there is only one installation to be run and no need to link D-Fend Reloaded with DOSBox manually. Now, install D-Fend following the wizard.

Then, you can download a copy of Turbo Pascal 7.1 from that collects free abandonware.

After the installation of D-Fend, under your user in Windows 10, you find D-Fend Reloaded folder and in it VirtualHD folder.

Where is the VirtualHD for D-Fend Reloaded? - Fifty years of Pascal
Where is the VirtualHD for D-Fend Reloaded?

In VirtualHD folder, create a new folder like TP7 and in this one extract the file from

Extract file for Turbo Pascal 7
Extract file for Turbo Pascal 7

Now, run D-Fend Reloaded and click on the button Add and select Add with wizard. Skip the first page of the wizard and them you have to select the Program to be started. Click on the button at the end of the textbox and then select TURBO.EXE under BIN under TP7.

Create new profile
Create new profile

Click Next until the end of the wizard. Then, from the list, right-click on the profile you have just created and select Edit. Then, click on DOS environment and check the PATH

Profile editor for Turbo Pascal
Profile editor for Turbo Pascal

Then, you are ready. Double click on the profile and your Turbo Pascal 7.1 is up and running.

Turbo Pascal 7.1 - Fifty years of Pascal
Turbo Pascal 7.1

Do you remember the Help? Ok, I know, this is a sign of my age.

Turbo Pascal 7.1 Help - Fifty years of Pascal
Turbo Pascal 7.1 Help

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.