Algol (programmeertaal)

(sv) Algol is een zeer invloedrijke programmeertaal, bedacht voor wetenschappelijke doeleinden in 1958. De naam is een afkorting voor Algorithmic Language.

Geschiedenis

De taal was voortgekomen uit de wens om een machine-onafhankelijke programmeertaal te maken die zoveel mogelijk moest lijken op gebruikelijke wiskundige notatie. De taal was daarmee een reactie op de weinige andere destijds al bestaande programmeertalen, Cobol en Fortran.

De taal richtte zich op de gebruiker, en was gespecificeerd met een gedefinieerde grammatica, zodat het mogelijk werd om op een formele manier over programmacorrectheid te spreken. De implementatie van al dit moois was voor de bedenkers van later zorg. Algol was ook de eerste taal die alle programmeerparadigma's zou combineren. Alle moderne programmeertalen ontlenen wel ideeën aan Algol.

Ironisch genoeg was de taaldefinitie zo ontzettend uitgebreid, dat nooit iemand het voor elkaar heeft gekregen een compiler voor de complete taal te maken. Toch waren de gedeeltelijke implementaties, die gebruikmaken van een interpreter, in de jaren tachtig populair en wordt de taal nog steeds wel gebruikt voor pseudocode.

Er zijn drie versies van de taaldefinitie van Algol verschenen:

• Algol-58
• Algol-60
• Algol-68

Algol-58 was de eerste, deze werd dan ook in 1958 ontworpen. Deze programmeertaal was meer een verzameling van goede ideeën, maar was nooit bedoeld als volledig afgemaakt product. Toch zou deze taal de basis worden voor veel andere talen.

In 1960 kwam Algol-60 uit, als resultaat van werk van John Backus, Peter Naur en Edsger W. Dijkstra. De Amerikaanse beroepsvereniging ACM besloot dat deze taal de standaardtaal zou worden voor het weergeven van algoritmes in haar blad Communications of the ACM.

De namen van Backus en Naur zijn tot heden verbonden aan de wijze waarop de syntaxis gedefinieerd wordt. Zie Backus-Naur-formalisme.

Eigenschappen van Algol-60

De taal bestaat uit een aantal tekens die op de meeste toetsenborden te vinden zijn, en een aantal symbolen die in de definitie beschreven zijn als vetgedrukte woorden, bijvoorbeeld if then else. deze symbolen staan niet op een toetsenbord en ze werden in sommige implementaties tussen aanhalingstekens geschreven, bijvoorbeeld 'IF'A>B'THEN'X(A)'ELSE'X(B); Spaties werden genegeerd en hadden geen betekenis.

Enkele andere tekens die in het Algol-report voorkomen en die een beetje problematisch zijn, zijn ₁₀ (voor drijvende-kommagetallen) en de aanhalingstekens ‘ ’ voor strings. De verschillende implementaties hebben daar verschillende oplossingen voor. Er is zelfs een implementatie die de dubbele punt en de puntkomma niet kent, en in plaats daarvan .. respectievelijk ., schrijft. Dit geeft inderdaad geen dubbelzinnigheid.

• De blokstructuur werd geïntroduceerd (een noviteit):

begin
 ... 
end 

• Je kon in procedures (methoden) gebruikmaken van parameters, loops en recursie.
• Er kon gebruik worden gemaakt van semi-dynamische arrays. Dat wil zeggen dat je in een array een variabele kan gebruiken, bijvoorbeeld:

procedureinsert (n, a);
 valuen;
 integern, a;
begin
 integer array [1:n] list;
end;

Een Algolprogramma

Deze uitleg is op basis van Algol-60. De verschillende taaldefinities lijken veel op elkaar, maar de latere kennen meer mogelijkheden.

Eén van de belangrijkste kenmerken van Algol is dat de taal gestructureerd is. Je kunt een aantal statements groeperen door ze tussen de symbolen begin en end te zetten. Zo'n groep is zelf weer één statement. Het is hierdoor mogelijk om controle te hebben op de volgorde van het programma, waardoor het gebruik van labels en het goto-statement niet meer nodig (hoewel dit inzicht pas jaren later kwam). Een groep van statements wordt een compound-statement genoemd, en als het declaraties bevat heet het een blok. Statements die zich in een compound-statement bevinden moeten worden gescheiden door middel van puntkomma's. Een Algolprogrmma is zelf één statement, meestal een blok, omdat een programma moet starten met begin en moet eindigen met end. Een compleet Algolprogramma is dus:

begin
  
end

Aan het begin van een blok kunnen de variabelen worden gedeclareerd. Je moet eerst kijken van welk typen ze moeten zijn:

Datatypen

De volgende aspecten zijn van belang bij datatypes :

