Take the 2-minute tour ×
Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free, no registration required.

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.)

share|improve this question
    
@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 '11 at 18:40
1  
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 '11 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 '11 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). –  Jeroen Wiert Pluimers Aug 13 '11 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 '11 at 22:34
show 2 more comments

13 Answers

up vote 8 down vote accepted

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.

share|improve this answer
add comment

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.

share|improve this answer
    
Turbo Pascal was the simple product. Borland Pascal had a LOT of extra stuff like assemblers etc. –  user1249 Aug 1 '11 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 '11 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 '11 at 11:55
add comment

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.

share|improve this answer
8  
Objects were introduced into Pascal with Turbo Pascal 5.5 –  mcottle Jul 29 '11 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 '11 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 '11 at 19:33
2  
Objects were introduced into Pascal by Apple. en.wikipedia.org/wiki/Object_Pascal#Early_history_at_Apple –  Carl Manaster Jul 31 '11 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 '11 at 7:49
show 4 more comments

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

share|improve this answer
    
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>). –  Jeroen Wiert Pluimers Aug 14 '11 at 8:39
add comment

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

share|improve this answer
    
To the most recent versions of Delphi, maybe. I used up to Delphi 7, so of course never used either anonymous methods or generics! –  Frank Shearar Aug 8 '11 at 10:17
add comment

New language features between Delphi 7 and Delphi XE are described on page 52 in this white paper from Embarcadero:
http://www.embarcadero.com/images/dm/technical-papers/reasons-to-migrate-to-delphi-xe-white-paper.pdf

share|improve this answer
add comment

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.
share|improve this answer
    
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 '11 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. –  Marco van de Voort Nov 30 '13 at 11:50
add comment

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.

share|improve this answer
    
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 '11 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. –  quickly_now Aug 2 '11 at 23:02
add comment

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.

share|improve this answer
    
+1 for the ironic use of "real programmers"! –  David Heffernan Aug 7 '11 at 14:25
add comment

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.

share|improve this answer
add comment

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...

share|improve this answer
add comment

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.

share|improve this answer
add comment

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.

share|improve this answer
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

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