Alai

Operativsystemet definierar vår datorupplevelse. Det är den första programvaran vi ser när vi slår på datorn och den sista programvaran vi ser när vi stänger av datorn. Det är den programvara som möjliggör alla de program vi använder. Operativsystemet organiserar och kontrollerar hårdvaran på våra skrivbord och i våra händer, men de flesta användare kan inte med säkerhet säga exakt vad det är som operativsystemet gör.

I det här numret av HowStuffWorks berättar vi vad en programvara måste göra för att kallas operativsystem, och visar hur operativsystemet fungerar för att förvandla en samling hårdvara till ett kraftfullt datorverktyg!

De enkla benen
Det är viktigt att inse att inte alla datorer har operativsystem. Datorn som styr mikrovågsugnen i ditt kök, till exempel, behöver inget operativsystem. Den har en uppsättning relativt enkla uppgifter att utföra, mycket enkla in- och utmatningsmetoder (en knappsats och en LCD-skärm) och enkel, aldrig föränderlig hårdvara att styra. För en sådan dator skulle ett operativsystem vara ett onödigt bagage, som skulle öka komplexiteten där det inte behövs. I stället kör datorn i en mikrovågsugn helt enkelt ett enda program hela tiden.

För datorsystem som är mer komplicerade än mikrovågsugnens kan dock ett operativsystem vara nyckeln till större driftseffektivitet och enklare programutveckling. Alla stationära datorer har operativsystem. De vanligaste är Windows-familjen av operativsystem, UNIX-familjen av operativsystem och Macintosh-operativsystemen. Det finns hundratals andra operativsystem tillgängliga för specialtillämpningar, inklusive specialiseringar för stordatorer, robotteknik, tillverkning, styrsystem i realtid och så vidare.

På den enklaste nivån gör ett operativsystem två saker:

• Det hanterar datorsystemets hård- och mjukvaruresurser. Dessa resurser omfattar sådant som processor, minne, diskutrymme osv.
• Det tillhandahåller ett stabilt och konsekvent sätt för program att hantera hårdvaran utan att behöva känna till alla detaljer om hårdvaran.

Den första uppgiften, att hantera hårdvaru- och programvaruresurserna, är mycket viktig, eftersom olika program och inmatningsmetoder konkurrerar om den centrala processorns (CPU) uppmärksamhet och kräver minne, lagringsutrymme och bandbredd för in- och utmatning (I/O) för sina egna syften. I denna egenskap spelar operativsystemet rollen som den goda föräldern och ser till att varje program får de nödvändiga resurserna samtidigt som det spelar snällt med alla andra program, samt att det förvaltar systemets begränsade kapacitet till största möjliga nytta för alla användare och program.

Den andra uppgiften, att tillhandahålla ett enhetligt programgränssnitt, är särskilt viktig om det kommer att finnas mer än en av en viss typ av dator som använder operativsystemet, eller om den hårdvara som datorn består av är öppen för förändringar. Ett konsekvent gränssnitt för tillämpningsprogram (API) gör det möjligt för en programutvecklare att skriva ett program på en dator och ha en hög grad av säkerhet om att det kommer att köras på en annan dator av samma typ, även om mängden minne eller lagringsutrymme skiljer sig åt på de två maskinerna. Även om en viss dator är unik kan ett operativsystem se till att programmen fortsätter att köras när uppgraderingar och uppdateringar av maskinvaran sker, eftersom det är operativsystemet och inte programmet som har till uppgift att hantera maskinvaran och fördelningen av dess resurser. Windows 98 är ett utmärkt exempel på den flexibilitet som ett operativsystem ger. Windows 98 kan köras på maskinvara från tusentals leverantörer. Det kan ta emot tusentals olika skrivare, diskettstationer och speciella kringutrustning i alla möjliga kombinationer.

Inom den breda familjen av operativsystem finns det i allmänhet fyra typer, som kategoriseras utifrån vilka typer av datorer de styr och vilken typ av program de stöder. De breda kategorierna är:

