Op dit moment ben ik bezig met het schrijven van een boek. In dit boek schreef ik een heel kort stukje over het geheugen van computers en toen ik dat geschreven had, vroeg ik mijzelf af of ik het zelf eigenlijk wel goed begreep. Daarom besloot ik iets meer over computergeheugens te weten te komen. Ik wilde o.a. kunnen uitleggen waarom we 8 geheugenplaatsen gebruiken om 1 symbool in het geheugen van een computer op te slaan. Het resultaat staat hieronder.

Het boek dat ik aan het schrijven ben is mijn tweede boek. Het is bedoeld voor studenten van scholen en universeiten en geeft een eenvoudige inleiding in het programmeren. Het boek is nog niet uitgegeven. Als je op zoek bent naar een boek over programmeren met LiveCode, kun je eens kijken naar Programming LiveCode for the Real Beginner.

IBM, in 1924 voortgekomen uit de Computing Tabulating Recording Company, dat apparaten maakte om berekeningen te vereenvoudigen, produceerde in 1944 de MARK I, de eerste automatische rekenmachine. MARK I was zo groot als een flinke huiskamer en gebruikte geen micro-elektronica maar radiobuizen en andere elektrische onderdelen. Van geheugen zoals die in hedendaagse computers gebruikt worden, was nog geen sprake.

In 1968 introduceerde Hewlett-Packard een apparaat dat je de eerste personal computer zou kunnen noemen, de HP 9100A. Dit apparaat kon ongeveer hetzelfde als de gemiddelde zakcalculator in het begin van de jaren 1990 kon. De HP 9100A had in totaal 8 kilobyte werkgeheugen. In 1976 kwamen Steve Jobs en Steve Wozniak met de Apple I. Om de productiekosten laag te houden, kozen ze er voor om eveneens slechts 8 kilobyte werkgeheugen in te bouwen. In 1977 begon Commodore met de verkoop van de PET 2001, die standaard 4 kilobyte geheugen tot zijn beschikking had. Omdat de PET de eerste complete computer met toetsenbord en beeldscherm was, zou je dit de eerste echte home computer kunnen noemen. Pas eind jaren 1970 en vooral in de jaren 1980, nam de hoeveelheid geheugen die in computers werd ingebouwd, toe. Bekende modellen zijn de C64, de Macintosh 128K en de ATARI ST. De ATARI had minimaal 512 kilobyte geheugen.

De kleine hoeveelheid geheugen brengt natuurlijk beperkingen met zich mee. Dit hangt samen met het aantal verschillende symbolen (letters, cijfers en leestekens) dat je wilt kunnen gebruiken. Als je bijvoorbeeld slechts 2 symbolen wilt gebruiken, een 0 en een 1, dan heb je slechts 1 bit (een plaats in het geheugen) nodig. Dat lijkt merkwaardig, maar omdat een bit aan of uit kan zijn, kun je alleen al door hem aan of uit te zetten een waarde aan hem toekennen, dus bijvoorbeeld 0 of 1.  Als de bit uit is, geef je hem de waarde 0 en als hij aan is de waarde 1. Voor 4 verschillende waarden heb je slechts 2 bits nodig.

00 alle bits uit (bijvoorbeeld 0)
01 een bit aan (1)
10 de andere bit aan (2)
11 twee bits aan (3)

Het probleem is dat je meer bits nodig hebt naarmate je meer symbolen tot je beschikking hebt. Als je meer dan 4 (en maximaal 8) verschillende waarden wilt kunnen weergeven, heb je 3 bits nodig:

000 (0)
001 (1)
010 (2)
011 (3)
100 (4)
101 (5)
110 (6)
111 (7)

Als je alle 26 (hoofd)letters van het alfabet wilt gebruiken, heb je voor elk symbool 5 bits nodig:

00000 (A)
00001 (B)
00010 (C)
etc.

en als je ook nog 26 kleine letters en 10 cijfers wilt kunnen gebruiken, dus in totaal 62 verschillende symbolen, dan heb je voor ieder symbool 6 bits nodig. Voor het gebruik van extra symbolen heb je dus voor ieder symbool meer bits nodig. Daardoor neemt het benodigde geheugen voor het weergeven van de symbolen exponentieel toe. Vanaf eind jaren 1960 werkten de meeste computers met 128 verschillende symbolen en vanaf eind jaren 1970 met 256 verschillende symbolen. Daarvoor zijn 7 respectievelijk 8 bits per symbool nodig. Het aantal bits dat nodig is om een symbool in het geheugen op te slaan noemen we een byte.

Voordat iemand de termen bit en byte bedacht, gebruikten we voor een rijtje eenen en nullen de term “woord”. Als je een rijtje binaire code, bijvoorbeeld 00000 00100 10010 00000 achterelkaar ziet, is dat wel begrijpelijk. De in binaire code weergegeven symbolen worden van elkaar gescheiden door spaties en zo krijgen we iets wat op woorden lijkt. Ook nu noemen we dergelijke door spaties van elkaar gescheiden codes woorden, ook als ze op een andere manier worden weergegeven, bijvoorbeeld  EF EE   00 36 00 A0 00 A8 etc.

Het aantal geheugenplaatsen dat je nodig hebt om een bepaald aantal symbolen weer te geven, kun je nu berekenen. Om 128 symbolen weer te kunnen geven, heb je 128*8=1024 bits nodig. Aangezien 8 bits gelijk is aan 1 byte, is 1024 bits gelijk aan 128 bytes. Als we de volledige ASCII tabel 4 keer in het geheugen zetten, hebben we 1024 bytes nodig. Omdat dit ongeveer gelijk is aan 1000, noemen we dit een kilobyte. Het is bij het rekenen met bits en bytes handiger om van eenheden van 1024 dan van 1000 uit te gaan.

Aangezien elk symbool 1 byte in het geheugen nodig heeft, kunnen computers met 8 kilobyte geheugen  dus maximaal

8 kilobyte geheugen * 1024 bytes = 8192 symbolen

onthouden. Als je dat geheugen moet gebruiken voor zowel een programma als de variabelen die door dat programma gecreëerd worden, dan zijn de mogelijkheden nogal beperkt, vooral vergeleken met hedendaagse computers. Deze tekst, bijvoorbeeld, zou al ruim de helft van het beschikbare geheugen in beslag nemen.