Alai

Het besturingssysteem bepaalt onze computerervaring. Het is de eerste software die we zien wanneer we de computer aanzetten, en de laatste software die we zien wanneer de computer wordt uitgezet. Het is de software die alle programma’s mogelijk maakt die we gebruiken. Het besturingssysteem organiseert en bestuurt de hardware op ons bureau en in onze handen, maar de meeste gebruikers kunnen niet met zekerheid zeggen wat het besturingssysteem nu precies doet.

In deze editie van HowStuffWorks vertellen we u wat een stuk software moet doen om een besturingssysteem genoemd te worden, en laten we u zien hoe het besturingssysteem werkt om een verzameling hardware om te zetten in een krachtig computerprogramma!

The Bare Bones
Het is belangrijk te beseffen dat niet alle computers een besturingssysteem hebben. De computer die bijvoorbeeld de magnetron in uw keuken aanstuurt, heeft geen besturingssysteem nodig. Hij heeft een reeks relatief eenvoudige taken uit te voeren, zeer eenvoudige invoer- en uitvoermethodes (een toetsenbord en een LCD-scherm), en eenvoudige, nooit veranderende hardware om te besturen. Voor een computer als deze zou een besturingssysteem overbodige bagage zijn, die complexiteit toevoegt waar dat niet nodig is. In plaats daarvan draait de computer in een magnetron de hele tijd maar één programma.

Voor computersystemen die de complexiteit van de magnetron te boven gaan, kan een besturingssysteem echter de sleutel zijn tot een grotere bedrijfsefficiëntie en een eenvoudiger ontwikkeling van toepassingen. Alle desktopcomputers hebben besturingssystemen. De meest voorkomende zijn de Windows familie van besturingssystemen, de UNIX familie van besturingssystemen en de Macintosh besturingssystemen. Er zijn honderden andere besturingssystemen beschikbaar voor speciale toepassingen, waaronder specialisaties voor mainframes, robotica, fabricage, real-time controlesystemen, enzovoort.

Op het eenvoudigste niveau doet een besturingssysteem twee dingen:

• Het beheert de hardware- en softwarebronnen van het computersysteem. Deze middelen omvatten zaken als de processor, geheugen, schijfruimte, enz.
• Het biedt een stabiele, consistente manier voor toepassingen om met de hardware om te gaan zonder alle details van de hardware te hoeven kennen.

De eerste taak, het beheer van de hardware- en softwarebronnen, is zeer belangrijk, omdat verschillende programma’s en invoermethoden om de aandacht van de centrale verwerkingseenheid (CPU) concurreren en geheugen, opslag en bandbreedte voor invoer/uitvoer (I/O) opeisen voor hun eigen doeleinden. In deze hoedanigheid speelt het besturingssysteem de rol van de goede ouder, door ervoor te zorgen dat elke toepassing de nodige middelen krijgt, terwijl het netjes speelt met alle andere toepassingen, en door de beperkte capaciteit van het systeem te gebruiken voor het grootste goed van alle gebruikers en toepassingen.

De tweede taak, het leveren van een consistente applicatie-interface, is vooral belangrijk als er meer dan één van een bepaald type computer is die het besturingssysteem gebruikt, of als de hardware waaruit de computer is opgebouwd, ooit kan veranderen. Een consistente applicatieprogramma-interface (API) stelt een software-ontwikkelaar in staat een applicatie op één computer te schrijven en er in hoge mate op te vertrouwen dat deze op een andere computer van hetzelfde type zal werken, zelfs indien de hoeveelheid geheugen of de hoeveelheid opslagruimte op de twee machines verschillend is. Zelfs als een bepaalde computer uniek is, kan een besturingssysteem ervoor zorgen dat toepassingen blijven werken wanneer hardware-upgrades en -updates plaatsvinden, omdat het besturingssysteem en niet de toepassing belast is met het beheer van de hardware en de verdeling van de hulpbronnen. Windows 98 is een goed voorbeeld van de flexibiliteit die een besturingssysteem biedt. Windows 98 draait op hardware van duizenden leveranciers. Het kan duizenden verschillende printers, disk drives en speciale randapparatuur bevatten in elke mogelijke combinatie.