• De waarde die een variabele van dat type kan aannemen
• De operaties die mogelijk zijn met die variabele

Numerieke datatypen

• Discrete
• Denk maar aan integer, ook wel ordinale (betrekking op rangorde) typen genoemd.
• Is te herkennen aan de duidelijke opeenvolging, duidelijke voorganger en opvolger
• Dit type is het populairste
• Floating point
• Hierbij geen duidelijke opeenvolging, in Algol is deze datatype gedeclareerd als een REAL
• Bv: float 1₁₀1, 1.0000000000001
• Fixed point
• In Algol kun je van een Floating point variabele een Fixed point maken. Je kunt dit doen door parameters mee te geven. Bijvoorbeeld: rwrite (1,antwoord,8,2); schermuitvoer van deze REAL wordt in totaal 8 decimalen lang inclusief de 2 decimalen na de komma.

Karaktertypen

Als je in Algol letters wilt bewaren, gebruik je het type char. Unicode: Hierin hebben alle leestekens (ter wereld) een unieke code gekregen

Logische typen

Dit datatype heet boolean en kent twee waarden:true en false. De voorwaarde in een if-statement moet een boolean zijn. Het type Boolean is genoemd naar de Engelse wiskundige George Boole, de grondlegger van de wiskundige logica.

Gestructureerde datatypen

Dit kunnen in Algol strings en arrays zijn.

Een string bestaat uit een serie tussen apostrofs geplaatste tekens.
Een array is een reeks elementen van hetzelfde gegevenstype.

procedure insert (n, a);
 value n;
 integer n, a;
begin
 integer array list [1:n];
 ...
end;

Het "HELLO WORLD"-programma

begin
text(1,‘HELLO WORLD!’)
end

Voorbeeldprogramma

Als voorbeeld volgt hier een programma waarin het gemiddelde en de standaarddeviatie van een van te voren opgegeven aantal in te voeren getallen wordt berekend. Uiteraard is het aantal een geheel getal en zijn de in te voeren getallen, het gemiddelde en de standaarddeviatie reële getallen. Verder specificeren we dat de standaarddeviatie berekend wordt met de formule $\sigma ={\sqrt {\frac {\sum _{i=1}^{n}(x_{i}-{\bar {x}})^{2}}{n}}}$. Deze mag niet worden vereenvoudigd tot $\sigma ={\sqrt {{\frac {\sum _{i=1}^{n}{x_{i}}^{2}}{n}}-{\bar {x}}^{2}}}$ omdat die een te onnauwkeurig resultaat geeft als de afwijkingen van het gemiddelde relatief klein zijn. Dit betekent dat de ingelezen variabelen in een array opgeslagen moeten worden. In Algol-60 kan een array worden gedeclareerd dat precies plaats biedt aan het aantal in te lezen getallen. Bij het beperkte geheugen van de computers uit 1960 was dat een zeer nuttige functie.

Het programma ziet er als volgt uit, waarbij de toelichtingen zo veel mogelijk in het commentaar staan

begin comment Bereken standaarddeviatie;
  integer n;
  text(1,"aantal getallen:"); 
  n:=read(1);
  begin comment De variabelen worden pas in het binnenblok
                      gedeclareerd want ze zijn niet eerder nodig;
    real array a[1:n];
    integer i;
    real gem,stdev;
    gem:=0;
    comment Tijdens het inlezen wordt het gemiddelde berekend.
                  voor de som wordt de variabele gem gebruikt;
    for i:=1 step 1 until n do
    begin 
      text(1,‘getal ’);
      write(1,i);
      text(1,‘:’);
      a[i]:=read(1);
      gem:=gem+a[i]
    end;
    gem:=gem/n;
    comment Voor de berekeningn van de standaarddeviatie 
                  worden de opgeslagen waarden gebruikt;
    stdev:=0;
    for i:=1 step 1 until n do
       stdev:=stdev+(a[i]-gem)^2;
    stdev:=sqrt(stdev/n);
    comment Nu komt de output;
    text(1,‘gemiddelde=’); 
    rwrite(1,gem,10,6);
    text(1,‘ standaarddeviatie=’);
    rwrite(1,stdev,10,6)
  end
end

Op een DOS-scherm zien input en output er als volgt uit

aantal getallen:4
getal 1 :100001
getal 2 :100002
getal 3 :100003
getal 4 :100004
gemiddelde= 100002.48 standaarddeviatie= 1.118034

Externe links

• Downloaden van de compiler en interpreter van Algol-60
• Rechtstreeks download a60.zip
• Full DOS Algol-60 compilers en run-time programma met broncode

Leestip

Robert W. Sebesta, Concepts of programming languages

Bronnen

Artikel over Algol van David en Chon (Technische informatica, Hogeschool van Amsterdam)