I am compiling a detailed history of the Pascal language, and there are a few details I am missing.

There are so many features today that we take for granted. What features significantly contributed to the evolution of Pascal, and why were they significant?

I'm looking for language features, not platform or framework features. So like operator overloading or default parameters, but not Linux support or new Rich Text widget.

I know there are a few different flavors of Pascal (Delphi, Free Pascal, Oxygene, Quick Pascal, Apple Pascal, etc.) and they introduced the same features at different times and in parallel. That is OK. I'm looking at the Pascal language as whole, and when the significant milestones occurred (dates, versions, etc.)

  • @Jim Your question asked for a list of dates, but did not ask for input on why someone would consider them to be significant. I've reworded your question to capture that aspect, and have reopened it.
    – user8
    Jul 28, 2011 at 18:40
  • 2
    You are aware that the Turbo Pascal product revolutionized the Pascal world? And the IBM PC world too, actually? Especially since it fixed strings.
    – user1249
    Jul 29, 2011 at 8:10
  • 4
    Don't forget UCSD Pascal! It introduced bytecodes (p-codes), long before Java was a twinkle in Sun's eye.
    – Macneil
    Aug 2, 2011 at 2:20
  • 1
    +1 @Macneil UCSD p-Code and the Smalltalk VM are the things that I always explain when talking about modern managed code (Java, .NET). It is fun to have a déjà vu when seeing loads of 'modern' stuff (like Apps, which is just a new flavour of client-server). Aug 13, 2011 at 21:32
  • 1
    @Jeroen Pluimers: I'm also amused by this talk of DVCS being "new". I used SCCS/Teamware at Sun, Torvalds used BitKeeper. When I saw CVS, I knew it was broken (as did Torvalds). When I first heard about SVN, I thought "oh, they finally fixed it." But no. The OSS world (and Joel!) were so damaged by CVS doing everything wrong, they need to believe it's a new thing!
    – Macneil
    Aug 13, 2011 at 22:34

13 Answers 13


From a language historical perspective, probably the biggest contribution of Pascal was strong type safety. That battle is mostly over now - Pascal's side won - and the industrial tipping point was Java. But for a very long time, C was favoured ahead of Pascal by people who considered themselves grown up coders in large part because of this: people wanted the freedom to manipulate their pointers as if they were integers. Practical implementations of Pascal had loopholes, however, like unions that didn't dynamically check the discriminant field, or even had full-blown typecasting of pointers to the point of being all but C equivalent (Turbo Pascal was one of these).

This, and a simplification of the complicated ALGOL 68 spec[1], might be a starting point.

[1] Try reading the ALGOL 68 report sometime - it's definitely a product of the 60s! One site on the web mentions some of its odd jargon: 'bus token', 'invisible production trees', 'primal environs', 'incestuous unions', 'notions', 'protonotions', 'metanotions', 'hypernotions', 'paranotions', etc.


I would say that the two most important driving forces throughout the history of Pascal have been:

  1. Type safety: Pascal was seminal in creating the belief that type safety is important and critical in a language.
  2. Compiler efficiency: Pascal has always been designed as a single pass language, and showed the world how fast a compiler can be without giving up power. The things that make for a fast compiler are also the things that make for a well designed, easy to read language as well. Borland's genuis was in providing all that and performance, too.
  • Wasn't PASCAL also the first language where the compiler was written in PASCAL itself? Another remarkable thing at that time was the P-code - code for a virtual pascal machine. All one had to do to implement PASCAL on a different machine was to write an interpreter or assembler for the P-code.
    – Ingo
    Sep 9, 2011 at 10:00
  • I would add that the type safety also included the mechanisms known as runtime checks in most pascal compilers. (Nearly?) every compiler has them, which is fundamentally different from the LINT approach favoured by C compilers. Nov 30, 2013 at 11:50

You really need to go back to the origins - find some history of Niklaus Wirth. Pascal started its life as a teaching language. "Algorithms + Data Structures = Programs" is a good starting point.

At the time, Pascal was far simpler than Algol 68 and PL/1. It forced structure and declaration, and strong type safety, unlike Fortran4 (Fortran 77 improved things a bit there but you could still play terribly fast-n-loose). And compared to COBOL it was short, simple and easier to write programs. (Hello world in about 6 lines instead of 600).