Binnen de brede familie van besturingssystemen zijn er over het algemeen vier typen, gecategoriseerd op basis van het soort computers dat zij besturen en het soort toepassingen dat zij ondersteunen. De brede categorieën zijn:

• Real-time besturingssysteem (RTOS) – Real-time besturingssystemen worden gebruikt om machines, wetenschappelijke instrumenten en industriële systemen te besturen. Een RTOS heeft doorgaans zeer weinig mogelijkheden voor de gebruikersinterface en geen eindgebruikersprogramma’s, aangezien het systeem een “verzegelde doos” is wanneer het voor gebruik wordt afgeleverd. Een zeer belangrijk onderdeel van een RTOS is het beheren van de middelen van de computer, zodat een bepaalde bewerking telkens in precies dezelfde tijd wordt uitgevoerd. In een complexe machine kan het sneller laten bewegen van een onderdeel, alleen omdat er systeembronnen beschikbaar zijn, net zo rampzalig zijn als het helemaal niet te laten bewegen omdat het systeem bezig is.
• Single-user, single task – Zoals de naam al aangeeft, is dit besturingssysteem ontworpen om de computer zo te beheren dat één gebruiker effectief één ding tegelijk kan doen. Het Palm OS voor Palm handheld computers is een goed voorbeeld van een modern single-user, single-task besturingssysteem.
• Single-user, multi-tasking – Dit is het type besturingssysteem dat de meeste mensen tegenwoordig op hun desktop- en laptopcomputers gebruiken. Windows 98 en het MacOS zijn beide voorbeelden van een besturingssysteem waarbij een enkele gebruiker meerdere programma’s tegelijk kan gebruiken. Het is bijvoorbeeld heel goed mogelijk voor een Windows-gebruiker om een notitie te schrijven in een tekstverwerker terwijl hij een bestand downloadt van het Internet terwijl hij de tekst van een e-mailbericht afdrukt.
• Multi-user – Een multi-user besturingssysteem stelt veel verschillende gebruikers in staat om gelijktijdig gebruik te maken van de middelen van de computer. Het besturingssysteem moet ervoor zorgen dat de eisen van de verschillende gebruikers met elkaar in evenwicht zijn, en dat elk van de programma’s die zij gebruiken over voldoende en afzonderlijke bronnen beschikt, zodat een probleem bij één gebruiker niet de hele gemeenschap van gebruikers treft. Unix, VMS, en mainframe-besturingssystemen, zoals MVS, zijn voorbeelden van multi-user besturingssystemen.

Het is belangrijk om hier onderscheid te maken tussen multi-user besturingssystemen en single-user besturingssystemen die netwerken ondersteunen. Windows 2000 en Novell Netware kunnen elk honderden of duizenden netwerkgebruikers ondersteunen, maar de besturingssystemen zelf zijn geen echte multi-user besturingssystemen. De systeembeheerder is de enige “gebruiker” voor Windows 2000 of Netware. De netwerkondersteuning en alle gebruikerslogins op afstand die het netwerk mogelijk maakt, zijn in het totaalplan van het besturingssysteem een programma dat wordt uitgevoerd door de administratieve gebruiker.

Met de verschillende soorten besturingssystemen in gedachten, is het tijd om te kijken naar de basisfuncties die door een besturingssysteem worden geleverd.

Wake-Up Call
Wanneer de stroom naar een computer wordt ingeschakeld, is het eerste programma dat wordt uitgevoerd meestal een reeks instructies die in het ROM (read-only memory) van de computer wordt bewaard en die de systeemhardware onderzoekt om te controleren of alles naar behoren functioneert. Deze inschakelzelftest (POST) controleert de CPU, het geheugen en de basisinput-outputsystemen (BIOS) op fouten en slaat het resultaat op een speciale geheugenplaats op. Zodra de POST met succes is voltooid, begint de in ROM geladen software (soms firmware genoemd) de diskdrives van de computer te activeren. In de meeste moderne computers, wanneer de computer de harde schijf activeert, vindt het het eerste stuk van het besturingssysteem: de bootstrap loader.