• Realtidsoperativsystem (RTOS) – Realtidsoperativsystem används för att styra maskiner, vetenskapliga instrument och industriella system. Ett RTOS har vanligtvis mycket små möjligheter till användargränssnitt och inga verktyg för slutanvändare, eftersom systemet är en ”förseglad låda” när det levereras för användning. En mycket viktig del av ett RTOS är att hantera datorns resurser så att en viss operation utförs på exakt samma tid varje gång den inträffar. I en komplex maskin kan det vara lika katastrofalt att en del rör sig snabbare bara för att systemresurser finns tillgängliga som att den inte rör sig alls för att systemet är upptaget.
• Enanvändare, en uppgift – Som namnet antyder är detta operativsystem utformat för att hantera datorn så att en användare effektivt kan göra en sak åt gången. Palm OS för Palm handdatorer är ett bra exempel på ett modernt operativsystem för en användare och en uppgift.
• Enanvändare med flera uppgifter – Detta är den typ av operativsystem som de flesta använder på sina stationära och bärbara datorer idag. Windows 98 och MacOS är båda exempel på ett operativsystem som låter en enskild användare ha flera program igång samtidigt. Det är till exempel fullt möjligt för en Windows-användare att skriva en anteckning i en ordbehandlare samtidigt som han laddar ner en fil från Internet och skriver ut texten i ett e-postmeddelande.
• Fleranvändare – Ett operativsystem för flera användare gör det möjligt för många olika användare att utnyttja datorns resurser samtidigt. Operativsystemet måste se till att de olika användarnas krav är balanserade och att vart och ett av de program som de använder har tillräckliga och separata resurser så att ett problem med en användare inte påverkar hela användarkollektivet. Unix, VMS och stordatoroperativsystem, t.ex. MVS, är exempel på fleranvändaroperativsystem.

Det är viktigt att här skilja mellan fleranvändaroperativsystem och enanvändaroperativsystem som stöder nätverk. Windows 2000 och Novell Netware kan var och en stödja hundratals eller tusentals användare i nätverk, men operativsystemen i sig är inte riktiga fleranvändaroperativsystem. Systemadministratören är den enda ”användaren” för Windows 2000 eller Netware. Nätverksstödet och alla fjärranvändarinloggningar som nätverket möjliggör är, i operativsystemets övergripande plan, ett program som körs av den administrativa användaren.

Med de olika typerna av operativsystem i åtanke är det dags att titta på de grundläggande funktioner som ett operativsystem tillhandahåller.

Väckarklocka
När strömmen till en dator slås på är det första programmet som körs vanligtvis en uppsättning instruktioner som förvaras i datorns ROM-minne (read-only memory) och som undersöker systemets maskinvara för att se till att allt fungerar som det ska. Detta POST-test (power-on self test) kontrollerar processorn, minnet och BIOS (basic input-output systems) för fel och lagrar resultatet på en särskild minnesplats. När POST har slutförts framgångsrikt börjar den programvara som finns inläst i ROM (ibland kallad firmware) att aktivera datorns diskstationer. I de flesta moderna datorer hittar datorn när den aktiverar hårddisken den första delen av operativsystemet: bootstrap-loadern.

Bootstrap loader är ett litet program som har en enda funktion: Det laddar in operativsystemet i minnet och låter det börja fungera. I den mest grundläggande formen ställer bootstrap loader in de små drivrutinsprogrammen som fungerar som gränssnitt mot och kontrollerar datorns olika hårdvarusubsystem. Den ställer in de delar av minnet som innehåller operativsystemet, användarinformation och program. Den upprättar de datastrukturer som kommer att innehålla de otaliga signaler, flaggor och semaforer som används för att kommunicera inom och mellan datorns delsystem och tillämpningar. Därefter överlåts kontrollen över datorn till operativsystemet.

Operativsystemets uppgifter, i den mest allmänna bemärkelsen, kan delas in i sex kategorier:

• Processorhantering
• Minneshantering
• Enhetshantering
• Lagringshantering
• Applikationsgränssnitt
• Användargränssnitt

Men det finns de som hävdar att ett operativsystem bör göra mer än dessa sex uppgifter, och vissa operativsystemleverantörer bygger in många fler hjälpprogram och hjälpfunktioner i sina operativsystem, men dessa sex uppgifter utgör kärnan i nästan alla operativsystem. Låt oss titta på de verktyg som operativsystemet använder för att utföra var och en av dessa funktioner.

Processorhantering
Kärnan i hanteringen av processorn handlar om två relaterade frågor:

• Säkerställa att varje process och program får tillräckligt mycket av processorns tid för att fungera korrekt
• Använda så många processorcykler för verkligt arbete som möjligt

Den grundläggande programvaruenhet som operativsystemet hanterar när det gäller att schemalägga processorns arbete är antingen en process eller en tråd, beroende på operativsystemet.

