Zoals uit de vorige afleveringen bleek, lijkt Pascal in hoge mate op C en Rust en ook wel op COBOL en BASIC. Dat is historisch niet zo gek, aangezien de stamboom van programmeertalen begint met Fortran, waaruit ALGOL werd geboren. En daaruit kwamen C en Pascal gebroederlijk weer voort. Rust is dan weer een nazaat van C. Grote overeenkomsten liggen dus voor de hand. COBOL en BASIC stammen een stuk minder direct af van Fortran en ALGOL, maar hebben toch flinke overeenkomsten. Waarom? Omdat iedere programmeertaal voor iedere computer sinds de IBM 704 in hoofdlijnen met dezelfde soort machine te maken had en dus dezelfde soort dingen moest doen. Lussen, conditionele spronginstructies, rekenen en data verplaatsen. In welke taal je dat ook ordent, de basiszaken die een computer moet doen, zijn sinds die tijd niet wezenlijk veranderd en de grondstructuur van alle programmeertalen sindsdien is dan ook redelijk vergelijkbaar.

 Waar zit dan de kracht in van een programmeertaal, het onderscheidend vermogen?

Deels in heel specifieke details, zoals afgedwongen memory safety bij Rust, of het vermogen jezelf in de voet te schieten met C, of je hele been er af te schieten met C++. De eenvoud van BASIC of de leesbaarheid van Pascal. Maar niet onbelangrijk voor de kracht van een programmeertaal is de wijze waarop de taal met data om gaat. Pascal laat daarin een mooi midden zien tussen de flexibiliteit van C en de veiligheid van Rust. Pascal overtreft daarbij met gemak de mogelijkheden van BASIC. Waar COBOL een heel eigenzinnig typesysteem heeft, dat goed werkt op bestanden, sluit Pascal veel meer aan bij de typesystemen uit de C-familie met een focus op data in memory. De enkelvoudige standaardtypes, integers, booleans, etcetera, de enumeraties en de ranges hebben we al gezien. Nu de wat complexere structuren.

Als eerste krijgen we de arrays. Een definitie van een array ziet er bijvoorbeeld zo uit:

Var
  Numbers: array[1..5] of Integer;

En in je programma kan je dan zoiets schrijven als 

Numbers[2] := 60;

Betrekkelijk voor de hand liggend voor wie C al kent. Let op dat de range van de array genoemd wordt, niet de lengte van de array, zoals in C waar de declaratie was geweest: 

Int Numbers[5]; met index-waarden van 0 tot en met 4. 

Wil je verschillende types samenbrengen in een samengesteld type, zoals de struct in C, dan krijg je in Pascal: 

Type
  Student = record
    Name: string[20];
    Age: Integer;
  end; 

Als je nu een variabele X hebt van het type Student, dan kan je de inhoud benaderen via X.Name en X.Age. 

In de praktijk zal je niet zelden willen werken met een array van records en ook dat kan zonder probleem: 

Var
  X: array[1..100] of Student;

Voeg daar nog pointers aan toe en je kan met dynamische geheugenallocatie aan de slag.  

Type
  PNode = ^Node;
  Node = record
    Value: Integer;
    Next: PNode;
  end;

Var N: PNode;

New(N);
N^.Value := 10;
Dispose(N);

Iets nuttiger zou natuurlijk zijn als je aan een node een volgende node koppelt, zodat een linked list ontstaat.
Dit alles lijkt wellicht nog niet zo complex, maar met deze bouwstenen bouw je data-structuren die zowel dynamisch als zeer complex zijn, als je wilt.