De bootstrap loader is een klein programma dat slechts één functie heeft: Het laadt het besturingssysteem in het geheugen en zorgt ervoor dat het kan beginnen werken. In de meest elementaire vorm zet de bootstrap loader de kleine stuurprogramma’s op die de interface vormen met de verschillende hardware subsystemen van de computer en deze aansturen. Hij stelt de geheugenpartities in die het besturingssysteem, de gebruikersinformatie en de toepassingen bevatten. Het zet de gegevensstructuren op die de ontelbare signalen, vlaggen en semaforen bevatten die worden gebruikt om te communiceren binnen en tussen de subsystemen en toepassingen van de computer. Daarna wordt de controle over de computer overgedragen aan het besturingssysteem.

De taken van het besturingssysteem, in de meest algemene zin, vallen uiteen in zes categorieën:

• Processorbeheer
• Geheugenbeheer
• Apparaatbeheer
• Opslagbeheer
• Applicatie-interface
• Gebruikersinterface

Hoewel er mensen zijn die beweren dat een besturingssysteem meer dan deze zes taken zou moeten doen, en sommige leveranciers van besturingssystemen bouwen veel meer hulpprogramma’s en hulpfuncties in hun besturingssystemen in, maar deze zes taken bepalen de kern van bijna alle besturingssystemen. Laten we eens kijken naar de hulpmiddelen die het besturingssysteem gebruikt om elk van deze functies uit te voeren.

Processorbeheer
De kern van het beheer van de processor komt neer op twee verwante zaken:

• Zorgen dat elk proces en elke toepassing genoeg tijd van de processor krijgt om goed te functioneren
• Zoveel mogelijk processorcycli gebruiken voor echt werk

De basiseenheid van software waarmee het besturingssysteem te maken heeft bij het plannen van het werk dat door de processor wordt gedaan, is ofwel een proces of een thread, afhankelijk van het besturingssysteem.

Het is verleidelijk om te denken aan een proces als een toepassing, maar dat geeft een onvolledig beeld van hoe processen zich verhouden tot het besturingssysteem en de hardware. De toepassing die u ziet (tekstverwerker of spreadsheet of spel) is, inderdaad, een proces, maar die toepassing kan verschillende andere processen doen starten, voor taken zoals communicatie met andere apparaten of andere computers. Er zijn ook talloze processen die lopen zonder dat je direct bewijs hebt dat ze ooit bestaan. Een proces is dus software die een bepaalde actie uitvoert en kan worden bestuurd – door een gebruiker, door andere toepassingen of door het besturingssysteem.

Het zijn processen, in plaats van toepassingen, die het besturingssysteem controleert en inplant voor uitvoering door de CPU. In een single-tasking systeem is het schema rechttoe rechtaan. Het besturingssysteem staat toe dat de toepassing begint te lopen, en schort de uitvoering slechts lang genoeg op om interrupts en gebruikersinvoer af te handelen. Interrupts zijn speciale signalen die door hardware of software naar de CPU worden gestuurd. Het is alsof een deel van de computer plotseling zijn hand opsteekt om de aandacht van de CPU te vragen tijdens een levendige vergadering. Soms zal het besturingssysteem de prioriteit van processen zo plannen dat interrupts gemaskeerd worden — dat wil zeggen, het besturingssysteem zal de interrupts van sommige bronnen negeren zodat een bepaalde taak zo snel mogelijk voltooid kan worden. Er zijn sommige interrupts (zoals die van foutcondities of problemen met het geheugen) die zo belangrijk zijn dat ze niet genegeerd kunnen worden. Deze non-maskable interrupts (NMI’s) moeten onmiddellijk worden afgehandeld, ongeacht de andere taken die er zijn.

