Att komma igång med Linux i Örebro

Av Thomas Padron-McCarthy (e-post: Thomas.Padron-McCarthy@tech.oru.se). Senaste ändring: 4 augusti 2004.

Den här handledningen är tänkt att ge en enkel introduktion till de nya Linux-datorerna i datorsalen T219. Den vänder sig till studenter som läser kurser vid Institutionen för teknikÖrebro universitet, och som inte tidigare använt Linux eller något annat Unix-system. Den förutsätter dock att läsaren har en del datorerfarenhet, särskilt från Windows-datorer.

Linux

Linux är ett operativsystem, som Windows 2000, dvs det grundprogram eller grundsystem som datorn kör, och som de andra programmen körs, som man brukar säga, "under". Linux är en variant av Unix, men utvecklat från grunden med helt egen källkod.

Att starta Linux och logga in

Datorerna har både Windows och Linux installerade, och man väljer vilket man vill köra när datorn startas.
  1. Om Linux inte redan är igång, så starta om maskinen, och välj sen Linux när du får välja mellan Windows och Linux.
  2. Linux startar med fönstersystem och allt. Mata in ditt vanliga Windows-loginnamn när datorn frågar efter användarnamn, och ditt vanliga lösenord när den frågar efter lösenordet.
Tänk på att Linux skiljer på stora och små bokstäver.

Likheter mellan Windows och Linux

Många har en föreställning om Unix som svåranvänt och bara för experter. Kryptiska kommandon skrivs in i ett textgränssnitt, och ger lika obegripliga svar från datorn. Lyssna till exempel på den här unixkursen (en MP3-fil).

Det är sant att Unix innehåller många verktyg som underlättar för experten, och som kräver att man läser en del i manualer innan man använder dem första gången, men moderna Unix-system, som Linux, är ganska lätta att använda även för nybörjaren. Man har arbetat mycket med att göra verktyg och fönstersystem som ska vara enkla att komma igång med.

Fönstersystemet är inte en del av operativsystemet i Linux, som det är i (nyare) Windows, utan om man vill kan man köra Linux i ett rent textläge. Men det finns flera olika fönstersystem till Linux, och nästan alla användare kör något av dem.

Här är ett exempel på hur skärmen kan se ut i Linux. Bilden är hämtad från datorerna i T219. (Klicka på bilden för att se den i stort format.)

hela-skarmen-halv

Det här är fönstersystemet KDE, som vi använder på Linux-datorerna här. Som synes påminner skärmen mycket om skrivbordet i Windows. Det finns ett antal ikoner längst ner till vänster, som man kan klicka på för att starta program. Det finns till och med en Start-meny, precis som i Windows, i nedre vänstra hörnet, fast den är märkt med ett K i ett kugghjul. Program som är igång syns också i listen nertill på skärmen.

En skillnad mot Windows-skrivbordet är att det finns flera olika virtuella skrivbord, som man kan välja mellan genom att klicka i rutorna med siffror mitt på den nedre listen.

I sin strävan att bli som Windows har KDE-programmerarna gjort en motsvarighet till Explorer i Windows, som heter Konqueror:

konqueror

Precis som i Windows fungerar Konqueror både för att bläddra bland lokala filer och för att titta på webbsidor:

konqueror-webb

Skillnader mellan Windows och Linux

En skillnad mellan Windows och Linux är att Linux har textgränssnitt som faktiskt går att använda. Windowsanvändare kallar ibland textgränssnittet för "DOS-prompt" (även i Windows NT och dess efterföljare, som inte innehåller något DOS), och vill gärna undvika det. Det är förståeligt, med tanke på hur dåliga textgränssnitt de olika Windows-smakerna har.

Unix har alltid haft kraftfulla textverktyg, så kallade skal, där man kan arbeta effektivt med hjälp av kommandon och egenskrivna programsnuttar. I den här handledningen ska vi bara titta på några av de enklaste kommandona.

I KDE får kan enklast ett skal genom att starta verktyget Konsole. (Ja, de stavar det så.) Klicka på ikonen i nederkanten av skärmen:

konsole-knapp

Ett skalfönster startas, och där kan man ge kommandon, till exempel ls som helt enkelt listar vilka filer som finns i aktuell katalog:

konsole

Några förklaringar:

Man skapar nya kataloger med mkdir och byter aktuell katalog med cd:

konsole-2

Filer och kataloger i Unix

I Windows är filerna uppdelade på flera olika enheter, C:, D: och så vidare. Under varje sådan enhet är alla filer samlade i ett träd.

I Unix finns bara ett enda träd av filer, som börjar i rotkatalogen. Den heter /. Diskar, cd-skivor, kataloger på servrar och allt annat stoppas in i trädet. Till exempel är det vanligt att användarnas hemkataloger ligger som underkataloger under katalogen home. I stället för till exempel M:\, som man kanske är van vid från Windows, heter hemkatalogen kanske /home/kajsa, om ens användarnamn råkar vara kajsa.

I Windows har alla filer normalt en ändelse, och vilken ändelse filen har avgör vad det är för typ av fil. Till exempel är filer som slutar på .exe körbara filer. I Unix behöver man inte ha filändelser, även om många enskilda verktyg tittar på ändelsen för att avgöra vad det är för fil.

Även fysiska enheter, som diskar, finns med i filträdet. Till exempel heter datorns huvudhårddisk ofta /dev/hda. Man kan alltså öppna hårddisken som vilken fil som helst, och läsa dess innehåll direkt. (Om man har läsrättigheter till den, vilket du förmodligen inte har.)

Att ange filnamn

Filnamn kan anges absolut, som till exempel /home/kajsa/foo, eller relativt till aktuell katalog. Om vi antar att aktuell katalog är /home, kan samma fil kallas kajsa/foo. Om aktuell katalog är /home/hjalmar, kan filen kallas ../kajsa/foo. Att namnet börjar med ett snedstreck, /, betyder alltså att filnamnet är absolut.

Linux skiljer på stora och små bokstäver i filnamn.

De flesta skal förstår jokertecken ("wildcards") i filnamn. Som vanligt betyder ? ett godtyckligt tecken, och * står för noll, ett eller flera godtyckliga tecken. Det fungerar som i Windows, men med fler möjligheter och mer konsekvent.

Haklamrar, som i [abcde], kan användas för att ange ett av flera tecken. Samma sak kan skrivas [a-e]. Fiskmåsklamrar kan användas för att ange alternativa delar av ett namn: {abc,de} betyder antingen abc eller de.

Tilde-tecknet, ~, som står för användarens hemkatalog. ~bengt står för användaren bengts hemkatalog.

