Difference between revisions of "Why use Pascal"

From Free Pascal wiki
Jump to navigationJump to search
m (Text replacement - "Object Pascal Introduction" to "Basic Pascal Introduction")
(11 intermediate revisions by 3 users not shown)
Line 2: Line 2:
  
 
== Introduction ==
 
== Introduction ==
 +
 
Pascal often comes under attack as a language which should be dead, or as a language not suitable for very much.
 
Pascal often comes under attack as a language which should be dead, or as a language not suitable for very much.
  
Line 7: Line 8:
  
 
=== What is Pascal? ===
 
=== 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.
 
[[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.
 
This is important in understanding existing code as well as debugging because people don't read individual characters but whole words.
Line 39: Line 41:
  
 
== Pros and Cons ==
 
== Pros and Cons ==
 +
 +
As always: Choosing what programming language to use depends on your program you'd like to program.
 +
 
=== Pros ===
 
=== Pros ===
==== real assignment-operator ====
+
 
other languages: mathematically wrong:
+
==== Object oriented programming ====
<syntaxhighlight>
+
 
 +
You want Object Oriented Programming (OOP)? There you got OOP: FPC supports it: see [[Basic Pascal Introduction|Tutorial]].
 +
In the meantime, generics (templates, usually for classes) became possible, too, though generics can be used for a wide variety of other types as well.
 +
 
 +
==== Real assignment operator ====
 +
 
 +
Other languages: mathematically wrong (there are two equations):
 +
 
 +
<syntaxhighlight lang="C">
 
x = 42;
 
x = 42;
 
x = 3 * 3;
 
x = 3 * 3;
 
</syntaxhighlight>
 
</syntaxhighlight>
  
Pascal, right:
+
Or even worse (<syntaxhighlight lang="C" enclose="none">x</syntaxhighlight> on both sides):
<syntaxhighlight>
+
 
 +
<syntaxhighlight lang="C">
 +
x = 3 * x - 1;
 +
</syntaxhighlight>
 +
 
 +
So, <syntaxhighlight lang="C" enclose="none">x = 0.5</syntaxhighlight> or what (the f***)?
 +
 
 +
Pascal does it right (there are two consecutive definitions):
 +
 
 +
<syntaxhighlight lang="pascal">
 
x := 42;
 
x := 42;
 
x := 3 * 3;
 
x := 3 * 3;
 
</syntaxhighlight>
 
</syntaxhighlight>
  
==== strong type-safety ====
+
==== Strong type safety ====
In C you can add a character to a real and interpret it as a boolean (or whatsovever).
+
 
 +
In C you can add a character to a real and interpret it as a boolean (or whatsoever).
 
Why the heck should I do this?
 
Why the heck should I do this?
In Pascal that is not possible.
+
In Pascal that is not possible (only with force).
 
The compiler will raise an error.
 
The compiler will raise an error.
  
==== well structured ====
+
==== Well structured ====
C:
+
 
# signature
+
For example a function in C look like this:
 +
 
 +
# function signature
 
# declaration of variables … and definition of function may be mixed up
 
# declaration of variables … and definition of function may be mixed up
  
 
In Pascal it is clear:
 
In Pascal it is clear:
# signature
+
 
 +
# function/procedure signature
 
# declaration of variables …
 
# declaration of variables …
 
# definition of function/procedure/program
 
# definition of function/procedure/program
  
==== case-insensitive ====
+
==== Case-insensitive ====
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.
 
  
==== principle of scope ====
+
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.
There are many chances to limit the validity of identifiers – to limit the scope.
+
 
 +
==== Principle of scope ====
 +
 
 +
There are many chances to limit the validity of identifiers – to limit their scope.
 
Encapsulating functions/procedures or limiting a variable's/constant's/type's scope is done implicitly: Depending where you declare such things, they are only known on the same or lower levels.
 
Encapsulating functions/procedures or limiting a variable's/constant's/type's scope is done implicitly: Depending where you declare such things, they are only known on the same or lower levels.
 +
 +
==== Readability ====
 +
 +
You can write Pascal as you speak (or at least it is some more natural):
 +
 +
<syntaxhighlight lang=pascal>
 +
if x equals true then
 +
begin
 +
writeline, left round bracket, apostroph, hello world, apostroph, right round bracket, semicolon
 +
end
 +
</syntaxhighlight>
 +
 +
Counter example:
 +
 +
if, left round bracket, x equal equal true, right round bracket
 +
left curly brace
 +
print formatted, left round bracket, inch-sign, hello world,
 +
      backslash n, inch-sign, right round bracket, semicolon
 +
right curly brace
 +
 +
The counter example shows that you may get lost if you don't know what brackets and braces mean.
 +
Indeed, it's a weak pro-point.
 +
 +
==== Native set operators ====
 +
 +
Since Mr. Wirth (the father of the Pascal language) has a background in mathematics, where [[Set|sets]] (containers of units called “elements”) are a fundamental tool, he included operators for handling with sets, too.
 +
We can check, whether an element is in a set via the <tt>in</tt> operator.
 +
We can <tt>include</tt>, <tt>exclude</tt> elements, compare sets (difference, symmetric difference), combine and intersect them.
 +
Knowing where to use sets, makes your code incredibly more readable!
 +
There's no need to include any extra class or unit for that, it's already part of the language.
 +
However, FPC's current implementation of sets allows 256 elements top per set.
 +
You can't do mathematics in a large scale with that, though.
  
 
=== Cons ===
 
=== Cons ===
==== uncommon ====
 
Finding ppl for software-projects who already have xp in pas could be difficult.
 
It could be harder to find suitable library-solutions for specific problems.
 
  
==== longer ====
+
==== Reduced popularity ====
Sometimes writing all the reserved words (like "begin", "end", "then", ...) feels uncomfortable.
+
 
Other languages just use parantheses or curly braces – that is ''one'' letter.
+
Finding people for software projects who already have experience in Pascal can become difficult.
Editor functions like "match-corresponding paranthese/brace" are harder to find.
+
It could be harder to find suitable library solutions for specific problems.
 +
 
 +
==== More usage of reserved words than reserved characters ====
 +
 
 +
Sometimes writing all the reserved words (like <syntaxhighlight lang="pascal" enclose="none">begin</syntaxhighlight>, <syntaxhighlight lang="pascal" enclose="none">end</syntaxhighlight>, <syntaxhighlight lang="pascal" enclose="none">then</syntaxhighlight>, ) feels uncomfortable.
 +
Other languages just use parentheses or curly braces – that is just a single letter.
 +
Editor functions like “match-corresponding parenthesis/brace” or in Pascal-context “match corresponding <syntaxhighlight lang="pascal" enclose="none">begin</syntaxhighlight>/<syntaxhighlight lang="pascal" enclose="none">end</syntaxhighlight>” are harder to find.
 +
 
 +
==== Language corset ====
 +
 
 +
On multiple occasions programmers may encounter boundaries the language sets (e.g. the strong type safety mentioned above).
 +
These measures were set for good reasons, though:
 +
To prevent programmers from doing stupid stuff (that's actually a pro point).
 +
However, if you do not care about bad practices, you might get annoyed by that fact.
 +
 
  
 
== See also ==
 
== See also ==
* [FPC Advantages] Similar page though not as structured. Perhaps these could be merged.
+
 
 +
* [[FPC Advantages]]
  
 
== External links ==
 
== External links ==
 +
 
* [http://www.pascal-central.com Pascal Central], a repository with technical information, tools, references, source code, internet links, and more.
 
* [http://www.pascal-central.com Pascal Central], a repository with technical information, tools, references, source code, internet links, and more.
 
* [http://www.standardpascal.org Standard Pascal], reference information about the ANSI ISO 7185 standard.
 
* [http://www.standardpascal.org Standard Pascal], reference information about the ANSI ISO 7185 standard.
Line 98: Line 170:
 
[[Category:Promotion]]
 
[[Category:Promotion]]
 
[[Category:Pascal]]
 
[[Category:Pascal]]
 +
[[Category:FPC]]

Revision as of 03:30, 29 March 2020

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

Introduction

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

As always: Choosing what programming language to use depends on your program you'd like to program.

Pros

Object oriented programming

You want Object Oriented Programming (OOP)? There you got OOP: FPC supports it: see Tutorial. In the meantime, generics (templates, usually for classes) became possible, too, though generics can be used for a wide variety of other types as well.

Real assignment operator

Other languages: mathematically wrong (there are two equations):

x = 42;
x = 3 * 3;

Or even worse (x on both sides):

x = 3 * x - 1;

So, x = 0.5 or what (the f***)?

Pascal does it right (there are two consecutive definitions):

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 whatsoever). Why the heck should I do this? In Pascal that is not possible (only with force). The compiler will raise an error.

Well structured

For example a function in C look like this:

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

In Pascal it is clear:

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

Case-insensitive

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.

Principle of scope

There are many chances to limit the validity of identifiers – to limit their scope. Encapsulating functions/procedures or limiting a variable's/constant's/type's scope is done implicitly: Depending where you declare such things, they are only known on the same or lower levels.

Readability

You can write Pascal as you speak (or at least it is some more natural):

if x equals true then
begin
writeline, left round bracket, apostroph, hello world, apostroph, right round bracket, semicolon
end

Counter example:

if, left round bracket, x equal equal true, right round bracket
left curly brace
print formatted, left round bracket, inch-sign, hello world,
     backslash n, inch-sign, right round bracket, semicolon
right curly brace

The counter example shows that you may get lost if you don't know what brackets and braces mean. Indeed, it's a weak pro-point.

Native set operators

Since Mr. Wirth (the father of the Pascal language) has a background in mathematics, where sets (containers of units called “elements”) are a fundamental tool, he included operators for handling with sets, too. We can check, whether an element is in a set via the in operator. We can include, exclude elements, compare sets (difference, symmetric difference), combine and intersect them. Knowing where to use sets, makes your code incredibly more readable! There's no need to include any extra class or unit for that, it's already part of the language. However, FPC's current implementation of sets allows 256 elements top per set. You can't do mathematics in a large scale with that, though.

Cons

Reduced popularity

Finding people for software projects who already have experience in Pascal can become difficult. It could be harder to find suitable library solutions for specific problems.

More usage of reserved words than reserved characters

Sometimes writing all the reserved words (like begin, end, then, …) feels uncomfortable. Other languages just use parentheses or curly braces – that is just a single letter. Editor functions like “match-corresponding parenthesis/brace” or in Pascal-context “match corresponding begin/end” are harder to find.

Language corset

On multiple occasions programmers may encounter boundaries the language sets (e.g. the strong type safety mentioned above). These measures were set for good reasons, though: To prevent programmers from doing stupid stuff (that's actually a pro point). However, if you do not care about bad practices, you might get annoyed by that fact.


See also

External links