Hoewel interrupts enige complicatie toevoegen aan de uitvoering van processen in een single-tasking systeem, wordt de taak van het besturingssysteem veel gecompliceerder in een multi-tasking systeem. Nu moet het besturingssysteem de uitvoering van toepassingen zo regelen dat u denkt dat er verschillende dingen tegelijk gebeuren. Dit is ingewikkeld omdat de CPU maar één ding tegelijk kan doen. Om de indruk te wekken dat er veel dingen tegelijk gebeuren, moet het besturingssysteem duizenden keren per seconde schakelen tussen verschillende processen. Dit is hoe het gebeurt.

• Een proces neemt een bepaalde hoeveelheid RAM in beslag. Het maakt ook gebruik van registers, stapels en wachtrijen binnen de CPU en het besturingssysteem geheugenruimte.
• Wanneer twee processen multi-tasking zijn, wijst het besturingssysteem een bepaald aantal CPU-uitvoeringscycli toe aan één programma.
• Na dat aantal cycli maakt het besturingssysteem kopieën van alle registers, stapels en wachtrijen die door de processen worden gebruikt, en noteert het het punt waarop het proces in zijn uitvoering heeft gepauzeerd.
• Het laadt vervolgens alle registers, stapels en wachtrijen die door het tweede proces worden gebruikt en staat het een bepaald aantal CPU-cycli toe.
• Wanneer die zijn voltooid, maakt het kopieën van alle registers, stapels en wachtrijen die door het tweede programma worden gebruikt, en laadt het eerste programma.

Alle informatie die nodig is om een proces bij te houden tijdens het schakelen, wordt bewaard in een gegevenspakket dat een procesbesturingsblok wordt genoemd. Het procescontroleblok bevat gewoonlijk:

• Een ID-nummer dat het proces identificeert
• Punten naar de locaties in het programma en zijn gegevens waar verwerking het laatst heeft plaatsgevonden
• Inhoud van registers
• Standen van verschillende vlaggen en schakelaars
• Punten naar de boven- en ondergrenzen van het voor het proces benodigde geheugen
• Een lijst van door het proces geopende bestanden
• De prioriteit van het proces
• De status van alle door het proces benodigde I/O-apparaten

Wanneer de status van het proces verandert, van in afwachting naar actief, bijvoorbeeld, of van opgeschort naar lopend, moet de informatie in het procesbesturingsblok net als de gegevens in elk ander programma worden gebruikt om de uitvoering van het taak-omschakelingsgedeelte van het besturingssysteem te sturen.

Dit verwisselen van processen gebeurt zonder directe tussenkomst van de gebruiker, en elk proces krijgt voldoende CPU-cycli om zijn taak in een redelijke hoeveelheid tijd te volbrengen. Er kunnen echter problemen ontstaan als de gebruiker probeert te veel processen tegelijk te laten werken. Het besturingssysteem zelf heeft enige CPU-cycli nodig voor het opslaan en verwisselen van alle registers, wachtrijen en stapels van de applicatieprocessen. Als er genoeg processen worden gestart, en als het besturingssysteem niet zorgvuldig is ontworpen, kan het systeem het overgrote deel van zijn beschikbare CPU-cycli gaan gebruiken om tussen processen te swappen in plaats van processen uit te voeren. Wanneer dit gebeurt, heet het thrashing, en het vereist meestal een soort van directe tussenkomst van de gebruiker om processen te stoppen en weer orde in het systeem te brengen.

Een van de manieren waarop ontwerpers van besturingssystemen de kans op thrashing verkleinen, is door de behoefte aan nieuwe processen voor het uitvoeren van verschillende taken te verminderen. Sommige besturingssystemen maken een “proces-lite” mogelijk, een thread genaamd, die al het CPU-intensieve werk van een normaal proces kan doen, maar zich in het algemeen niet bezighoudt met de verschillende soorten I/O en geen structuren opzet waarvoor het uitgebreide procescontroleblok van een normaal proces nodig is. Een proces kan vele threads of andere processen starten, maar een thread kan geen proces starten.