Det är frestande att tänka på en process som ett program, men det ger en ofullständig bild av hur processer förhåller sig till operativsystemet och maskinvaran. Det program du ser (ordbehandlingsprogram eller kalkylblad eller spel) är förvisso en process, men det programmet kan orsaka att flera andra processer startar, för uppgifter som kommunikation med andra enheter eller andra datorer. Det finns också många processer som körs utan att ge dig direkta bevis på att de existerar. En process är alltså en programvara som utför någon åtgärd och som kan styras – av en användare, av andra program eller av operativsystemet.

Det är processer, snarare än program, som operativsystemet kontrollerar och schemalägger för att köras av processorn. I ett system med en enda uppgift är schemat okomplicerat. Operativsystemet låter programmet börja köras och avbryter utförandet endast tillräckligt länge för att hantera avbrott och användarinmatning. Avbrott är särskilda signaler som skickas av maskinvara eller programvara till processorn. Det är som om någon del av datorn plötsligt räckte upp handen för att be om processorns uppmärksamhet i ett livligt möte. Ibland schemalägger operativsystemet prioriteringen av processer så att avbrotten maskeras – det vill säga operativsystemet ignorerar avbrotten från vissa källor så att ett visst arbete kan slutföras så snabbt som möjligt. Det finns vissa avbrott (t.ex. från feltillstånd eller problem med minnet) som är så viktiga att de inte kan ignoreras. Dessa icke-maskningsbara avbrott (NMI) måste hanteras omedelbart, oavsett vilka andra uppgifter som är aktuella.

Men även om avbrott komplicerar utförandet av processer i ett system med en enda uppgift blir operativsystemets uppgift mycket mer komplicerad i ett system med flera uppgifter. Nu måste operativsystemet ordna utförandet av programmen så att du tror att det är flera saker som händer samtidigt. Detta är komplicerat eftersom processorn bara kan göra en sak åt gången. För att ge sken av att många saker händer samtidigt måste operativsystemet växla mellan olika processer tusentals gånger per sekund. Så här går det till.

• En process upptar en viss mängd RAM-minne. Den använder sig också av register, staplar och köer i processorns och operativsystemets minnesutrymme.
• När två processer utför flera uppgifter tilldelar operativsystemet ett visst antal exekveringscykler i CPU:n till ett program.
• Efter detta antal cykler gör operativsystemet kopior av alla register, staplar och köer som används av processerna och noterar den punkt där processen gjorde en paus i sitt utförande.
• Det laddar sedan alla register, staplar och köer som används av den andra processen och ger den ett visst antal CPU-cykler.
• När dessa är klara gör den kopior av alla register, staplar och köer som används av det andra programmet och laddar det första programmet.

Alla den information som behövs för att hålla reda på en process vid växling hålls i ett datapaket som kallas processkontrollblock. Processkontrollblocket innehåller vanligtvis följande:

• Ett ID-nummer som identifierar processen
• Poäng till de platser i programmet och dess data där bearbetningen senast ägde rum
• Registerinnehåll
• Status för olika flaggor och växlar
• Poäng till det övre. och nedre gränserna för det minne som krävs för processen
• En lista över filer som öppnats av processen
• Processens prioritet
• Statusen för alla I/O-enheter som behövs av processen

När processens status ändras, från väntande till aktiv, till exempel, eller från avbruten till pågående, måste informationen i processkontrollblocket användas på samma sätt som uppgifterna i vilket annat program som helst för att styra utförandet av den uppgiftsväxlande delen av operativsystemet.

Detta processbyte sker utan direkt inblandning av användaren, och varje process får tillräckligt med CPU-cykler för att utföra sin uppgift inom rimlig tid. Problem kan dock uppstå om användaren försöker få för många processer att fungera samtidigt. Själva operativsystemet kräver en del CPU-cykler för att utföra sparandet och bytet av alla register, köer och staplar för tillämpningsprocesserna. Om tillräckligt många processer startas, och om operativsystemet inte har utformats omsorgsfullt, kan systemet börja använda den stora majoriteten av sina tillgängliga CPU-cykler till att byta mellan processer i stället för att köra processer. När detta händer kallas det för thrashing, och det kräver vanligtvis någon form av direkt ingripande från användarens sida för att stoppa processerna och återställa ordningen i systemet.

