Als je langer dan een koffiepauze een computer hebt gehad, heb je de termen bits en bytes wel eens voorbij zien komen. Het zijn de standaardeenheden voor het meten van RAM, harde schijfcapaciteit en bestandsgroottes in elke moderne bestandsviewer.
U hoort misschien een verkooppraatje waarin wordt beweerd dat een machine een 32-bits Pentium-processor heeft met 64 megabyte RAM en 2,1 gigabyte aan ruimte op de harde schijf. Deze specificaties verschijnen voortdurend in technische handleidingen en tutorials. Als u begrijpt wat deze termen eigenlijk betekenen, kunt u stoppen met gissen en beginnen te weten.
Decimale getallen
Om het een beetje te begrijpen, vergelijk het met iets bekends: cijfers.
Een cijfer is één vakje voor een waarde tussen 0 en 9. We combineren deze om grotere getallen te maken. Neem 6.357. Het heeft vier cijfers. De 7 staat op de “1s-plaats”. De 5 staat op de plaats van de 10. De 3 staat op de plaats van de 100. De 6 bekleedt de plaats van de 1000.
Dat kun je expliciet opschrijven:
(6 * 1000) + (3 * 100) + (5 * 10) + (7 * 1) = 6000 + 300 + 50 + 7 = 6357
Of gebruik machten van 10. Als je het dakje-symbool (^) gebruikt voor ‘tot de macht van’, ziet het er als volgt uit:
(6 * 10^3) + (3 * 10^2) + (5 * 10^1) + (10^0) = 6000 + 300 + 50 + 7 = 6357
Elk cijfer is een placeholder voor de eerstvolgende hogere macht van 10. Het eerste cijfer begint bij 10^0.
Dit voelt normaal omdat we dagelijks een base-10 -systeem gebruiken. Het bestaat waarschijnlijk omdat mensen tien vingers hebben. Als we met acht vingers zouden evolueren, zouden we waarschijnlijk een basis-8-systeem gebruiken. Je kunt elke gewenste basis gebruiken. Verschillende bases zijn zinvol in verschillende contexten.
Computers gebruiken het grondtal-2-nummersysteem. Het wordt ook wel het binaire getalsysteem genoemd.
Het Base-2-systeem en de 8-bit byte
Computers gebruiken base-2 omdat het goedkoop is. Je zou een basis-10-computer kunnen bouwen. Het zou alleen maar belachelijk duur zijn. Base-2-hardware is relatief betaalbaar.
Computers gebruiken dus binaire getallen. Ze gebruiken binaire cijfers in plaats van decimale cijfers. Het woord bit verkort “Binary digIT.”
Decimale cijfers hebben 10 waarden: 0 tot en met 9. Bits hebben slechts twee waarden: 0 en 1. Een binair getal is slechts een reeks nullen en enen, zoals 1011.
Om de waarde te vinden, gebruikt u machten met grondtal 2 in plaats van machten met grondtal 10.
(1 * 2^3) + (0 * 2^2) + (1 * 2^1) + (1 * 2^0) = 8 + 0 + 2 + 1 = 11
Elke bit vertegenwoordigt toenemende machten van 2. Tellen in binair getal is eenvoudig. Hier ziet u hoe decimaal en binair zich verhouden van 0 tot 20:
- 0 = 0
- 1 = 1
- 2 = 10
- 3 = 11
- 4 = 100
- 5 = 101
- 6 = 110
- 7 = 111
- 8 = 1000
- 9 = 1001
- 10 = 1010
- 11 = 1011
- 12 = 1100
- 13 = 1101
- 14 = 1110
- 15 = 1111
- 16 = 10.000
- 17 = 10001
- 18 = 10010
- 19 = 10011
- 20 = 10100
Let op de overdracht. Op nummer 2 draagt binair voor het eerst. Als een bit 1 is en je voegt 1 toe, wordt het 0 en wordt het volgende bit 1. Als je van 15 naar 16 gaat, loop je door vier bits heen, waardoor 1111 in 10.000 verandert.
Bits reizen zelden alleen. Ze zijn gebundeld in 8-bit-collecties. Deze bundels worden bytes genoemd.
Waarom acht bits in een byte? Het is hetzelfde als vragen waarom er twaalf eieren in een dozijn zitten. De afgelopen 50 jaar hebben mensen met vallen en opstaan gekozen voor 8 bits.
Met 8 bits kun je 256 waarden weergeven. Ze variëren van 0 tot 255.
- 0 = 00000000
- 1 = 00000001
- 2 = 00000010
- …
- 254 = 11111110
- 255 = 11111111
In Hoe cd’s werken leert u dat een cd 2 bytes per sample gebruikt. Dat zijn 16 bits. Elk monster kan variëren van 0 tot 65.535.
- 0 = 0000000000000000
- 1 = 0000000000000001
- 2 = 0000000000000010
- …
- 65534 = 1111111111111110
- 65535 = 1111111111111111
Vervolgens zullen we kijken naar één manier waarop bytes worden gebruikt.
Hoe ASCII-codering en binaire wiskunde uw gegevens versterken
Tekst is geen magie. Het zijn gewoon cijfers die een kostuum dragen.
Wanneer u een zin typt, ziet uw computer geen letters. Het ziet binaire waarden. Concreet vertrouwt het op de standaard ASCII-tekenset om toetsaanslagen in gegevens om te zetten. In dit systeem wordt elke binaire waarde van 0 tot 127 toegewezen aan een specifiek teken. De meeste systemen rekken dit uit tot 256 waarden met behulp van een volledige byte, waarbij letters met accenten en symbolen voor internationale talen worden toegevoegd.
Maar de kern van de 128 codes is waar de basis ligt.
Overweeg Windows 95/98 Kladblok. Als u ‘Vier score en zeven jaar geleden’ typt, wijst de software precies één byte geheugen per teken toe. Dit geldt ook voor de spaties tussen woorden. De spatie is ASCII-code 32. De punt is 46. ‘A’ is 65.
Probeer het zelf.
Maak een bestand met de naam getty.txt. Typ die zin. Bewaar het. Open uw bestandsverkenner. De grootte is 30 bytes. Waarom? Omdat er 30 karakters zijn. Voeg één woord toe. Het bestand groeit met het aantal letters in dat woord. Het is een directe verhouding van 1:1.
Open het bestand als onbewerkte gegevens en de letters verdwijnen. Je ziet cijfers.
Dit zijn decimale weergaven van ASCII-codes. Om technisch precies te zijn: de machine ziet alleen binair. 32 wordt 00100000. Maar de logica geldt: elke byte bevat één teken.
De eerste 32 waarden (0 tot en met 31) zijn geen letters. Het zijn controlecodes. Vervoer retourneert. Lijnfeeds. Bel klinkt. De eigenlijke afdrukbare tekens beginnen bij 32. Leestekens komen daarna. Dan cijfers. Dan hoofdletters. Dan kleine letters. U kunt het volledige diagram bekijken op Unicode.org, maar het principe is eenvoudig. Tekstopslag is slechts een lijst van deze gehele getallen.
Bytevoorvoegsels en binaire wiskunde begrijpen
Als je eenmaal begrijpt dat gegevens slechts bytes zijn, kom je een nieuw probleem tegen: schaal.
Een byte is klein. De meeste bestanden zijn enorm. We hebben dus voorvoegsels nodig.
We gebruiken bytevoorvoegsels om de omvang aan te duiden. Kilo, mega, giga. Dit zijn niet alleen marketingtermen. Het zijn binaire vermenigvuldigers.
- Kilo (K): $2^{10}$ = 1.024 bytes
- Mega (M): $2^{20}$ = 1.048.576 bytes
- Giga (G): $2^{30}$ = 1.073.741.824 bytes
- Tera (T): $2^{40}$ = ~1,1 biljoen bytes
- Peta (P): $2^{50}$ = ~1,1 biljard bytes
- Exa (E): $2^{60}$ = ~1,1 biljoen bytes
- Zetta (Z): $2^{70}$
- Yotta (Y): $2^{80}$
Kilo is ongeveer duizend. Mega is een miljoen. Giga is een miljard.
Als iemand beweert dat zijn harde schijf ‘2 gigabyte’ is, bedoelt hij $2 \maal 2^{30}$ bytes. Precies 2.147.483.648 bytes.
Dat klinkt abstract totdat je de gegevens visualiseert. Een standaard-cd bevat ongeveer 650 megabytes. Drie cd’s vullen een schijf van 2 GB. Een terabyte-database is gebruikelijk. Er bestaan waarschijnlijk petabyte-databases bij grote overheidsfaciliteiten. De schaal groeit exponentieel.
Dit brengt ons bij binaire wiskunde.
Het werkt als decimale wiskunde, met één strikte beperking. Elk bit kan slechts 0 of 1 zijn.
In decimalen tellen we 0-9. Wanneer we 9 bereiken en 1 toevoegen, dragen we de 1 naar de volgende kolom. Binair werkt identiek, maar de overdracht gebeurt sneller.
Neem decimale optelling:
Begin goed. $2+1=3$. Volgende kolom: $5+5=10$. Schrijf 0, draag 1. Vervolgens: $4+7+1(carry)=12$. Schrijf er 2, neem er 1 mee. Uiteindelijk: $0+0+1=1$. Resultaat: 1203.
Nu, binair.
Meest rechtse bit: $0+1=1$. Geen draag.
Tweede bit: $1+1=10$. Schrijf 0, draag 1.
Derde bit: $0+1+1(carry)=10$. Schrijf 0, draag 1.
Vierde bit: $0+0+1(carry)=1$.
Het resultaat is 1001. In decimalen is dat 9. De wiskunde is identiek. De weergave is slechts grondtal 2 in plaats van grondtal 10.
Het eindresultaat
Bits zijn binaire cijfers. Ze zijn 0 of 1.
Bytes zijn groepen van 8 bits.
Tekst is slechts een reeks bytes die zijn toegewezen aan ASCII-codes.
De opslaggrootte wordt gemeten in binaire machten van 1.024.
Het is niet ingewikkeld. Het is gewoon fundamenteel.
Voor een diepere duik in booleaanse logica en poortimplementaties kun je opzoeken hoe booleaanse optelling werkt. De rest is gewoon binair tellen.