Tot nu toe heeft alle scheduling die we hebben besproken betrekking gehad op een enkele CPU. In een systeem met twee of meer CPU’s moet het besturingssysteem de werkbelasting over de CPU’s verdelen en proberen de eisen van de vereiste processen in evenwicht te brengen met de beschikbare cycli op de verschillende CPU’s. Asymmetrische besturingssystemen gebruiken één CPU voor hun eigen behoeften en verdelen de applicatieprocessen over de overige CPU’s. Symmetrische besturingssystemen verdelen zichzelf over de verschillende CPU’s, waarbij de vraag wordt afgewogen tegen de beschikbaarheid van de CPU, zelfs wanneer het besturingssysteem zelf het enige is dat draait.

Zelfs als het besturingssysteem de enige software is met uitvoeringsbehoeften, is de CPU niet de enige bron die moet worden gepland. Geheugenbeheer is de volgende cruciale stap om ervoor te zorgen dat alle processen soepel verlopen.

Geheugen- en opslagbeheer
Wanneer een besturingssysteem het geheugen van de computer beheert, zijn er twee brede taken die moeten worden uitgevoerd:

• Elk proces moet voldoende geheugen hebben om te kunnen worden uitgevoerd, en het mag niet in de geheugenruimte van een ander proces komen, noch door een ander proces worden binnengedrongen.
• De verschillende soorten geheugen in het systeem moeten goed worden gebruikt, zodat elk proces zo effectief mogelijk kan draaien.

De eerste taak vereist dat het besturingssysteem geheugengrenzen instelt voor soorten software en voor afzonderlijke toepassingen.

Als voorbeeld nemen we een denkbeeldig systeem met 1 megabyte (1.000 kilobytes) RAM. Tijdens het opstartproces is het besturingssysteem van onze denkbeeldige computer ontworpen om naar de top van het beschikbare geheugen te gaan en dan ver genoeg “terug te gaan” om te voldoen aan de behoeften van het besturingssysteem zelf. Laten we zeggen dat het besturingssysteem 300 kilobyte nodig heeft om te draaien. Nu gaat het besturingssysteem naar de bodem van de RAM-pool en begint met het opbouwen van de verschillende stuurprogramma’s die nodig zijn om de hardware-subsystemen van de computer te besturen. In onze denkbeeldige computer nemen de stuurprogramma’s 200 kilobyte in beslag. Dus nadat het besturingssysteem volledig is geladen, blijft er nog 500 kilobyte over voor toepassingsprocessen.

Wanneer toepassingen in het geheugen worden geladen, worden ze geladen in blokgroottes die door het besturingssysteem worden bepaald. Als de blokgrootte 2 kilobytes is, dan krijgt elk geladen proces een stuk geheugen dat een veelvoud is van 2 kilobytes in grootte. Applicaties worden geladen in deze vaste blokgroottes, waarbij de blokken beginnen en eindigen op grenzen die worden bepaald door woorden van 4 of 8 bytes. Deze blokken en grenzen helpen ervoor te zorgen dat toepassingen niet bovenop elkaars ruimte worden geladen door een slecht berekend bit of twee. Nu dat zeker is gesteld, is de grotere vraag wat te doen als de 500 kilobyte toepassingsruimte is gevuld.