Ett sätt för konstruktörer av operativsystem att minska risken för thrashing är att minska behovet av nya processer för att utföra olika uppgifter. Vissa operativsystem tillåter en ”process-lite”, en så kallad tråd, som kan ta hand om allt CPU-intensivt arbete som en normal process, men som i allmänhet inte tar hand om de olika typerna av I/O och som inte upprättar strukturer som kräver det omfattande processkontrollblock som en vanlig process kräver. En process kan starta många trådar eller andra processer, men en tråd kan inte starta en process.

Hostills har all schemaläggning som vi har diskuterat gällt en enda CPU. I ett system med två eller flera CPU:er måste operativsystemet fördela arbetsbelastningen mellan CPU:erna och försöka balansera kraven från de nödvändiga processerna med de tillgängliga cyklerna på de olika CPU:erna. Asymmetriska operativsystem använder en CPU för sina egna behov och fördelar tillämpningsprocesserna på de återstående CPU:erna. Symmetriska operativsystem delar upp sig själva på de olika CPU:erna och balanserar efterfrågan mot tillgången på CPU:er även när operativsystemet självt är det enda som körs.

Även om operativsystemet är den enda programvaran med exekveringsbehov är CPU:n inte den enda resursen som ska schemaläggas. Minneshantering är nästa avgörande steg för att se till att alla processer löper smidigt.

Hantering av minne och lagring
När ett operativsystem hanterar datorns minne finns det två breda uppgifter att utföra:

• Varje process måste ha tillräckligt med minne för att kunna utföras, och den får varken köra in i en annan process minnesutrymme eller bli körd in av en annan process.
• De olika typerna av minne i systemet måste användas på rätt sätt så att varje process kan köras så effektivt som möjligt.

Den första uppgiften kräver att operativsystemet sätter upp minnesgränser för typer av programvara och för enskilda program.

Som exempel kan vi titta på ett tänkt system med 1 megabyte (1 000 kilobyte) RAM-minne. Under uppstartsprocessen är operativsystemet i vår imaginära dator konstruerat för att gå till toppen av det tillgängliga minnet och sedan ”backa tillbaka” tillräckligt långt för att tillgodose behoven hos själva operativsystemet. Låt oss säga att operativsystemet behöver 300 kilobyte för att fungera. Nu går operativsystemet till botten av RAM-minnet och börjar bygga upp de olika drivrutiner som krävs för att styra datorns hårdvarusubsystem. I vår imaginära dator tar drivrutinerna upp 200 kilobyte. När operativsystemet är helt laddat finns det alltså 500 kilobyte kvar för programprocesser.

När programmen börjar laddas in i minnet laddas de i blockstorlekar som bestäms av operativsystemet. Om blockstorleken är 2 kilobyte kommer varje process som laddas att få en del av minnet som är en multipel av 2 kilobyte i storlek. Programmen laddas i dessa fasta blockstorlekar, där blocken börjar och slutar på gränser som fastställs av ord på 4 eller 8 byte. Dessa block och gränser bidrar till att säkerställa att programmen inte laddas ovanpå varandras utrymme på grund av en dåligt beräknad bit eller två. När detta är säkerställt är den större frågan vad man skall göra när programutrymmet på 500 kilobyte är fyllt.

I de flesta datorer är det möjligt att lägga till minne utöver den ursprungliga kapaciteten. Du kan till exempel utöka RAM-minnet från 1 till 2 megabyte. Detta fungerar bra, men tenderar att bli relativt dyrt. Det ignorerar också ett grundläggande faktum inom databehandling – den mesta av den information som ett program lagrar i minnet används inte vid varje given tidpunkt. En processor kan bara komma åt minnet en plats åt gången, så den stora majoriteten av RAM-minnet är oanvänt vid varje tillfälle. Eftersom diskutrymme är billigt jämfört med RAM, kan man genom att flytta information från RAM till hårddisk kraftigt utöka RAM-utrymmet utan kostnad. Denna teknik kallas virtuell minneshantering.

Disklagring är bara en av de minnestyper som måste hanteras av operativsystemet, och är den långsammaste. I rangordning efter hastighet är minnestyperna i ett datorsystem följande:

• Höghastighetscache – Detta är snabba, relativt små mängder minne som är tillgängliga för processorn via de snabbaste anslutningarna. Cachekontrollanter förutspår vilka datamängder som CPU:n kommer att behöva härnäst och hämtar dem från huvudminnet till höghastighetscachen för att påskynda systemets prestanda.
• Huvudminne – Detta är det RAM-minne som du ser mätt i megabyte när du köper en dator.
• Sekundärminne – Detta är oftast någon form av roterande magnetisk lagring som håller program och data tillgängliga för att användas och fungerar som virtuellt RAM-minne under styrning av operativsystemet.

