Linux är ett modernt operativsystem, men många av dess viktigaste idéer utvecklades redan under Unix-eran på 1960- och 1970-talen. Det hierarkiska filsystemet, processhanteringen, kommandopipelines och möjligheten att flytta systemet mellan olika datorarkitekturer är principer som fortfarande präglar dagens Linuxdistributioner. Att de lever kvar efter mer än 50 år beror framför allt på att de fortfarande är enkla, flexibla och användbara.
Linux brukar beskrivas som ett modernt operativsystem. Det används i allt från mobiltelefoner och persondatorer till superdatorer, webbservrar och inbyggda system. Trots detta bygger Linux på flera grundidéer som utvecklades redan under Unix barndom på 1960- och 1970-talen.
Många av idéerna var banbrytande när de introducerades. I dag är de så självklara att de flesta användare knappt tänker på dem. Här är några av de viktigaste Unix-principerna som fortfarande präglar moderna Linuxdistributioner.
Filsystemet är uppbyggt som ett träd
En av Unix viktigaste innovationer var det hierarkiska filsystemet. När forskarna bakom Unix beskrev systemet i artikeln The Unix Time-Sharing System år 1974 var idén om ett sammanhängande katalogträd fortfarande relativt ny.
I Linux börjar hela filsystemet i rotkatalogen:
Under rotkatalogen finns kataloger som exempelvis:
Dessa kan i sin tur innehålla fler kataloger och filer. Strukturen kan jämföras med ett träd där rotkatalogen är stammen och underkatalogerna är grenar.
Till skillnad från DOS och Windows använder Linux normalt inte enhetsbokstäver som C: eller D:. I stället monteras olika lagringsenheter på valfria platser i samma katalogträd.
En extern hårddisk kan exempelvis monteras under:
En nätverksresurs kan monteras under:
För användaren ser resurserna då ut som vanliga kataloger, även om de i verkligheten finns på olika hårddiskar, USB-minnen, servrar eller optiska skivor.
Detta gör Linux filsystem både flexibelt och enhetligt.
Flera processer kan köras samtidigt
Unix konstruerades från början som ett fleranvändar- och multitaskingsystem. Flera program kunde därför köras samtidigt, även när användarna arbetade via enkla textterminaler.
I Linux kallas ett program som körs för en process. Operativsystemet kan hantera tusentals processer samtidigt och fördela processortid och minne mellan dem.
I ett kommandoskal kan ett program startas i bakgrunden genom att lägga till tecknet &:
Skalet återgår då direkt till kommandoprompten medan programmet fortsätter att köras.
Om ett program redan körs i förgrunden kan det tillfälligt stoppas genom att trycka:
Därefter kan processen fortsätta i bakgrunden med kommandot:
Det går även att visa skalets aktuella jobb:
Och återföra ett bakgrundsjobb till förgrunden:
Denna typ av jobbkontroll utvecklades när textterminaler var vanligare än grafiska skrivbord. Funktionen är fortfarande användbar vid arbete via terminal, SSH eller på servrar utan grafiskt gränssnitt.
Små program kan kopplas ihop med pipelines
En av Unix mest inflytelserika idéer är att program ska vara små, göra en tydligt avgränsad uppgift och kunna kombineras med andra program.
Detta möjliggörs genom standardiserade kanaler för inmatning och utmatning:
- standard input, normalt tangentbordet
- standard output, normalt terminalen
- standard error, där felmeddelanden visas
Utmatningen från ett kommando kan sparas i en fil:
Kommandot ps aux visar systemets processer. Tecknet > skickar resultatet till filen allprocs.txt i stället för till skärmen.
En fil kan även användas som inmatning:
Ännu viktigare är pipeline-tecknet:
Det skickar utmatningen från ett kommando direkt till nästa kommando.
Ett enkelt exempel är:
Här skapar ps aux en lista över alla processer. Resultatet skickas till grep, som endast visar de rader som innehåller ordet firefox.
Ett mer lekfullt exempel är:
Programmet fortune skriver ut ett kort citat eller meddelande. Resultatet skickas sedan till lolcat, som visar texten i olika färger.
Pipeline-principen gör det möjligt att skapa avancerade arbetsflöden genom att kombinera enkla verktyg. I stället för att varje program måste innehålla alla funktioner kan användaren bygga en lösning av flera mindre delar.
C gjorde Unix flyttbart mellan olika datorer
Tidiga operativsystem skrevs ofta nästan helt i assembler. Assemblerkod arbetar nära datorns processor och kan vara mycket effektiv, men den är samtidigt starkt bunden till en viss processorarkitektur.
Ett program skrivet för en viss processor kunde därför inte utan vidare köras på en annan.
Unix skrevs till stor del om i programspråket C, som utvecklades av Dennis Ritchie vid Bell Labs. Detta var ett avgörande steg.
C är ett kompilerat högnivåspråk. Samma källkod kan i många fall kompileras för flera olika processorer, förutsatt att det finns en lämplig kompilator och att de maskinberoende delarna anpassas.
Det gjorde Unix betydligt lättare att flytta, eller porta, till nya datorsystem.
Samma grundidé gäller för Linux. Linuxkärnan och stora delar av operativsystemets grundläggande verktyg är skrivna i C. Därför kan Linux köras på många arkitekturer, bland annat:
- x86 och x86-64
- ARM
- RISC-V
- PowerPC
- MIPS
- IBM:s stordatorarkitekturer
Portabiliteten är en viktig förklaring till att Linux finns i så många typer av produkter, från små routrar till världens kraftfullaste superdatorer.
Användarna hjälper varandra
Unix utvecklades vid Bell Labs, som tillhörde det amerikanska telebolaget AT&T. På grund av dåtidens konkurrensregler hade företaget begränsade möjligheter att sälja Unix som en vanlig kommersiell produkt.
I stället distribuerades Unix till universitet och forskningsinstitutioner mot relativt låga avgifter. I många fall fick mottagarna även tillgång till källkoden.
Däremot följde inte alltid någon traditionell kundsupport med systemet. Användarna fick därför själva lösa problem, rätta fel och utveckla förbättringar.
Det växte fram användargrupper där forskare, studenter och systemadministratörer utbytte program, dokumentation och tekniska lösningar. En viktig organisation blev USENIX, som senare utvecklades till en betydande konferensorganisation inom datavetenskap.
Vid University of California, Berkeley utvecklades BSD, Berkeley Software Distribution. BSD blev en egen Unix-gren och kom att påverka många senare operativsystem.
Samma kultur lever kvar runt Linux. Supporten kommer ofta från flera olika håll:
- distributionsprojektens dokumentation
- webbforum
- e-postlistor
- lokala Linuxanvändargrupper
- IRC och chattkanaler
- webbplatser som Stack Exchange
- diskussionsforum och sociala medier
Linuxvärlden bygger fortfarande i stor utsträckning på att användare delar kunskap och hjälper varandra.
Unix började på en relativt liten dator
Linuxanvändare framhåller ofta att systemet kan ge äldre datorer ett nytt liv. Lätta Linuxdistributioner kan användas på maskiner som inte längre klarar moderna versioner av Windows.
Även detta har en historisk koppling till Unix.
Bell Labs hade tidigare deltagit i utvecklingen av Multics, ett mycket ambitiöst operativsystem som skulle erbjuda datorkraft som en samhällstjänst. Användare skulle kunna ansluta till centrala datorresurser ungefär på samma sätt som människor ansluter sig till el- eller telefonnätet.
Projektet blev dyrt och försenat, och Bell Labs drog sig ur samarbetet.
Ken Thompson och Dennis Ritchie började därefter utveckla ett mindre och enklare system. De använde en PDP-7 från Digital Equipment Corporation, en dator som redan då hade begränsade resurser jämfört med de stora stordatorsystemen.
Unix växte alltså fram ur tanken att skapa ett användbart system med mindre och enklare hårdvara.
På ett liknande sätt kan Linux i dag användas för att återbruka äldre datorer. En maskin som inte längre fungerar bra med ett tungt operativsystem kan fortfarande användas som exempelvis:
- enkel arbetsstation
- webbserver
- filserver
- internetradio
- informationsskärm
- brandvägg eller router
- retrospelsdator
- terminal för fjärranslutning
Det betyder inte att alla moderna Linuxdistributioner är resurssnåla. Fullständiga skrivbordsmiljöer kan kräva relativt mycket minne och processorkraft. Däremot ger Linux användaren stora möjligheter att välja ett lättare skrivbord eller helt avstå från ett grafiskt gränssnitt.
Unixfilosofin lever vidare
Linux är inte Unix, men det är ett Unix-liknande operativsystem. Många av dess viktigaste egenskaper kommer direkt eller indirekt från de idéer som utvecklades vid Bell Labs för mer än ett halvt sekel sedan.
Det hierarkiska filsystemet skapar en sammanhängande struktur för filer och enheter. Processmodellen gör det möjligt att köra många program samtidigt. Pipelines låter små verktyg samarbeta. Programspråket C gjorde systemen lättare att flytta mellan olika datorarkitekturer. Användargemenskaperna skapade en tradition av kunskapsdelning och gemensam utveckling.
Dessa idéer lever inte kvar enbart av nostalgiska skäl. De finns kvar eftersom de fortfarande fungerar.
Linux visar därmed att teknisk utveckling inte alltid innebär att allt gammalt måste ersättas. Ibland bygger framtidens system vidare på idéer som visade sig vara ovanligt hållbara.
> FAKTA: UNIX-IDÉER I LINUX
> Ursprung: Unix började utvecklas vid Bell Labs år 1969.
> Linux: Linuxkärnan skapades av Linus Torvalds och publicerades första gången 1991.
> Filsystem: Alla filer och lagringsenheter ingår i ett gemensamt katalogträd som börjar i rotkatalogen /.
> Processer: Linux kan köra många program och användarsessioner samtidigt.
> Pipelines: Tecknet | skickar resultatet från ett kommando vidare till ett annat.
> Programspråk: Linuxkärnan och många grundläggande systemverktyg är huvudsakligen skrivna i C.
> Arkitekturer: Linux kan köras på bland annat x86-64, ARM, RISC-V, PowerPC och stordatorer.
> Grundprincip: Små program ska göra en tydlig uppgift och kunna kombineras med andra program.
> Varför lever idéerna kvar? De är enkla, flexibla, portabla och fungerar fortfarande efter mer än 50 år.