In de meeste computers is het mogelijk om geheugen toe te voegen boven de oorspronkelijke capaciteit. U kunt bijvoorbeeld het RAM-geheugen uitbreiden van 1 naar 2 megabyte. Dit werkt prima, maar is vaak relatief duur. Het gaat ook voorbij aan een fundamenteel feit van computergebruik — het grootste deel van de informatie die een toepassing in het geheugen opslaat, wordt op een gegeven moment niet gebruikt. Een processor kan het geheugen slechts één plaats tegelijk benaderen, dus het overgrote deel van het RAM-geheugen is op elk moment ongebruikt. Aangezien schijfruimte goedkoop is vergeleken met RAM, kan het verplaatsen van informatie in het RAM naar de harde schijf de RAM-ruimte zonder kosten aanzienlijk vergroten. Deze techniek wordt virtueel geheugenbeheer genoemd.

Disk-opslag is slechts een van de geheugentypen die door het besturingssysteem moeten worden beheerd, en is het langzaamst. Gerangschikt in volgorde van snelheid zijn de geheugentypen in een computersysteem:

• High-speed cache – Dit zijn snelle, relatief kleine hoeveelheden geheugen die beschikbaar zijn voor de CPU via de snelste verbindingen. Cachecontrollers voorspellen welke stukjes gegevens de CPU de volgende keer nodig heeft en halen die uit het hoofdgeheugen naar de hogesnelheids-cache om de systeemprestaties te versnellen.
• Hoofdgeheugen – Dit is het RAM-geheugen dat u in megabytes gemeten ziet wanneer u een computer koopt.
• Secundair geheugen – Dit is meestal een soort roterende magnetische opslag die toepassingen en gegevens beschikbaar houdt om te worden gebruikt, en dient als virtueel RAM onder controle van het besturingssysteem.

Het besturingssysteem moet de behoeften van de verschillende processen in evenwicht brengen met de beschikbaarheid van de verschillende soorten geheugen, waarbij gegevens in blokken (pagina’s genaamd) tussen het beschikbare geheugen worden verplaatst zoals het schema van processen voorschrijft.

Apparaatbeheer
Het pad tussen het besturingssysteem en vrijwel alle hardware die niet op het moederbord van de computer staat, loopt via een speciaal programma dat een driver wordt genoemd. Een groot deel van de functie van een stuurprogramma is de vertaler tussen de elektrische signalen van de hardware-subsystemen en de programmeertalen op hoog niveau van het besturingssysteem en de toepassingsprogramma’s. Drivers nemen gegevens die het besturingssysteem heeft gedefinieerd als een bestand en vertalen ze in stromen bits die op specifieke locaties op opslagapparaten worden geplaatst, of een reeks laserpulsen in een printer.

Omdat er zulke grote verschillen zijn in de hardware die via drivers wordt aangestuurd, zijn er ook verschillen in de manier waarop de driver-programma’s functioneren, maar de meeste worden uitgevoerd wanneer het apparaat nodig is, en functioneren ongeveer hetzelfde als elk ander proces. Het besturingssysteem zal vaak blokken met een hoge prioriteit aan drivers toewijzen, zodat de hardware-bron zo snel mogelijk kan worden vrijgegeven en klaargemaakt voor verder gebruik.

Een van de redenen waarom stuurprogramma’s gescheiden zijn van het besturingssysteem is dat nieuwe functies kunnen worden toegevoegd aan het stuurprogramma — en dus aan de hardware subsystemen — zonder dat het besturingssysteem zelf hoeft te worden gewijzigd, opnieuw gecompileerd en opnieuw gedistribueerd. Door de ontwikkeling van nieuwe drivers voor hardware-apparaten, een ontwikkeling die vaak wordt uitgevoerd of betaald door de fabrikant van de subsystemen in plaats van door de uitgever van het besturingssysteem, kunnen de input/output-mogelijkheden van het totale systeem sterk worden verbeterd.

