Difference between revisions of "Why use Pascal"

From Lazarus wiki
m (well strutured)
m (= longer)
Line 77: Line 77:
==== longer ===
==== longer ===
Sometimes writing all the reserved like words begin, end, then feels uncomfortable
Sometimes writing all the reserved words (like "begin", "end", "then", ...) feels uncomfortable
== External links ==
== External links ==

Revision as of 01:20, 26 January 2014

“A low level language is one whose programs require attention to the irrelevant.”


Pascal often comes under attack as a language which should be dead, or as a language not suitable for very much.

This document will discuss these claims and add the latest informations about Pascal as of 2013 and beyond.

What is Pascal?

Pascal is a very clean programming language, which looks more like real languages in the sense that it uses real English words as keywords rather than random ASCII characters. This is important in understanding existing code as well as debugging because people don't read individual characters but whole words.

A common misconception is that Pascal started as a teaching language. While this is partially true, the associations are usually wrong; usually that makes people expect systems like Logo, limited playing grounds for children.

Pascal, like its predecessor ALGOL(-60), however was primarily designed as a language for formal specification and teaching of algorithms, mostly with future engineers and computer scientists as target. Contrary to ALGOL-68, emphasis was put on simplicity. This turned out to be beneficial for compiler construction.

The initial Pascal dialects had a series of serious ugliness (like untyped procedure variables) that were quickly remedied, way before the language's prime time in the eighties (revised J&W and early standardization trajectory).

Further modernization and facilities for interfacing to lower level systems were added to nearly every dialect. Most of these weren't standardized back into the language, but this was normal at the time (way before C and POSIX standards). However the dialects were not entirely random, and could be classified into two major streams, UCSD/Borland like and ISO standards compliant, with Apple creating a hybrid between the two (UCSD in origin, but incorporating most level 1 ISO features).

Over the years especially the Borland stream language has matured and gained all capabilities necessary for up-to-date large scale software projects (for example the Free Pascal compiler or the Lazarus IDE).

The particular strength of Pascal is that most development time is spent on the program itself, contrary to C and C++ like languages, where the developer needs to focus on managing the memory of variables or the structure of very basic things like passing parameters and returning them back again.

As a result, Pascal developers do not have to learn a new sub-language inside the same language, like C++, STL, MFC.

The Readln and Writeln effect

Most developers that touched Pascal did not like the language, because they only learned some very basic commands and how to write a more structured code than their mind was thinking at the time.

That is, why languages such as C and Perl, for example, have tended to win the popularity contests. While Pascal seems very basic and very minimalistic, when you uncover the true language, you find that it is much easier to create a program in Pascal than in C, Java and other popular languages. Even languages such as Python, while popular and still remains structured, have many elements of a disoriented language. That issue arrives first of all from the attempt to create the most “perfect” programming language, that will be easy to use, and have the cleanest way to create things.

Pros and Cons


real assignment-operator

other languages: mathematically wrong:

x = 42;
x = 3 * 3;

Pascal, right:

x := 42;
x := 3 * 3;

strong type-safety

In C you can add a character to a real and interpret it as a boolean (or whatsovever). Why the heck should I do this? In Pascal that is not possible. The compiler will raise an error.

well structured


  1. signature
  2. declaration of variables … and definition of function may be mixed up

In Pascal it is clear:

  1. signature
  2. declaration of variables …
  3. definition of function/procedure/program


A function defined with the name getLimit will be called though you forgot the upper-case-L in the middle ( (calling getlimit()). It does not raise a compile-time-error.



= longer

Sometimes writing all the reserved words (like "begin", "end", "then", ...) feels uncomfortable

External links