Operativsystemet måste balansera de olika processernas behov med tillgången på de olika typerna av minne och flytta data i block (så kallade sidor) mellan tillgängligt minne när processernas schema kräver det.

Enhetshantering
Vägen mellan operativsystemet och praktiskt taget all maskinvara som inte finns på datorns moderkort går via ett särskilt program som kallas drivrutin. En stor del av en drivrutins funktion är att vara översättare mellan de elektriska signalerna från maskinvarans delsystem och högnivåprogrammeringsspråken i operativsystemet och tillämpningsprogrammen. Drivrutiner tar data som operativsystemet har definierat som en fil och översätter dem till strömmar av bitar som placeras på specifika platser på lagringsenheter, eller en serie laserpulser i en skrivare.

Då det finns så stora skillnader i den hårdvara som styrs genom drivrutiner finns det skillnader i hur drivrutinsprogrammen fungerar, men de flesta körs när enheten behövs och fungerar i stort sett på samma sätt som alla andra processer. Operativsystemet tilldelar ofta högprioriterade block till drivrutiner så att hårdvaruresursen kan frigöras och göras redo för vidare användning så snabbt som möjligt.

En anledning till att drivrutiner är skilda från operativsystemet är att nya funktioner kan läggas till i drivrutinen – och därmed i maskinvarusubsystemen – utan att själva operativsystemet behöver ändras, kompileras om och distribueras på nytt. Genom utveckling av nya drivrutiner för hårdvaruenheter, en utveckling som ofta utförs eller betalas av tillverkaren av delsystemen snarare än av utgivaren av operativsystemet, kan det övergripande systemets in- och utmatningsmöjligheter förbättras avsevärt.

Hanteringen av in- och utdata handlar till stor del om att hantera köer och buffertar, särskilda lagringsutrymmen som tar emot en ström av bitar från en enhet, kanske ett tangentbord eller en seriell port, håller kvar dessa bitar och släpper dem till processorn i en takt som är tillräckligt långsam för att processorn skall kunna hantera dem. Denna funktion är särskilt viktig när ett antal processer pågår och tar upp processortid. Operativsystemet kommer att instruera en buffert att fortsätta att ta emot inmatning från enheten, men att sluta skicka data till CPU:n medan den process som använder inmatningen är avbruten. När den process som behöver indata sedan återigen blir aktiv kommer operativsystemet att beordra bufferten att skicka data. Denna process gör det möjligt för ett tangentbord eller ett modem att hantera externa användare eller datorer med hög hastighet även om det finns tillfällen då processorn inte kan använda indata från dessa källor.

Hanteringen av datorsystemets alla resurser är en stor del av operativsystemets funktion och kan, när det gäller realtidsoperativsystem, vara praktiskt taget all funktionalitet som krävs. För andra operativsystem är dock tillhandahållandet av ett relativt enkelt och konsekvent sätt för program och människor att använda maskinvarans kraft en avgörande del av deras existensberättigande.

Gränssnitt mot världen

Användningsgränssnitt
På samma sätt som drivrutiner ger program ett sätt för program att använda maskinvarans delsystem utan att behöva känna till varje detalj i maskinvarans funktion, låter gränssnitt för tillämpningsprogram (API) tillämpningsprogrammerare använda datorens och operativsystemets funktioner utan att direkt behöva hålla reda på alla detaljer i CPU:ns funktion. Låt oss titta på exemplet med att skapa en hårddiskfil för att lagra data för att se varför detta kan vara viktigt.

En programmerare som skriver ett program för att spela in data från ett vetenskapligt instrument kanske vill låta forskaren ange namnet på den skapade filen. Operativsystemet kan tillhandahålla en API-funktion som heter MakeFile för att skapa filer. När programmeraren skriver programmet skulle han eller hon infoga en rad som ser ut så här:

MakeFile

I det här exemplet talar instruktionen om för operativsystemet att skapa en fil som kommer att tillåta slumpmässig åtkomst till sina data (1), som kommer att ha ett namn som skrivs in av användaren (%Name) och som kommer att ha en storlek som varierar beroende på hur mycket data som lagras i filen (2). Låt oss nu titta på vad operativsystemet gör för att omsätta instruktionen i handling.