Het beheer van invoer en uitvoer is grotendeels een kwestie van het beheren van wachtrijen en buffers, speciale opslagfaciliteiten die een stroom bits van een apparaat, misschien een toetsenbord of een seriële poort, aannemen, die bits vasthouden, en ze aan de CPU afgeven met een snelheid die langzaam genoeg is voor de CPU om aan te kunnen. Deze functie is vooral belangrijk wanneer er een aantal processen lopen die processortijd in beslag nemen. Het besturingssysteem zal een buffer instrueren om door te gaan met het ontvangen van invoer van het apparaat, maar om te stoppen met het zenden van gegevens naar de CPU terwijl het proces dat de invoer gebruikt wordt opgeschort. Vervolgens, wanneer het proces dat de invoer nodig heeft weer actief wordt gemaakt, zal het besturingssysteem de buffer opdracht geven gegevens te verzenden. Dit proces maakt het mogelijk dat een toetsenbord of een modem met hoge snelheid met externe gebruikers of computers kan omgaan, ook al zijn er tijden dat de CPU de invoer van die bronnen niet kan gebruiken.

Het beheer van alle bronnen van het computersysteem is een groot deel van de functie van het besturingssysteem en kan, in het geval van real-time besturingssystemen, vrijwel alle vereiste functionaliteit zijn. Voor andere besturingssystemen, echter, het verstrekken van een relatief eenvoudige, consistente manier voor toepassingen en mensen om de kracht van de hardware te gebruiken is een cruciaal onderdeel van hun reden van bestaan.

Interface naar de wereld

Applicatie-interface
Net zoals stuurprogramma’s een manier bieden voor applicaties om gebruik te maken van hardware-subsystemen zonder elk detail van de werking van de hardware te hoeven kennen, stellen applicatieprogramma-interfaces (API’s) applicatieprogrammeurs in staat functies van de computer en het besturingssysteem te gebruiken zonder direct alle details van de werking van de CPU te hoeven bijhouden. Laten we eens kijken naar het voorbeeld van het maken van een bestand op de harde schijf voor het bewaren van gegevens om te zien waarom dit belangrijk kan zijn.

Een programmeur die een toepassing schrijft om gegevens van een wetenschappelijk instrument vast te leggen, wil de wetenschapper wellicht in staat stellen de naam van het aangemaakte bestand op te geven. Het besturingssysteem biedt wellicht een API-functie met de naam MakeFile voor het maken van bestanden. Bij het schrijven van het programma zou de programmeur een regel invoegen die er als volgt uitziet:

MakeFile

In dit voorbeeld vertelt de instructie het besturingssysteem om een bestand te maken dat willekeurige toegang tot zijn gegevens toestaat (1), een naam heeft die door de gebruiker is ingevoerd (%Name), en een grootte heeft die varieert afhankelijk van hoeveel gegevens er in het bestand zijn opgeslagen (2). Laten we nu eens kijken wat het besturingssysteem doet om de instructie in actie om te zetten.

1. Het besturingssysteem stuurt een query naar de diskdrive om de locatie van de eerste beschikbare vrije opslaglocatie te achterhalen.
2. Met die informatie maakt het besturingssysteem een vermelding in het bestandssysteem met de begin- en eindlocaties van het bestand, de naam van het bestand, het bestandstype, of het bestand is gearchiveerd, welke gebruikers toestemming hebben om het bestand te bekijken of te wijzigen, en de datum en tijd waarop het bestand is gemaakt.
3. Het besturingssysteem schrijft aan het begin van het bestand informatie die het bestand identificeert, het type toegang instelt dat mogelijk is en andere informatie bevat die het bestand aan de toepassing bindt.

   In al deze informatie zijn de query’s naar de diskdrive en de adressen van het begin- en eindpunt van het bestand in formaten die sterk afhankelijk zijn van de fabrikant en het model van de diskdrive.

Omdat de programmeur haar programma heeft geschreven om de API voor schijfopslag te gebruiken, hoeft zij niet de instructiecodes, gegevenstypen en antwoordcodes voor elke mogelijke harde schijf en bandstation bij te houden. Het besturingssysteem, verbonden met drivers voor de verschillende hardware subsystemen, houdt zich bezig met de veranderende details van de hardware — de programmeur moet gewoon code schrijven voor de API en erop vertrouwen dat het besturingssysteem de rest doet.

