• Origins
• Wirth Invents Pascal
• UCSD Pascal
• Pascal Becomes Standard
• Extensions
• The World Changes
• So Why Learn Pascal

Pascal grew out of ALGOL, a programming language intended for scientific computing. Meeting in Zurich, an international committee designed ALGOL as a platform-independent language. This gave them more more free rein in the features they could put into it, but also made it more difficult to write compilers for it. Many computer vendors didn't. The lack of compilers on many platforms, combined with its lack of pointers and many basic data types such as characters, led to ALGOL not being widely accepted. Scientists and engineers flocked to FORTRAN, a programming language which was available on many platforms. ALGOL mostly faded away, except that it became the standard language for describing algorithms.

In the 1960s, several computer scientists worked on extending ALGOL. One of these was Dr. Niklaus Wirth of the Swiss Federal Institute of Technology (ETH-Zurich), a member of the original group that created ALGOL. In 1971, he published his specification for a highly-structured language which resembled ALGOL in many ways. He named it Pascal after the 17th-century French philosopher and mathematician who built a working mechanical digital computer.

Pascal is very data-oriented, giving the programmer the ability to define custom data types. With this freedom comes strict type-checking, which ensured that data types didn't get mixed up. Pascal was intended as a teaching language, and was widely adopted as such. Pascal is free-flowing, unlike FORTRAN, so student programmers didn't have to worry about formatting. In addition, Pascal reads very much like a natural language, making it very easy to understand code written in it.

One of the things that killed ALGOL was the difficulty of creating a compiler for it. Dr. Wirth avoided this by having his Pascal compiler compile to an intermediate, platform-independent object code stage. Another program turned this intermediate code into executable code. Prof. Ken Bowles at the University of California at San Diego (UCSD) seized on the opportunity this offered to adapt the Pascal compiler to the Apple II, the most popular microcomputer of the day. UCSD P-System became a standard, and was widely used at universities. This was aided by the low cost of Apple II's compared to mainframes, which were necessary at the time to run other languages such as FORTRAN.

By the early 1980's, Pascal has already become widely accepted at universities. Two things happened to make it even more popular.

First, the Educational Testing Service, the company which creates the primary college entrance exam in the United States, decided to add a Computer Science exam to its Advanced Placement exams for high school students. For this exam, it chose the Pascal language. Because of this, secondary-school students as well as college students began to learn Pascal. Pascal remained the official language of the AP exams until 1999, when it was replaced by C++.

Second, a small company named Borland International came out with the Turbo Pascal compiler for the IBM Personal Computer. This compiler was truly revolutionary. It did take some shortcuts and made some modifications to standard Pascal, but these were minor and led to its greatest advantage: speed. Turbo Pascal compiled at a dizzying rate: several thousand lines a minute. At the time, the available compilers for the PC platform were slow and bloated. When Turbo Pascal came out, it was a breath of fresh air. Soon, Turbo Pascal became the de facto standard for programming on the PC. When computing magazines published source code for utility programs, it was usually in either assembly or Turbo Pascal.

At the same time, Apple came out with its Macintosh series of computers. Since UCSD Pascal has first been implemented on the Apple II, Apple made Pascal the standard programming language for the Mac. When programmers received the API and example code, it was all in Pascal.

From version 1.0 to 7.0 of Turbo Pascal, Borland expanded the language. One of the criticisms of the original version of Pascal was its lack of separate compilation for modules. Dr. Wirth even created a new programming language, Modula-2, to address that problem. Borland added this to Pascal with its units feature.

By version 7.0, many advanced features had been added. One of these was DPMI (DOS Protected Mode Interface), a way to run DOS programs in protected mode, breaking free of the 640K barrier instituted by Microsoft its early versions of DOS. Turbo Vision, a text-based windowing system, allowed programmers to create great-looking interfaces in practically no time at all. Pascal even became object-oriented, as version 5.5 adopted the Apple Object Pascal extensions. When Windows 3.0 came out, Borland created Turbo Pascal for Windows, bringing the speed and ease of Pascal to the graphical user interface. It seemed that Pascal's future was secure.

However, this was not so. In the 1970s, Dennis Ritchie and Brian Kernighan of AT&T Bell Laboratories created the C Programming Language. Ritchie then collaborated with Ken Thompson to design the UNIX operating system. AT&T had, at that time, a monopoly on telephone service in the United States, and was permitted to keep that monopoly in exchange for being banned from the computer business. AT&T thus gave away the operating system, with source code, to universities for free.

Thus, a whole generation of computer science students learned Pascal in the introductory programming courses, then learned C when they delved into operating systems. Slowly but surely, C began to filter into the computer programming world.

The killer, ironically enough, was object orientation and the move to Windows on the PC platform. Bjarne Stroustrop introduced object-orientation to most of the world when he created C++. Object Pascal was quickly created in response, but for most programmers, the first thing that pops to mind when OOP is mentioned is C++. As for the move to Windows, while Turbo Pascal supported Windows, it was a chore. Windows was programmed in C, and Microsoft released the API entirely in C. For each revision, Borland had to translate it all into Pascal.

Many colleges and universities moved away from Pascal, choosing C++, or the new Java, for their programming courses. Finally, the AP exam moved to C++, ending Pascal's dominance in high schools.

Despite its fading away as the de facto standard, Pascal is still extremely useful. C and C++ are very symbolic languages. Where Pascal chooses words (e.g. begin-end), C/C++ chooses symbols ({-}). Also, C and C++ are not strongly-typed languages. In Pascal, mixing types often led to an error. In C/C++, nothing would happen. You could even treat pointers as integers and do pointer arithmetic with them. In this way, you could very easily crash your computer. When the AP exam switched to C++, only a subset of C++ was adopted. Many features, like arrays, were considered too dangerous, and ETS provided its own "safe" version of these features. Java corrects many of these problems of C++ (there are no actual pointers in Java).

Another reason: speed and size. The Borland Pascal compiler is still lightning- fast. Borland has revitalized Pascal for Windows with Delphi, a Rapid-Application-Development environment. Instead of spending several hours writing a user interface for a Windows program in C/C++, you could do it in ten minutes with Delphi's graphical design tools. You could do the same in Visual BASIC, but Delphi is so much faster than Visual BASIC.

Also, Pascal remains preferred at many universities which saw C++ as too dangerous. Java is beginning to be implemented, but teaching Java requires the teaching of pointers, a very difficult topic. To teach simple procedural programming, Pascal remains the top choice.

Thus, even after C, C++, and Java took over the programming world, Pascal retains a niche in the market. Many small-scale freeware, shareware, and open-source programs are written in Pascal/Delphi. So enjoy learning it while it lasts. It's a great introduction to computer programming. It's not scary like C, dangerous like C++, or abstract like Java. In another twenty years, you'll be one of the few computer programmers to know and appreciate Pascal.

Back to compilers

Begin tutorial

Contents

Index

E-mail me