Zoals in COBOL een programma is opgebouwd in vaste blokken met datadefinities, input en output, programma-logica et cetera, kent ook Pascal een voorgeschreven opbouw van ieder programma in blokken. Die blokken zijn niet verplicht, maar als je iets wil doen dat in zo'n blok past, dan moet het ook in dat blok en die blokken moeten in de voorgeschreven volgorde staan. De vrijheid die C kent, ontbreekt dus in Pascal. Turbo Pascal geeft daarin wel weer meer vrijheid. In de basis ziet een TP-programma er altijd zo uit, met weglating van wat niet nodig is: 

Program ProgrammaNaam; 

Uses
  Unit1, Unit2;

Label
  Labels;

Const
  Constanten = ...;

Type
  TypeDefinities = ...;

Var
  Variabelen: ...;

{ Procedures en Functions }
Procedure DoSomething;
Begin
  { ... }
End;

Function Compute: Integer;
Begin
  { ... }
  Compute := 0;
End;

Begin
  { Programma‑logica }
End.

Binnen een function en een procedure heb je opnieuw een structuur waarin labels, constanten, types en variabelen kunnen worden gedeclareerd. Deze bestaan dan uitsluitend lokaal in die function of procedure. Het doorgeven van waarden gaat als volgt: 

Procedure VbProc(var X, Y: Integer);
     <procedureblok>

Function VbFunc(I, J: Integer): Real;
     <functieblok>

Wil je nu in je hoofdprogramma de variabelen A en B laten bewerken door VbProc en daarna tot een waarde bewerken door VbFunc, dan krijg je zoiets als

VbProc(A, B);
C := VbFunc(A,B);

Een paar bijzonderheden van Pascal: In een functie geef je de returnwaarde anders door dan in C of Rust, namelijk via de naam van de functie zelf. Hier dus via VbFunc := <return-waarde>.

Bij het doorgeven van de waardes in de declaratie gebruik je var, zoals in VbProc om de referentie door te geven. Zonder var wordt de waarde doorgegeven. In een procedure die iets met variabelen moet doen, zal je dus veelal met var werken. Maar in een functie die alleen iets berekent op basis van je variabelen, de waardes dus, zal je veelal zonder var werken.