1. Operativsystemet skickar en förfrågan till diskenheten för att få fram platsen för den första tillgängliga fria lagringsplatsen.
2. Med den informationen skapar operativsystemet en post i filsystemet som visar filens start- och slutplats, filens namn, filtyp, om filen har arkiverats, vilka användare som har behörighet att titta på eller ändra filen samt datum och tid för filens skapande.
3. Operativsystemet skriver information i början av filen som identifierar filen, fastställer vilken typ av åtkomst som är möjlig och innehåller annan information som binder filen till programmet.

   I all denna information är förfrågningarna till diskenheten och adresserna till filens början och slutpunkt i format som är starkt beroende av diskenhetens tillverkare och modell.

Då programmeraren har skrivit sitt program så att det använder API:et för skivlagring behöver hon inte hålla reda på instruktionskoderna, datatyperna och svarskoderna för alla möjliga hårddiskar och bandstationer. Operativsystemet, som är kopplat till drivrutiner för de olika maskinvarusubsystemen, tar hand om de skiftande detaljerna i maskinvaran — programmeraren måste helt enkelt skriva kod för API:et och lita på att operativsystemet sköter resten.

API:er har under de senaste åren blivit ett av de mest omtvistade områdena inom dataindustrin. Företagen inser att programmerare som använder deras API i slutändan kommer att översättas till möjligheten att kontrollera och tjäna pengar på en viss del av industrin. Detta är en av anledningarna till att så många företag har varit villiga att tillhandahålla program som läsare eller tittare till allmänheten utan kostnad. De vet att konsumenterna kommer att begära att programmen ska dra nytta av de kostnadsfria läsarna, och applikationsföretagen kommer att vara beredda att betala royalties för att deras programvara ska kunna tillhandahålla de funktioner som konsumenterna efterfrågar.

Användargränssnitt
På samma sätt som API:et ger programmen ett konsekvent sätt att använda datorsystemets resurser, ger användargränssnittet struktur åt interaktionen mellan användaren och datorn. Under det senaste decenniet har nästan all utveckling av användargränssnitt skett inom området grafiskt användargränssnitt (GUI), med två modeller, Apples Macintosh och Microsofts Windows, som fått den största uppmärksamheten och vunnit de flesta marknadsandelarna. Det finns andra användargränssnitt, vissa grafiska och andra inte, för andra operativsystem.

Unix, till exempel, har användargränssnitt som kallas shells och som erbjuder ett mer flexibelt och kraftfullt användargränssnitt än det textbaserade standardgränssnittet i operativsystemet. Program som Korn Shell och C Shell är textbaserade gränssnitt som lägger till viktiga verktyg, men deras huvudsyfte är att göra det lättare för användaren att manipulera operativsystemets funktioner. Det finns också grafiska användargränssnitt, som X-Windows och Gnome, som gör Unix och Linux mer lika Windows- och Macintosh-datorer ur användarens synvinkel.

Det är viktigt att komma ihåg att i alla dessa exempel är användargränssnittet ett program eller en uppsättning program som ligger som ett lager ovanför själva operativsystemet. Samma sak gäller, med något olika mekanismer, för både Windows- och Macintosh-operativsystemen. Operativsystemets kärnfunktioner, dvs. hanteringen av datorsystemet, ligger i operativsystemets kärna. Displayhanteraren är separat, även om den kan vara nära knuten till kärnan under den. Kopplingarna mellan operativsystemets kärna och användargränssnittet, verktyg och annan programvara definierar många av skillnaderna mellan operativsystemen i dag och kommer att definiera dem ytterligare i framtiden.

Framtiden
En fråga om operativsystemens framtid kretsar kring förmågan hos en viss filosofi för programvarudistribution att skapa ett operativsystem som kan användas av företag och konsumenter tillsammans.

Linux, det operativsystem som skapats och distribuerats enligt principerna för öppen källkod, skulle kunna få en betydande inverkan på operativsystemet i allmänhet. De flesta operativsystem, drivrutiner och hjälpprogram skrivs av kommersiella organisationer som distribuerar körbara versioner av sin programvara – versioner som inte kan studeras eller ändras. Öppen källkod kräver distribution av originalkällmaterial som kan studeras, ändras och byggas vidare på, och resultaten kan återigen distribueras fritt.

Den fortsatta tillväxten av Internet och spridningen av datorer som inte är vanliga stationära eller bärbara datorer innebär att operativsystemen kommer att förändras för att hålla jämna steg, men de centrala förvaltnings- och gränssnittsfunktionerna kommer att fortsätta, även om de utvecklas.