programmera.net -> architecture -> normal     för utskrift      info@programmera.net

Unix, ett exempel på komponentbaserad arkitektur

1. Small is beautiful
2. Unix och komponentbaserad arkitektur
3. Hur kopplas programmen samman?
4. Komponenter som är oberoende av programmeringsspråk
5. Operativsystem och skräddarsydda program

1. Small is beautiful

I Unixvärlden används frasen "Small is Beautiful" frekvent. Med denna fras menas att ett litet program är bättre än ett stort. Frasen beskriver ganska bra den grundläggande strategin för de Unixliknande operativsystemen. Operativsystemen utnyttjar en uppsjö av små program (eller kommandon) som kombineras för att lösa större problem.

  • Vad räknas som litet? Ett litet program i Unix ska lösa en och endast en uppgift. Vanliga kommandon är till exemplel "sort" (som sorterar en textfil), "date" (som skriver ut dagens datum) eller ett något större program som "find" (som letar igenom hårddisken efter filer som uppfyller ett givet kriterium och anropar en givet kommando på dem). Trots att "find" är ett mycket komplext program inuti räknas det fortfarande som "litet" eftersom det löser ett specifikt och avgränsat problem.
Ett program som löser för många uppgifter och därför inte längre är "small and beautiful" kallas för "bloated" (uppsvälld).

2. Unix och komponentbaserad arkitektur

Jag tycker att Unix har kommit långt i sin strävan att bygga en komponentbaserad arkitektur, om man ser operativsystemets små program som komponenter. Vi går tillbaka till definitionen från sidan  komponentbaserad arkitektur :

  1. Sammanhängande inuti: Programmen i Unix löser ofta var sitt väl avgränsat problem.
  2. Oberoende av omgivningen: Många av programmen i Unix är helt oberoende av övriga program.
  3. Inkapsling: Varje litet program har ett väl definierat gränssnitt mot operativsystemet. De kan bara anropas av andra program genom att man skriver programmets namn och skickar in de nödvändiga parametrarna. Programmen läser från "standard input" och skriver till "standard output".
I och med den starka inkapslingen är det lätt att byta ut enskilda program om de skulle visa sig innehålla någon bugg.

3. Hur kopplas programmen samman?

Programmen kan kopplas samman för att lösa mer komplexa problem med hjälp av följande tekniker:

  1. Pipe: Programmen kan kopplas samman med "pipe" (|), ett kommando som läser input från "standard input" och skriver till "standard output". Genom att bygga långa kedjor av program som kopplas samman med "pipe" kan man få data att flöda mellan programmen som i ett långt rör. Varje program i "röret" förfinar datat så att när datat väl kommer ut ur "röret" är datat färdigbehandlat.
  2. Shellscript: Du kan också binda samman flera små program i ett shellscript. Ett shellscript är ett script där varje rad i scriptet exekveras som om en användare hade skrivit raden i prompten. Genom att köra scriptet kan du utföra många kommandon i ett svep.

4. Komponenter som är oberoende av programmeringsspråk

Om du till exempel vill använda en generell komponent i ett programmeringsspråk, säg Java, är det mycket lättare att utnyttja denna komponent om komponenten själv är skriven i Java! Om du vill använda en komponent skriven i till exempel Perl inifrån Java måste du använda ett "native"-anrop. Det som gör Unix komponentbaserade arkitektur så värdefull är att det inte spelar någon roll vilket programmeringsspråk komponenten är skriven i, alla program kan samverka med varandra eftersom de endast kommunicerar med text.

5. Operativsystem och skräddarsydda program

När ett system konstrueras kan man blanda små program som följer med operativsystemet med program som är skräddarsydda för systemet.

  • I Unix är det ingen riktig skillnad på ett program som följer med operativsystemet och ett som du har skrivit själv. Du kan lätt ersätta ett program i operativsystemet med en egen implementation eller lägga till nya program och på detta sätt bygga ditt "eget" Unix.