When it originated, there were things like character arrays in Pascal - that was it for string handling. Things improved over the years.

If you really want to delve into a Pascal history, some points you must take into account:

  • Wirth's original (Standard Pascal)
  • extensions by Digital Equipment Corp (DEC) on the Vax
  • the UCSD p-System (on many machines but notably the Apple-2)
  • Turbo Pascal
  • Apollo Domain Pascal (used to write the Domain/OS operating system, also called Aegis)
  • Turbo Pascal with objects and units (ver 5.5 and later. Edit: just found the TP 5.5 OOP PDF)
  • Delphi

Back in the 1980s there was a huge slug-fest between Pascal and C. There was a vast amount of development and activity happening in both camps.

As a consequence, weird and wonderful things like Bliss-32, Algol, and PL/1 have pretty much disappeared - but ideas from these made their way into Pascal.

EDIT: character arrays could be packed which conferred some special properties, but if you wanted what we now know as string handling you needed to grow it yourself.

  • IIRC there was a small amount of special handling for packed array[1..n] of char;, e.g. in Read(ln) and Write(ln)
    – Gerry
    Aug 2, 2011 at 2:13
  • Yes, readln, writeln were a bit special in that they could handle input / output of a variable number of characters. There was also a bit of a dust-up in the late 1980's about them being evil and sinful and breaking the language construct because they accepted a variable number of parameters. The purists hated this. The rest of us just used it without worrying too much about it. Aug 2, 2011 at 23:02
  • Maybe module/unit systems from the "other" Wirth language Modula2. (Though maybe indirect via resulting efforts to get it in Pascal standads, it finally made the Extended Pascal standard, though with different syntax ) Mar 13, 2019 at 17:01

Object Oriented extensions! Object Pascal was the biggest (unofficial) standards leap with the release of Delphi (1) in the mid-90s. Its hard to pick out just one, but the entire core of the object model as a whole helped bring the language up to modern status. Unfortunately to this day it has not been made into an official single unified standard of which all compilers would conform to for coding symmetry.

Thankfully the Free Pascal project developers has been quite accommodating of features added to Delphi by both Borland and Embarcadero. RemObjects not so much but at least hey have ties to Embarcadero under Delphi Prism so any deviation from a standard (to make the language more .NET compliant) would be highly documented.

  • 8
    Objects were introduced into Pascal with Turbo Pascal 5.5
    – mcottle
    Jul 29, 2011 at 0:17
  • 1
    procedures and functions were by default static. You had to use the virtual keyword to make them overridable by subclasses.
    – user1249
    Jul 29, 2011 at 10:07
  • 1
    Virtual is not a reserved word in Delphi. The list of Delphi reserved words and Prism keywords can be found at here and here.
    – David I
    Jul 30, 2011 at 19:33
  • 2
    Objects were introduced into Pascal by Apple. en.wikipedia.org/wiki/Object_Pascal#Early_history_at_Apple Jul 31, 2011 at 15:12
  • 2
    @Carl - I'd forgotten that the classic Macs were programmed in Pascal, and I didn't know that it was an OO version of Pascal co-created by Wirth.
    – mcottle
    Aug 2, 2011 at 7:49

Just one or two things I remember from using Pascal long ago with MS-DOS:

Turbo Pascal more or less introduced a kind of IDE in the 80s (and compilation performance got a great boost compared to UCSD Pascal

Somehow around the mid 90s Borland changed the name from Turbo to Borland Pascal. As a first step the introduced Units, which allowed to split large projects into separate compilation units.

Later they added object-oriented programming as well.

  • Turbo Pascal was the simple product. Borland Pascal had a LOT of extra stuff like assemblers etc.
    – user1249
    Aug 1, 2011 at 21:08
  • 2
    Units where introduced in Turbo Pascal (v4 IIRC). These compiled to .tpu (turbo pascal unit) files, which were the predecessor of the current dcu files. I believe they were based on concepts from Wirth's Modula-2 language.
    – Gerry
    Aug 2, 2011 at 2:04
  • 1
    ISTR the UCSD p-System had units too, but I don't know if they predated Turbo Pascal or not.
    – TMN
    Aug 2, 2011 at 11:55
  • Interestingly, the "BASIC PROGRAMMING" cartridge for the Atari 2600 provided in 1980 a programming screen that was surprisingly similar to a CodeView screen; one could view the program (with the current execution point highlighted) in one area of the screen, the values of variables in a second, and any output from "print" statements in a third. Unfortunately, the amount of RAM available to the programmer was so constrained it wasn't merely limited to "toy" applications--it wasn't even much of a toy. Still an interesting technical achievement for a platform with...
    – supercat
    Nov 3, 2014 at 21:07
  • ...a whopping 128 bytes of RAM (including 24 bytes which were required for screen pointers), and with the entire development system fitting in 4K of ROM (including the character shapes). Given those constraints, allowing users 64 bytes of RAM to hold their program, variables, and output was a pretty neat trick. Too bad Atari released Basic Programming before they developed their "SARA" chip (which doubled RAM from 128 bytes to 256). Being able to use 128 bytes of RAM for the program plus 64 for variables and output would have been much better than having 64 bytes for everything.
    – supercat
    Nov 3, 2014 at 21:10

One of the core evolutionary steps in Pascal was the proper notion of strings. ISO 7185 ("Standard Pascal") didn't have them, which is kind of embarassing. However, all real programmers needed them, and viable Pascal implementations (such as Borland/Turbo Pascal) did provide them.


Looking back at Delphi's Pascal language innovations - I would add the Property, Method, Event (PME) model and the "Published" section for classes. That made native code, easy to use and extend component building possible. Components fulfilled Brad Cox's promise of Software ICs.


The fight between many flavours of Pascal in the 80s and early 90s.

You had Apple Pascal, Microsoft Pascal and QuickPascal, and Turbo Pascal.

All introduced Object Pascal in one way or the other (QuickPascal 1.0 and Turbo Pascal 5.5 around the same time frame). Apple because they required it for their platform, Microsoft and Borland because OO was becoming 'cool' (then QuickPascal died soon after, and Turbo Pascal 6.0 added a reasonable OO framework called Turbo Vision).

Rudy Velthuis is quite complete on this in his forum posting.

You can download an ISO image with DOS 6.22 and a few of the DOS Pascal compilers from that era.


I think the introduction of interfaces (in Delphi 3 IIRC) was very important to make it a modern object oriented language.

  • Note that interface inheritance is not OO in it self, but it is considered to be one of the truest forms of polymorphism. As it shared the same VMT format as COM, it made interoperating with COM much easier (people have wide opinions on that being a good or bad thing <g>). Aug 14, 2011 at 8:39

I'll add anonymous methods and generics to the mix.

  • 1
    To the most recent versions of Delphi, maybe. I used up to Delphi 7, so of course never used either anonymous methods or generics! Aug 8, 2011 at 10:17

New language features between Delphi 7 and Delphi XE are described on page 52 in this white paper from Embarcadero:


For me the two biggest things (after some other languages like C...) was the case insensitivity and the compiler speed.

And after that is the fact that it is easier to write with Finnish keyboard, because I don't need constantly the {} or other keys that is difficult to reach...

I've been aboard since Delphi2 but used D1 in work couple of years...


Start with "Structured Programming", by Dahl, Dijkstra, and Hoare. Dijkstra's section is fundamental, even today. Tony Hoare's section on data structuring laid a great deal of the groundwork for PASCAL. (Dahl's section talked about what eventually became object-oriented programming. He described what became classes in Simula 67.)

Look into ALGOL-W, Wirth's implementation of a variant of ALGOL-60.

You also need to know about PL/I and the IBM 360 link editor (linker) at the time. It was a marvel of generality, with the minor issue that it ran slower than molasses in January in Juneau, Alaska. PASCAL was specifically designed to be compiled and linked in one pass, for speed. (It did help that the language started life on a CDC 6400 junior supercomputer, with lots of memory, making a one-pass compiler practical.)

There were actually two major versions of PASCAL from ETH Zurich. The language everyone currently knows as PASCAL was actually PASCAL2, the second version.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

Not the answer you're looking for? Browse other questions tagged or ask your own question.