Exempel: Om din hemkatalog heter /home/kajsa, så matchar mönstret ~/*/a*?.{c,cc} filerna /home/kajsa/koi/ax.c och /home/kajsa/C++/arbete.cc, men inte /home/kajsa/koi/labb1/ax.c eller /home/kajsa/koi/a.c.

De enklaste kommandona

Man kan sköta mycket av det dagliga arbetet i Linux via fönstersystemet och till exempel Konqueror, men här ska vi koncentrera oss på hur man ger kommandon i ett skalfönster.

Kommando Funktion Exempel
ls Lista filer ls
ls bilder
ls prog*.c
ls ~/prog*[1-4].{c,C,cpp,cc}
mv Byt namn på en fil mv gammal ny
mv prog1.c pro2.c katalogen
mv *.c c-programskatalogen
cp Kopiera filer cp program.c kopia.c
cp prog1.c prog2.c katalogen
cp *.c c-programskatalogen
cp -r Kopiera rekursivt cp -r en-katalog en-annan-katalog
rm Ta bort en eller flera filer rm foo
rm apa.txt foo blaj.c
rm /tmp/blaj.c
cd Byt aktuell katalog cd koi/labb2
cd /usr/local/bin
cd ..
mkdir Skapa en katalog mkdir min-nya-katalog
rmdir Ta bort en katalog rmdir koi
rmdir koi ../gammalt
cat Skriv ut en fil i skalfönstret cat foo
cat /etc/passwd
more Skriv ut en fil i skalfönstret en sida i taget more foo
more koi/*.c
exit Avsluta ett skal exit
man Titta på manualbladet för (exempelvis) ett kommando man rmdir
man -k time
alias Definiera nya kommandon alias ll='ls -l'
alias e='emacs'

Varning: Kommandot rm tar bort filer. Det flyttar dem inte till en papperskorg, utan det tar bort dem. "Bort" som i "borta för evigt". Man kan visserligen omdefiniera kommandon i Linux, och det är ganska vanligt att man omdefinierar just kommandot rm så att det flyttar filerna till en papperskorgskatalog. Men om ingen varit snäll och gjort det, så kan man inte få tillbaka en fil som man raderat.

Omdirigering av in- och utmatning

Man kan skicka utmatningen från ett program eller ett kommando till en fil med större-än-tecknet > och till ett annat program med pipe-tecknet |. Ett program eller ett kommando, som normalt läser från standardinmatningen, kan läsa sin inmatning från en fil om man använder mindre-än-tecknet <. Det fungerar som i Windows, men mer konsekvent.

Att kompilera, köra, editera och debugga program

Kompilering

C-kompilatorn heter gcc och C++-kompilatorn heter g++.

Bägge tar bland annat dessa flaggor:

Kommando Funktion Exempel
gcc Kompilera och länka C-program gcc -c foo.c
gcc -c -Wall foo.c
gcc -g foo.c fum.o fie.o -o foo
g++ Kompilera och länka C++-program g++ -c foo.cpp
g++ -c -Wall foo.cpp
g++ -g foo.cpp fum.o fie.o -o foo

Körning

Programmen körs genom att man skriver programnamnet i skalfönstret. (Av säkerhetsskäl är många Unix-system konfigurerade så att man måste skriva ./ före programnamnet om man vill köra ett program i den aktuella katalogen. Alltså ./foo i stället för bara foo, för att visa att man verkligen menar att köra ett program i den aktuella katalogen.)

metamatic-konsole-1

Editering

Det finns flera olika editorer att välja mellan. En editor som är populär bland många Unix-användare, men som kan vara lite besvärlig i början, är Emacs. Skriv kommandot
emacs filen.c &
för att börja editera filen filen.c. &-tecknet betyder att kommandot körs i bakgrunden, så man kan ge nya kommandon i skalfönstret. Program som öppnar sina egna fönster är det ofta praktiskt att göra så med.

Så här ser ett Emacs-fönster ut i vår KDE-omgivning. Emacs är känt för sina många korta kommandon, som till exempel CTRL-B för att flytta markören ett tecken bakåt, och ESCAPE b för att flytta markören ett ord bakåt, men som syns på bilden finns det även vanliga menyer (File, Edit och så vidare) som man kan klicka på.

metamatic-emacs.gif

En annan editor, som är mer i stil med Notepad, är KEdit. Starta den med kommandot kedit.

Debugging

Om man har kompilerat sitt program med flaggan -g, kan man köra det i debuggern gdb. Den har ett helt textbaserat gränssnitt, men finns också i en fönsterversion, och heter då xxgdb.

Personligen tycker jag att den textbaserade varianten är mycket enklare att arbeta med.

Men låt oss köra programmet metamatic i debuggern xxgdb. Vi startar debuggern från skalfönstret med kommandot xxgdb metamatic:

metamatic-konsole-2

Ett fönster som ser ut så här öppnas:

metamatic-xxgdb-1

I debuggern kan man stega fram programmet en rad i taget, och man kan titta på innehållet i variabler. Om programmet kraschar, visar debuggern på vilken rad det hände.

metamatic-xxgdb-2

Några tankar om fönster

De Windows-användare, inklusive Windows-programmerare, som jag kommer i kontakt med har en tendens att ha de flesta fönster maximerade, så de täcker hela skärmen. Det gör att de bara kan titta på en sak i taget. Om de till exempel ska titta på utskrifter i ett kommandofönster, och redigera programmet som gör utskrifterna, så får de växla fram och tillbaka mellan de två fönstren, för fönstret med programkoden i täcker hela skärmen. (Och när man klickar i det fönstret för att göra något, hoppar det fram och täcker kommandofönstret.)

Jag själv, och andra Unix-människor jag känner, har i stället massor med små fönster. Det kan vara ett fönster att editera i, ett fönster att köra programmet i, ett fönster för att läsa manualen i en webbläsare, och kanske ett kompileringsfönster. Varje fönster är bara så stort som det behöver vara, och eftersom alla får plats på skärmen behöver man sällan bläddra mellan fönstren.

Därför upplever jag det som frustrerande när jag ska kommunicera med någon Windows-person vid datorn, och hon ägnar den mesta tiden åt att bläddra bland sina (onödigt stora) fönster.

Jag tror att det kan finnas flera orsaker till den här vanan med maximerade fönster, bland annat att Windows-människor är vana vid integrerade system (som Visual Studio eller Borland Builder i stället för Emacs + xterm + gcc + gdb), vilket gör att de oftast inte har mer än ett fönster att hålla reda på.

Tänk på att det kan vara praktiskt att ha flera små fönster bredvid varandra på skärmen. I synnerhet när man programmerar.

Överkurs: make

Programmet make kan användas för att automatisera kompileringar. Genom att skriva en Makefile kan man styra vilka steg som ska köras.

Ett gott råd: Automatisera alltid så mycket som möjligt när du programmerar. Manuella steg, som till exempel att komma ihåg att köra bison eller byta namn på en fil, glömmer man förr eller senare alltid bort. Och sen sitter man där i sex timmar på natten och letar efter fel som inte finns.

Vi antar att vi har ett C-program, med källkoden i filen foo.c, som kan kompileras till den körbara filen foo. En enkel Makefile för detta kan se ut så här:

foo: foo.c
	gcc -g -Wall foo.c -o foo
(Notera att raden med gcc-kommandot måste börja med ett tab-tecken, inte med mellanslag!)

Detta betyder att vi kan skapa filen foo utgående från filen foo.c, genom att köra kommandot gcc -g -Wall foo.c -o foo. Filen foo är också beroende av filen foo.c, så om foo.c har ändrats sen foo skapades, så måste kommandot köras på nytt.

Om vi nu ger kommandot make, i katalogen där filerna foo.c och Makefile finns, så kommer kompileringen att köras:

mlbmnis@prog60:~/koi$ make foo
gcc -g -Wall foo.c -o foo
mlbmnis@prog60:~/koi$ 
Om vi skriver samma kommando en gång till direkt, utan att ha ändrat i filen foo.c, så är make tillräckligt smart för att inse att programmet inte behöver kompileras om:
mlbmnis@prog60:~/koi$ make foo
make: `foo' is up to date.
mlbmnis@prog60:~/koi$ 
Här är en lite mer avancerad Makefile:
# Makefile för debug-övningsuppgiften
# Skriv bara "make" för att kompilera programmet metamatic!

OFILES = metamatic.o a.o abc.o abscissa.o absurdum.o ack.o

CPPFLAGS += -g

metamatic: $(OFILES)
	g++ -g $(OFILES) -o metamatic

clean:
        rm -f $(OFILES) metamatic
Körexempel:
mlbmnis@prog60:~/koi$ make
g++  -g  -c -o metamatic.o metamatic.cc
g++  -g  -c -o a.o a.cpp
g++  -g  -c -o abc.o abc.cpp
g++  -g  -c -o abscissa.o abscissa.cpp
g++  -g  -c -o absurdum.o absurdum.cpp
g++  -g  -c -o ack.o ack.cpp
g++ -g metamatic.o a.o abc.o abscissa.o absurdum.o ack.o -o metamatic
mlbmnis@prog60:~/koi$ make clean
rm -f metamatic.o a.o abc.o abscissa.o absurdum.o ack.o metamatic
mlbmnis@prog60:~/koi$ 


Thomas Padron-McCarthy (Thomas.Padron-McCarthy@tech.oru.se)