API’s zijn in de afgelopen jaren een van de meest omstreden gebieden van de computerindustrie geworden. Bedrijven realiseren zich dat programmeurs die hun API gebruiken zich uiteindelijk zullen vertalen in de mogelijkheid om een bepaald deel van de industrie te controleren en er winst uit te halen. Dit is een van de redenen waarom zoveel bedrijven bereid zijn toepassingen zoals lezers of viewers gratis ter beschikking van het publiek te stellen. Zij weten dat de consumenten zullen vragen om programma’s die gebruik maken van de gratis uitleesapparaten, en dat de bedrijven die de toepassingen maken, bereid zullen zijn royalty’s te betalen om hun software in staat te stellen de door de consumenten gevraagde functies te bieden.

Gebruikersinterface
Net zoals de API een consistente manier biedt voor toepassingen om de middelen van het computersysteem te gebruiken, brengt een gebruikersinterface (UI) structuur aan in de interactie tussen een gebruiker en de computer. In het laatste decennium hebben bijna alle ontwikkelingen op het gebied van gebruikersinterfaces betrekking gehad op de grafische gebruikersinterface (GUI), waarbij twee modellen, Apple’s Macintosh en Microsoft’s Windows, de meeste aandacht hebben gekregen en het meeste marktaandeel hebben veroverd. Er zijn andere gebruikersinterfaces, sommige grafisch en andere niet, voor andere besturingssystemen.

Unix, bijvoorbeeld, heeft gebruikersinterfaces die shells worden genoemd en die een gebruikersinterface bieden die flexibeler en krachtiger is dan de standaard op tekst gebaseerde interface van het besturingssysteem. Programma’s als de Korn Shell en de C Shell zijn tekstgebaseerde interfaces die belangrijke hulpprogramma’s toevoegen, maar hun hoofddoel is het voor de gebruiker gemakkelijker te maken om de functies van het besturingssysteem te manipuleren. Er zijn ook grafische gebruikersinterfaces, zoals X-Windows en Gnome, die Unix en Linux vanuit het oogpunt van de gebruiker meer op Windows- en Macintosh-computers laten lijken.

Het is belangrijk te onthouden dat in al deze voorbeelden de gebruikersinterface een programma of een verzameling programma’s is die als een laag boven het besturingssysteem zelf zit. Hetzelfde geldt, met enigszins verschillende mechanismen, voor zowel Windows als Macintosh besturingssystemen. De kernfuncties van het besturingssysteem, het beheer van het computersysteem, bevinden zich in de kernel van het besturingssysteem. De display-manager staat daar los van, hoewel hij nauw verbonden kan zijn met de kernel eronder. De banden tussen de kernel van het besturingssysteem en de gebruikersinterface, hulpprogramma’s en andere software bepalen veel van de verschillen in besturingssystemen vandaag, en zullen ze verder bepalen in de toekomst.

De toekomst
Een vraag over de toekomst van besturingssystemen draait om het vermogen van een bepaalde filosofie van softwaredistributie om een besturingssysteem te maken dat door bedrijven en consumenten samen kan worden gebruikt.

Linux, het besturingssysteem dat is gemaakt en gedistribueerd volgens de principes van open source, zou een belangrijke invloed kunnen hebben op het besturingssysteem in het algemeen. De meeste besturingssystemen, stuurprogramma’s en hulpprogramma’s worden geschreven door commerciële organisaties die uitvoerbare versies van hun software distribueren — versies die niet kunnen worden bestudeerd of gewijzigd. Open source vereist de distributie van origineel bronmateriaal dat kan worden bestudeerd, gewijzigd en verder uitgebouwd, met de resultaten opnieuw vrij verspreid.

De voortdurende groei van het Internet en de proliferatie van computers die geen standaard desktop- of laptopmachines zijn, betekent dat besturingssystemen zullen veranderen om gelijke tred te houden, maar de kernfuncties voor beheer en interface zullen blijven bestaan, zelfs als ze evolueren.