<chapter id="shell2-chapter"><title>Werken met &unix;</title>

<blockquote>
<literallayout>

A UNIX saleslady, Lenore, 
Enjoys work, but she likes the beach more. 
       She found a good way 
       To combine work and play: 
She sells C shells by the seashore. 

</literallayout>
</blockquote>

<para>
<indexterm><primary>bestand</primary></indexterm>
<indexterm><primary>C-shell</primary></indexterm>
<!-- \glossary{Bourne shell}\glossary{invoer}\glossary{uitvoer} -->
&unix; is een krachtig systeem voor degenen die weten hoe zijn kracht 
te benutten. In dit hoofdstuk zal ik diverse manieren proberen om 
&unix;'s shell, <application>bash</application>
<indexterm><primary>bash</primary></indexterm> effici&euml;nter te gebruiken.
</para>

<sect1 id="jokertekens"><title>Jokertekens</title>
<indexterm><primary>shell</primary>
<secondary>jokertekens</secondary></indexterm>
<indexterm><primary>shell</primary><secondary>globbing</secondary>
<see>shell, jokertekens</see></indexterm>
<indexterm><primary>jokertekens</primary>
<see>shell, jokertekens</see></indexterm>

<para>
Met betrekking tot bestandsbeheer leerde je in het vorige hoofdstuk 
over de opdrachten <command>cp</command>, <command>mv</command> en
<command>rm</command>. Zo nu en dan wil je iets met meer dan 
&eacute;&eacute;n bestand tegelijkertijd doen. Wellicht dat je 
in &eacute;&eacute;n keer een bewerking uit wilt voeren op meerdere bestanden.
Je wilt bijvoorbeeld misschien wel alle
bestanden beginnend met <filename>data</filename> kopi&euml;ren naar 
een directory genaamd <filename>~/backup</filename>. Je kunt dit doen 
door heel wat keren de opdracht <command>cp</command> uit te voeren, 
of je zou elk bestand op een opdrachtregel kunnen benoemen. Deze methoden
nemen echter beiden veel tijd in beslag en de kans is groot dat je fouten maakt.
Een betere manier om een dergelijke taak uit te voeren is door het
intikken van:
</para>

<para>
<screen>
<prompt>/home/larry/report# </prompt><userinput>ls -F</userinput>
<computeroutput>1993-1          1994-1          data1           data5
1993-2          data-new        data2
</computeroutput>
<prompt>/home/larry/report# </prompt><userinput>mkdir ~/backup</userinput>
<prompt>/home/larry/report# </prompt><userinput>cp data* ~/backup</userinput>
<prompt>/home/larry/report# </prompt><userinput>ls -F ~/backup</userinput>
<computeroutput>
data-new        data1           data2           data5
</computeroutput>
<prompt>/home/larry/report# </prompt>
</screen>
</para>

<para>
Zoals je kunt zien, werd met de asterisk aan <command>cp</command>
aangegeven, dat het alle bestanden beginnend met <parameter>data</parameter>
moest nemen en deze bestanden moesten naar <filename>~/backup</filename>
worden gekopieerd. Kun je raden wat <command>cp d*w ~/backup</command> zou 
hebben gedaan?
</para>
</sect1>

<sect1 id="whathappens">
<title>Wat gebeurt er nu <emphasis>echt</emphasis>?</title>
<para>
Goede vraag. Er worden door de shell <application>bash</application>
een paar tekens onderschept. De asterix (<literal>*</literal>), geeft aan 
dit woord door alle bestanden die in deze specificatie passen te vervangen.
Dus de opdracht <command>cp data* ~/backup</command>, zoals die hierboven, 
wordt gewijzigd in <command>cp data-new data1 data2 data5 ~/backup</command> 
voordat deze wordt uitgevoerd. Laat me dit illustreren door een nieuwe 
opdracht te introduceren, namelijk <command>echo</command>.
<indexterm><primary>echo</primary></indexterm>
<command>echo</command> is een uiterst simpele
opdracht; het weerkaatst, of drukt enige parameters af. Dus:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>echo Hallo!</userinput>
<computeroutput>Hallo!</computeroutput>
<prompt>/home/larry# </prompt><userinput>echo Hoe gaat het met je?</userinput>
<computeroutput>Hoe gaat het met je?</computeroutput>
<prompt>/home/larry# </prompt><userinput>cd report</userinput>
<prompt>/home/larry/report# </prompt><userinput> ls -F</userinput>
<computeroutput>
1993-1          1994-1          data1           data5
1993-2          data-new        data2</computeroutput>
<prompt>/home/larry/report# </prompt><userinput>echo 199*</userinput>
<computeroutput>1993-1 1993-2 1994-1</computeroutput>
<prompt>/home/larry/report# </prompt><userinput>echo *4*</userinput>
<computeroutput>1994-1</computeroutput>
<prompt>/home/larry/report# </prompt><userinput>echo *2*</userinput>
<computeroutput>1993-2 data2</computeroutput>
<prompt>/home/larry/report# </prompt>
</screen>
</para>
<para>
Zoals je kunt zien, breidt de shell het jokerteken uit en geeft het alle
bestanden door aan het programma dat je het vertelt het uit te voeren.
Wat gebeurt er als er <emphasis>geen</emphasis> bestanden zijn die 
tegemoet komen aan de jokertekenspecificatie? Probeer eens 
<command>echo /rc/fr*og</command> en je zult zien dat
<application>bash</application><indexterm><primary>bash</primary></indexterm>
de jokertekenspecificatie letterlijk doorgeeft aan het programma.
Andere shells, zoals <application>tcsh</application>
<indexterm><primary>tcsh</primary></indexterm>
zullen in plaats van het letterlijk doorgeven van het jokerteken, antwoorden 
met "<errorname>No match</errorname>". Hier wordt dezelfde opdracht 
uitgevoerd onder <application>tcsh</application>:
</para>

<para>
<screen>
<prompt>mousehouse> </prompt><userinput>echo /rc/fr*og</userinput>
<computeroutput>echo: No match.</computeroutput>
<prompt>mousehouse> </prompt>
</screen>
</para>

<para>
Het laatste wat je nu misschien nog zou willen weten is hoe je
<filename>data*</filename> zelf teruggekaatst krijgt in plaats van dat 
het de lijst met bestandsnamen retourneert? Onder zowel 
<application>bash</application> als <application>tcsh</application> plaats 
je de tekenreeks dan gewoon tussen aanhalingstekens:
</para>

<para>
<screen>
<prompt>/home/larry/report# </prompt><userinput>echo "data*"</userinput>
<computeroutput>data*</computeroutput>
<prompt>/home/larry/report# </prompt>
</screen>
</para>

<para>OF</para>

<para>
<screen>
<prompt>mousehouse> </prompt><userinput>echo "data*"</userinput>
<computeroutput>data*</computeroutput>
<prompt>mousehouse> </prompt>
</screen>
</para>

<sect2 id="questionmark"><title>Het vraagteken</title>
<para>
Behalve de asterix, interpreteert de shell ook een vraagteken als
speciaal teken. Een vraagteken komt overeen met &eacute;&eacute;n, maar dan
ook slechts &eacute;&eacute;n teken. <command>ls /etc/??</command> 
bijvoorbeeld zal 
alle tweeletterige bestanden in de <filename>/etc</filename>
directory weergeven.
</para>
</sect2>
</sect1>
<!-- \eindex{shell!jokertekens} -->

<sect1 id="command-line-edit">
<title>Tijd besparen met <application>Bash</application></title>
<indexterm><primary>opdrachtregelbewerking</primary><see>shell, bewerken</see>
</indexterm>

<sect2><title>Opdrachtregelbewerking</title>
<indexterm><primary>shell</primary>
<secondary>bewerken</secondary></indexterm>
<para>
Zo nu en dan typ je een lange opdracht onder <application>bash</application>
<!-- \ttindex{bash} --> en,
nog voor je de return-toets indrukt, zie je dat je aan het begin van de
regel een spelfout hebt gemaakt.
Je zou het vanaf het begin kunnen verwijderen en alles wat nodig is weer 
opnieuw in kunnen tikken, maar dat is wel erg veel moeite! In plaats daarvan 
kun je de pijltjestoetsen gebruiken om terug te gaan, de &eacute;&eacute;n of
twee misgetypte tekens verwijderen om vervolgens de juiste informatie in
te tikken.
</para>

<para>
Er bestaan diverse speciale toetsen om je te helpen bij het bewerken van
de opdrachtregel, waarvan de meesten vergelijkbaar zijn met de opdrachten 
die worden gebruikt in GNU Emacs.
<indexterm><primary>GNU Emacs</primary></indexterm>
Met bijvoorbeeld
<keycap>C-t</keycap> verwissel je twee achtereenvolgende tekens<footnote><para>
<keycap>C-t</keycap> betekent het vasthouden van de toets met het label 
"Ctrl", om vervolgens de toets "t" in te drukken. 
Laat vervolgens de "Ctrl"-toets weer los.</para></footnote>
De meeste opdrachten zul je terug kunnen vinden in het hoofdstuk over
emacs in hoofdstuk <xref linkend="emacs-chapter"/>.
</para>
</sect2>

<!-- \eindex{shell!bewerken} -->

<sect2><title>Opdracht- en bestandsvoltooiing</title>
<indexterm><primary>shell</primary>
<secondary>voltooiing</secondary></indexterm>
<!-- \bindex shell!voltooiing -->
<para>
Een andere feature van <application>bash</application><!-- \ttindex{bash} -->
is de automatische
voltooiing van je opdrachtregels. Laten we als voorbeeld eens kijken
naar het volgende waarbij gebruik wordt gemaakt van een
typische <command>cp</command> opdracht:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>ls -F</userinput>
<computeroutput>dit-is-een-lang-bestand</computeroutput>
<prompt>/home/larry# </prompt><userinput>cp dit-is-een-lang-bestand korter</userinput>
<prompt>/home/larry# </prompt><userinput>ls -F</userinput>
<computeroutput>korter              dit-is-een-lang-bestand</computeroutput>
/home/larry# 
</screen>
</para>

<para>
Om elk teken in te tikken van <filename>dit-is-een-lang-bestand</filename> 
kost nogal wat moeite, wanneer je het tracht te benaderen.
Dus maak <filename>dit-is-een-lang-bestand</filename> aan door 
<filename>/etc/passwd</filename> 
ernaar te kopi&euml;ren<footnote><para><command>cp /etc/passwd 
dit-is-een-lang-bestand</command></para></footnote>. 
Nu gaan we de bovenstaande <command>cp</command> opdracht zeer 
snel uitvoeren met een kleinere kans typfouten te maken.
</para>

<para>
In plaats van het intikken van de volledige bestandsnaam, typ je 
<command>cp di</command> en drukt de <keycap>Tab</keycap> toets in 
en laat deze direct weer los. Als magie, verschijnt de rest van de 
bestandsnaam op de opdrachtregel. Helaas kan <application>bash</application>
<!-- \ttindex{bash}  -->
je gedachten niet lezen, en zul je <emphasis>korter</emphasis> 
volledig in moeten tikken.
</para>

<para>
Wanneer je de <keycap>Tab</keycap> indrukt, 
bekijkt <application>bash</application> wat je hebt ingevoerd en
gaat zoeken naar een bestand dat daarmee begint. Als ik bijvoorbeeld
<filename>/usr/bin/ema</filename> intik en daarna de <keycap>Tab</keycap> 
indruk, dan zal <application>bash</application>
<filename>/usr/bin/emacs</filename> vinden aangezien dat het enige bestand is op mijn
systeem dat begint met <filename>/usr/bin/ema</filename>. Typ ik echter 
<filename>/usr/bin/ld</filename> en
druk daarna op <keycap>Tab</keycap>, dan laat <application>bash</application>
een beep horen.
Dat komt omdat er drie bestanden op mijn systeem zijn, te weten
<filename>/usr/bin/ld</filename>, <filename>/usr/bin/ldd</filename>, en 
<filename>/usr/bin/ld86</filename> die
allen met <filename>/usr/bin/ld</filename> beginnen.
</para>

<para>
Probeer je een voltooiing en retourneert <application>bash</application>
een geluid, dan kun je
onmiddellijk weer de <keycap>Tab</keycap>-toets indrukken om een lijst met alle
bestanden te verkrijgen waar de ingegeven beginletters tot dusverre mee
corresponderen. Mocht je niet zeker zijn van de exacte spelling van je
bestand, dan kun je op die manier een begin maken en een veel kleinere
lijst met bestanden scannen.
</para>
</sect2>
</sect1>
<!-- \eindex{shell!voltooiing} -->

<sect1 id="stdin-stdout"><title>Standaardinvoer en standaarduitvoer</title>
<!--
% it might be nice to get some illustrations around here, with
% pointers showing where all the output is going
-->
<para>
Laten we eens een simpel probleem aanpakken: een lijst verkrijgen van de
directory <filename>/usr/bin</filename>. Als we slechts 
<command>ls /usr/bin</command> opgeven, dan zullen
een aantal bestanden bovenaan niet meer te zien zijn omdat deze van het scherm
zijn verdwenen om de laatste bestanden te kunnen tonen. Hoe kunnen we alle
bestanden te zien krijgen?
</para>

<sect2 id="unixconcepts"><title>&unix;-concepten</title>
<para>
Het besturingssysteem &unix; maakt het programma's erg makkelijk gebruik te
maken van de terminal. Wanneer een programma iets naar je scherm schrijft, 
gebruikt het iets dat de standaarduitvoer wordt genoemd. 
Standaarduitvoer, afgekort tot stdout, is hoe het programma iets wegschrijft 
naar een gebruiker. Wat je aan een programma opgeeft, heet 
standaardinvoer (stdin). Een programma kan met de gebruiker 
communiceren zonder daarbij gebruik te maken van de standaardinvoer of 
-uitvoer, maar de meeste opdrachten die ik in dit boek behandel maken 
gebruik van stdin en stdout.
</para>

<para>
Met bijvoorbeeld de opdracht <command>ls</command>
<indexterm><primary>ls</primary></indexterm> wordt de lijst met
directory's naar standaarduitvoer weggeschreven, welke normaal gesproken
is "verbonden" met je terminal. Een interactieve opdracht, zoals je
shell <application>bash</application>, leest je opdrachten vanaf 
standaardinvoer.
</para>

<para>
Een programma kan ook naar standaardfout schrijven,
aangezien het heel eenvoudig is het naast de standaarduitvoer naar
je terminal te laten verwijzen. Standaardfout (stderr) is bijna altijd
verbonden met een terminal zodat een echt mens de melding zal lezen.
</para>

<para>
In deze sectie gaan we drie manieren bestuderen om met de standaardinvoer
en -uitvoer om te gaan: invoer- en uitvoeromleiding en pipes.
</para>
</sect2>

<sect2><title>Uitvoeromleiding</title>
<para>
<indexterm><primary>omleiden</primary>
<secondary>van uitvoer</secondary></indexterm>
<indexterm><primary>standaarduitvoer</primary></indexterm>
Een zeer belangrijke feature van &unix; is de mogelijkheid om
uitvoer <emphasis>om te leiden</emphasis>. Hiermee kun je het resultaat van een
opdracht in een bestand opslaan of het direct naar een printer doorsturen
in plaats dat je de resultaten van de opdracht op het scherm bekijkt.
Om bijvoorbeeld de uitvoer van de opdracht <command>ls /usr/bin</command>
om te leiden, plaatsen we een <emphasis>&gt;</emphasis>-teken aan het 
einde van de regel, en geven we op in welk bestand we willen dat de 
uitvoer wordt opgeslagen:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>ls</userinput>
<prompt>/home/larry# </prompt><userinput>ls -F /usr/bin > listing</userinput>
<prompt>/home/larry# </prompt><userinput>ls</userinput>
<computeroutput>listing</computeroutput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
Zoals je kunt zien cre&euml;erde de opdracht een geheel nieuw bestand in
je homedirectory in plaats dat het de namen van alle bestanden wegschreef.
Laten we dit bestand eens proberen te bekijken met de opdracht 
<command>cat</command>.
Terugkijkend zul je je herinneren dat <command>cat</command> een 
tamelijk onbruikbare
opdracht was waarmee naar de terminal (de standaarduitvoer) werd gekopieerd 
wat je had ingetikt (de standaardinvoer). <command>cat</command> kan 
ook een bestand op standaarduitvoer afdrukken als je het bestand als 
parameter aan <command>cat</command> opgeeft:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>cat listing</userinput>
...
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
De exacte uitvoer van de opdracht <command>ls /usr/bin</command>
verscheen in de inhoud
van <filename>listing</filename>. Alles goed en wel, het loste echter het 
oorspronkelijke probleem niet op.<footnote><para>Ongeduldige lezers kunnen 
de opdracht <command>more</command> uitproberen.</para></footnote> 
Er valt echter meer te zeggen voordat we zover zijn.
</para>

<para>
De opdracht <command>cat</command> doet echter iets interessants wanneer 
de uitvoer ervan wordt omgeleid. 
Wat doet de opdracht <command>cat listing &gt; nieuwbestand</command>?
Normaal gesproken geeft de <filename>&gt; nieuwbestand</filename> aan 
"neem alle uitvoer van de opdracht en plaats het in 
<filename>nieuwbestand</filename>."
De uitvoer van de opdracht <command>cat listing</command> is het 
bestand <filename>listing</filename>. 
Dus we vonden een nieuwe (en niet zo effici&euml;nte) methode om bestanden
te kopi&euml;ren.
</para>

<para>
Hoe zit het met de opdracht <command>cat &gt; fox</command>? 
<command>cat</command> op zichzelf leest
elke regel in die in de terminal wordt getypt (standaardinvoer) en drukt
het direct weer af (standaarduitvoer) totdat het een <keycap>Ctrl-d</keycap>
tegenkomt.
In dit geval werd de standaarduitvoer omgeleid naar het bestand 
<command>fox</command>. 
Nu dient <command>cat</command> als een rudimentaire editor:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>cat > fox </userinput>
The quick brown fox jumps over the lazy dog. 
<emphasis>druk op Ctrl-d</emphasis>
</screen>
</para>

<para>
We hebben nu het bestand <filename>fox</filename> aangemaakt met daarin 
de zin "The quick brown fox jumps over the lazy dog."
Een laatste gebruik van de veelzijdige opdracht <command>cat</command> is om bestanden samen te voegen.
<command>cat</command> zal elk bestand dat als parameter werd opgegeven, 
de een na de ander, afdrukken. Dus de opdracht 
<command>cat listing fox</command> zal de directorylisting van
<filename>/usr/bin</filename> afdrukken en daarna zal het onze rare zin 
afdrukken. Dus met de opdracht 
<command>cat listing fox &gt; listandfox</command> zal een nieuw
bestand worden aangemaakt met de inhoud van zowel <filename>listing</filename>
als <filename>fox</filename>.
</para>
</sect2>

<!-- \eindex{uitvoeromleiding} -->

<sect2><title>Invoeromleiding</title>
<para>
<indexterm><primary>omleiden</primary>
<secondary>van invoer</secondary></indexterm>
<indexterm><primary>standaardinvoer</primary></indexterm>
Net als het omleiden van standaarduitvoer, 
is het ook mogelijk standaardinvoer om te leiden. In plaats dat
een programma invoer vanaf je toetsenbord inleest, leest het dit uit een
bestand. Aangezien invoeromleiding is gerelateerd aan uitvoeromleiding, lijkt
het vanzelfsprekend het speciale teken voor invoeromleiding 
<emphasis>&lt;</emphasis> te laten zijn. Ook dit wordt gebruikt na de 
opdracht die je wenst uit te voeren.
</para>

<para>
Gewoonlijk komt dit van pas als je een gegevensbestand hebt en een opdracht
die invoer van standaardinvoer verwacht. De meeste opdrachten accepteren 
ook dat je een bestand opgeeft waarop het moet worden toegepast, dus
<emphasis>&lt;</emphasis> wordt in het dagelijks gebruik niet zoveel 
toegepast als andere technieken.
</para>
</sect2>

<!-- \eindex{invoeromleiding} -->

<sect2><title>Pipes</title>
<para>
<indexterm><primary>pipes</primary></indexterm>
Veel &unix;-opdrachten produceren een grote hoeveelheid informatie.
Het is bijvoorbeeld bij een opdracht als <command>ls /usr/bin</command>
niet ongewoon dat er meer uitvoer wordt geproduceerd dan je op je scherm
kunt zien. Om alle informatie te kunnen zien die een opdracht als 
<command>ls /usr/bin</command> als uitvoer produceert, is een andere 
&unix; opdracht nodig, genaamd <command>more</command>.
<indexterm><primary>more</primary></indexterm>
<footnote><para><command>more</command> wordt 
zo genoemd omdat dat de aanwijzing is die het van origine laat zien: 
<literal>--more--</literal>. In veel Linux-versies is de opdracht 
<command>more</command> identiek aan een geavanceerdere opdracht. 
Aangenomen dat computerprogrammeurs slechte blijspelspelers zijn, noemde 
ze dit nieuwe programma <command>less</command> (betekent: minder).
<indexterm><primary>less</primary></indexterm>
</para></footnote>
<command>more</command> pauzeert na elk scherm vol met informatie. Net als bij
<command>cat /etc/rc</command> toont <command>more &lt; /etc/rc</command>
bijvoorbeeld het bestand <filename>/etc/rc</filename>, behalve dan dat 
<command>more</command> je de kans geeft het te lezen. <command>more</command> 
accepteert ook de opdracht <command>/etc/rc</command>, en dat is de 
normale wijze van aanroep.
</para>

<para>
Dat verhelpt echter nog niet het probleem dat <command>ls /usr/bin</command>
meer informatie toont dan je kunt zien. <command>more &lt; ls /usr/bin</command>
werkt niet---invoeromleiding werkt alleen bij bestanden, niet bij opdrachten!
Je zou dit kunnen doen:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>ls /usr/bin > temp-ls</userinput>
<prompt>/home/larry# </prompt><userinput>more temp-ls</userinput>
...
<prompt>/home/larry# </prompt><userinput>rm temp-ls</userinput>
</screen>
</para>

<para>
&unix; voorziet echter in een veel zuivere manier om dat te doen. Je kunt
gewoon de opdracht <command>ls /usr/bin | more</command> gebruiken. 
Het teken "<literal>|</literal>" duidt een 
<emphasis>pipe</emphasis>
(pijp) aan. Net als een waterpijp, bestuurt een &unix;-pijp de stroom. 
In plaats van water, besturen we de informatiestroom!
</para>

<para>
Een handige toepassing van pipes zijn programma's genaamd 
<emphasis>filters</emphasis>.  
<indexterm><primary>filters</primary></indexterm>
Een filter is een programma dat de
standaardinvoer leest, het op een of andere manier wijzigt, en 
op standaarduitvoer deze bewerking als uitvoer geeft. <command>more</command> 
is een filter; het leest de data in die het krijgt aangeleverd
via de standaardinvoer en toont het per scherm op standaarduitvoer, je
de mogelijkheid gevend het bestand te lezen. <command>more</command> 
is niet zo'n geweldig filter, omdat de uitvoer ervan niet geschikt is 
om naar een ander programma door te sturen.
</para>

<para>
Andere filters zijn de programma's <command>cat</command>,
<indexterm><primary>cat</primary></indexterm> <command>sort</command>,
<indexterm><primary>sort</primary></indexterm> <command>head</command>,
<indexterm><primary>head</primary></indexterm> en <command>tail</command>.
<indexterm><primary>tail</primary></indexterm>
Als je bijvoorbeeld alleen de eerste tien regels
van de uitvoer van <command>ls</command> zou willen lezen, dan gebruik 
je de opdracht <command>ls /usr/bin | head</command>.
</para>
</sect2>
</sect1>
<!-- \eindex{pipes} -->

<sect1 id="section-multitasking"><title>Multi-tasking</title>
<sect2><title>Het gebruik van taakbeheer</title>
<indexterm><primary>taakbeheer</primary>
<see>shell, taakbeheer</see></indexterm>
<indexterm><primary>job control</primary>
<see>shell, taakbeheer</see></indexterm>
<para>
<emphasis>Job control</emphasis>
<indexterm><primary>shell</primary>
<secondary>taakbeheer</secondary></indexterm>
refereert naar de mogelijkheid om processen (in wezen een ander woord 
voor programma's) in de achtergrond te plaatsen en ze weer naar de
voorgrond te brengen. Je kunt er iets mee uitvoeren onderwijl
je aan iets anders werkt, maar het ook weer terug kunt halen wanneer
je het iets door wilt geven of wilt stoppen. Onder Unix is het belangrijkste 
hulpmiddel voor taakbeheer de shell. De shell houdt taken voor je bij, als
je de taal ervan leert spreken.
</para>

<para>
De twee belangrijkste concepten in die taal zijn <command>fg</command>,
<indexterm><primary>fg</primary></indexterm>
voor foreground (voorgrond), en <command>bg</command>,
<indexterm><primary>bg</primary></indexterm>
voor background (achtergrond). Gebruik achter de 
prompt de opdracht <command>yes</command> om
<indexterm><primary>yes</primary></indexterm>
erachter te komen hoe ze werken.
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>yes</userinput>
</screen>
</para>


<para>
Dit heeft de uitvoering van een lange kolom met <literal>y</literal>'s 
die links van je scherm verschijnen als verrassend effect, sneller dan 
je kunt volgen. <footnote><para>Er zijn goede redenen voor het bestaan van 
deze vreemde opdracht. Zo nu en dan vragen opdrachten om bevestiging; een 
"yes" antwoord op een vraag. Met de opdracht <command>yes</command>
kan een programmeur de reactie op deze vragen automatiseren.</para></footnote> 
Normaal gesproken stop je de uitvoering
met de toetsencombinatie <keycap>ctrl-c</keycap>, maar in plaats daarvan typ je
ditmaal <keycap>ctrl-z</keycap>. Het lijkt te zijn gestopt, maar voordat
de prompt verschijnt, wordt nog een melding weergegeven, die er min of
meer zo uitziet:
</para>

<para>
<screen>
[1]+   Stopped                  yes
</screen>
</para>


<para>
Dit betekent dat het proces <command>yes</command> in de achtergrond is 
opgeschort. Je kunt het weer activeren met de opdracht 
<command>fg</command>,
<indexterm><primary>fg</primary>
<secondary>voorgrond</secondary></indexterm>
waarmee het weer 
in de voorgrond wordt geplaatst. Als je dat wenst, kun je tijdens deze
opschorting iets anders doen. Probeer eens een paar keer de opdracht
<command>ls</command> of iets dergelijks voordat je het terug in de 
voorgrond plaatst.
</para>

<para>
Zodra het is teruggekeerd in de voorgrond, stromen de <literal>y</literal>'s
weer over je scherm, net zo snel als voorheen. Je hoeft je er geen zorgen om te
maken dat het tijdens de opschorting meer <literal>y</literal>'s aan 
het opslaan was om naar het scherm te sturen:
wanneer een programma wordt opgeschort, dan draait het programma 
pas weer op moment dat je het activeert. (Typ <keycap>ctrl-c</keycap> om het
voorgoed te stoppen, zodra je er genoeg van hebt).
</para>

<para>
Laten we de melding van de shell eens apart bekijken:
</para>

<para>
<screen>
<computeroutput>[1]+   Stopped                yes</computeroutput>
</screen>
</para>

<para>
Het nummer tussen de blokhaken is het <emphasis>taaknummer</emphasis> 
van deze taak 
<indexterm><primary>shell</primary>
<secondary>taaknummer</secondary></indexterm>
en het zal worden gebruikt 
wanneer we er specifiek naar moeten refereren. (Gezien taakbeheer geheel 
gaat over de uitvoering van meerdere processen, hebben we natuurlijk een 
manier nodig om onderscheid tussen de verschillende processen te kunnen maken).
Het <literal>&plus;</literal>-teken dat daarop volgt vertelt ons dat dit 
de "huidige taak" is; dat wil zeggen, de meest recent verplaatste 
taak van de voorgrond naar de achtergrond. Typ je <command>fg</command>
dan zou je de taak met de <literal>&plus;</literal> weer in de voorgrond 
plaatsen. (Daarover later meer, wanneer we
de uitvoering van meerdere taken tegelijkertijd bespreken).
Het woord <literal>Stopped</literal> betekent dat de taak is 
"be&euml;indigd". De taak is niet dood, maar het is thans niet
actief. Linux heeft het in een speciale opgeschorte toestand bewaard, 
klaar om in actie te komen mocht iemand daarom verzoeken. Tenslotte is 
<command>yes</command> de naam van het proces dat is be&euml;indigd.
</para>

<para>
Laten we voordat we verdergaan deze taak stoppen en het weer op een andere
manier opstarten. De opdracht daarvoor wordt <command>kill</command>
<indexterm><primary>kill</primary></indexterm>
genoemd en kan op de volgende wijze worden toegepast:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>kill %1</userinput>
<computeroutput>[1]+  Stopped                 yes</computeroutput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<indexterm><primary>jobs</primary>
<see>shell, jobs</see></indexterm>

<para>
Wederom die melding "stopped" is misleidend.
<indexterm><primary>shell</primary><secondary>jobs</secondary></indexterm>
Typ <command>jobs</command> om erachter te komen of het 
nog steeds actief is:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>jobs</userinput>
<computeroutput>[1]+  Terminated                 yes</computeroutput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para> 
Daar is het dan; de taak is be&euml;indigd!  
(Het is mogelijk dat de opdracht <command>jobs</command> helemaal niets
liet zien, wat gewoon betekent dat er geen taken meer in de achtergrond
draaien. Paste je de opdracht <command>kill</command> op een taak toe, 
en toonde <command>jobs</command> niets, dan weet je dat de kill-opdracht 
succesvol was. Gewoonlijk wordt de melding "terminated"; weergegeven.)
</para>

<para>
Start nu als volgt <command>yes</command> weer op:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>yes > /dev/null</userinput>
</screen>
</para>

<para>
Als je de sectie over het omleiden van de invoer en uitvoer hebt gelezen,
dan weet je dat hiermee de uitvoer van <command>yes</command> naar het 
speciale bestand <filename>/dev/null</filename> wordt gestuurd.  
<filename>/dev/null</filename> is een zwart gat dat alle
uitvoer verslindt wat ernaar toe is gestuurd (als je hier gelukkig van
wordt, kun je het je voorstellen als een stroom met <literal>y</literal>'s
die uit je achterkant van je computer komt en een gat in de muur doorboort).
</para>     
  
<para> 
Na het typen hiervan, krijg je geen prompt terug, en je ziet ook de rij
met <literal>y</literal>'s niet. Alhoewel de uitvoer naar 
<filename>/dev/null</filename> wordt gestuurd, is de taak nog steeds 
actief in de voorgrond. Zoals gewoonlijk kun je het opschorten met de 
toetsaanslag <keycap>ctrl-z</keycap>. Doe dat nu om de prompt terug 
te krijgen.
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>yes > /dev/null</userinput>
["yes" is actief, we typten ctrl-z]
<computeroutput>[1]+  Stopped                 yes >/dev/null </computeroutput>

<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
Hmm... is er een manier om het in de achtergrond te laten 
<emphasis>draaien</emphasis>
terwijl het de prompt bij ons achterlaat voor wat interactief werk?
De opdracht hiervoor is 
<indexterm><primary>bg</primary>
<secondary>achtergrond</secondary></indexterm>
<command>bg</command>:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>bg</userinput>
<computeroutput>[1]+ yes >/dev/null  &</computeroutput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
Hier zul je me op moeten vertrouwen: De opdracht 
<command>yes &gt; /dev/null</command> werd weer actief, nadat je 
<command>bg</command> intikte. Ditmaal echter in de achtergrond. In feite
kun je bemerken dat je machine iets is vertraagd 
(het eindeloos genereren en verwerpen van een constante stroom y's kost 
nu eenmaal wat werk!) als je opdrachten achter de prompt geeft, 
zoals bijvoorbeeld een <command>ls</command> enzo. Anders dan dat zijn 
er echter geen effecten. Je kunt achter de prompt doen wat je wilt en 
<command>yes</command> zal gewoon verdergaan met het doorsturen van 
zijn uitvoer naar het zwarte gat.
</para>

<para>
Er zijn nu twee verschillende manieren om het te stoppen: met de opdracht
<command>kill</command> die je zojuist leerde, of door de taak weer in de 
voorgrond te plaatsen en de opdracht <keycap>ctrl-c</keycap> erop toe te 
passen. Laten we de tweede manier eens proberen, gewoon om de relatie 
tussen <command>fg</command> en <command>bg</command> wat beter te leren 
begrijpen:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>fg</userinput>
<computeroutput>yes >/dev/null</computeroutput>
[nu bevindt het zich weer in de voorgrond. Stel 
dat ik ctrl-c indruk om het te stoppen]

<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
Het is al weg. Start nu een paar taken op die dan gelijktijdig worden
uitgevoerd, zoals:
</para>

<!--
% lg: rephrase the above paragraph, maybe. It's a little awkward and
% lg: too much a meta-paragraph: a paragraph about the document
% kff: done, (good point).
-->
<para>
<screen>
<prompt>/home/larry# </prompt><userinput>yes  > /dev/null &</userinput>
<computeroutput>[1] 1024</computeroutput>
<prompt>/home/larry# </prompt><userinput>yes | sort > /dev/null &</userinput>
<computeroutput>[2] 1026</computeroutput>
<prompt>/home/larry# </prompt><userinput>yes | uniq > /dev/null</userinput>
[en typ hier ctrl-z om het op te schorten]
<computeroutput>
[3]+  Stopped                 yes | uniq >/dev/null</computeroutput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
Het eerste wat je wellicht opvalt bij deze opdrachten is de afsluitende
<emphasis>&amp;</emphasis>
<indexterm><primary>&amp;</primary></indexterm> aan het eind van de 
eerste twee. Een <emphasis>&amp;</emphasis> aan het einde van een opdracht 
plaatsen, vertelt de shell dat het direct vanaf het allereerste begin in de 
achtergrond moet draaien. (Het is gewoon een manier om te voorkomen 
het programma te starten, <keycap>ctrl-z</keycap> te typen, en 
vervolgens <command>bg</command> te typen.)  Dus we 
startten deze twee opdrachten draaiend in de achtergrond. 
De derde is opgeschort en thans inactief. Wellicht dat je opvalt dat
de machine nu langzamer is geworden, aangezien de twee actieve taken
wat tijd van de CPU vereisen.
Elke taak liet zijn taaknummer achter. De eerste twee toonden je ook hun
process identification nummers, of <abbrev>PID</abbrev>'s
<indexterm><primary>PID</primary></indexterm>, onmiddellijk volgend
op het taaknummer. De <abbrev>PID</abbrev>'s hoef je normaal gesproken 
niet te weten, maar zo nu en dan komen ze van pas.
Laten we de tweede be&euml;indigen, aangezien het je machine vertraagt. Je zou
gewoon <command>kill &percnt;2</command> in kunnen tikken, maar dat zou iets te 
gemakkelijk zijn.  Geef in plaats daarvan op:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>fg %2</userinput>
<computeroutput>yes | sort >/dev/null</computeroutput>
[typ ctrl-c om het te stoppen]

<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
Hiermee wordt gedemonstreerd dat <command>fg</command> ook parameters 
accepteert die beginnen met een <emphasis>&percnt;</emphasis>. In feite 
zou je zelfs dit in hebben kunnen tikken:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>%2</userinput>
<computeroutput>yes | sort >/dev/null</computeroutput>
[type ctrl-c om het te stoppen]

<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
Dit werkt omdat de shell een taaknummer automatisch interpreteert als
een verzoek die taak in de voorgrond te plaatsen.
Door de voorafgaande <emphasis>&percnt;</emphasis>
<indexterm><primary>&percnt;</primary></indexterm> kan het 
taaknummer worden herleid uit andere getallen. Typ nu 
<command>jobs</command> om te bekijken welke taken er nog actief zijn:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>jobs</userinput>
<computeroutput>
[1]-  Running                 yes >/dev/null  &
[3]+  Stopped                 yes | uniq >/dev/null
</computeroutput>
<prompt>/home/larry# </prompt>
</screen>       
</para>

<para>
De "<emphasis>-</emphasis>" betekent dat taaknummer 1 de 
tweede in lijn is om in de voorgrond te worden geplaatst, als je slechts 
<command>fg</command> zonder enige parameters opgeeft. De 
"<emphasis>&plus;</emphasis>" betekent dat de aangegeven taak de
eerste in lijn is; een <command>fg</command> zonder parameters zal 
taaknummer 3 in de voorgrond plaatsen. Je kunt het echter krijgen door 
het te benoemen als je dat wilt:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>fg %1</userinput>
<computeroutput>yes >/dev/null</computeroutput>
[typ nu ctrl-z om het op te schorten]
<computeroutput>
[1]+  Stopped                 yes >/dev/null</computeroutput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
Na taaknummer 1 te hebben gewijzigd en het vervolgens te hebben opgeschort
heeft het ook de prioriteiten van alle taken gewijzigd. Je kunt dit zien met
de opdracht <command>jobs</command>:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>jobs</userinput>
<computeroutput>[1]+  Stopped                 yes >/dev/null
[3]-  Stopped                 yes | uniq >/dev/null</computeroutput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
Nu zijn ze beiden gestopt (omdat beiden werden opgeschort met
<keycap>ctrl-z</keycap>), en nummer 1 is de volgende in lijn om standaard in de
voorgrond geplaatst te worden. Dit komt omdat je het handmatig in de
voorgrond plaatste en het daarna opschortte. De "&plus;" refereert
altijd naar de meest recente taak die vanuit de voorgrond werd opgeschort.
Je kunt het weer activeren:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>bg</userinput>
<computeroutput>[1]+ yes >/dev/null  &</computeroutput>
<prompt>/home/larry# </prompt><userinput>jobs</userinput>
<computeroutput>[1]-  Running                 yes >/dev/null  
[3]+  Stopped                 yes | uniq >/dev/null</computeroutput>
<prompt>/home/larry# </prompt>
</screen> 
</para>

<para>
Nu het weer actief is, is de andere taak weer in de lijn opgeschoven en staat
hier de <emphasis>&plus;</emphasis> voor. Laten we ze nu allen 
be&euml;indigen zodat je systeem niet permanent wordt vertraagd door 
processen die niets doen.
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>kill %1 %3</userinput>
<computeroutput>[3]   Terminated              yes | uniq >/dev/null</computeroutput>
<prompt>/home/larry# </prompt><userinput>jobs</userinput>
<computeroutput>[1]+  Terminated              yes >/dev/null</computeroutput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
Als het goed is, krijg je diverse meldingen te zien over het be&euml;indigen
van de taken; niets lijkt in stilte te stoppen. Even verderop
wordt een beknopte samenvatting getoond wat je behoort te weten over taakbeheer.

<indexterm><primary>shell</primary>
<secondary>taakbeheer</secondary>
<tertiary>samenvatting</tertiary></indexterm>
</para>

<para>In taakbeheer gebruikte opdrachten en toetsaanslagen</para>
<itemizedlist>
	<listitem><para>[<command>fg</command> <emphasis>%taak</emphasis>
Dit is een shellopdracht waarmee een 
taak naar de voorgrond wordt teruggebracht. Typ <command>jobs</command> en zoek
naar de taak met het <emphasis>&plus;</emphasis> teken om erachter te komen 
welke taak dit standaard is.

Parameters: Optioneel taaknummer. De standaard is het proces 
ge&iuml;dentificeerd met een <emphasis>&plus;</emphasis>.
</para>
</listitem>

<listitem><para>[<command>&amp;</command>] 
Wanneer aan een opdracht het teken een ampersand (&amp;) wordt 
toegevoegd, dan wordt hiermee aangegeven dat de opdracht automatisch
in de achtergrond wordt uitgevoerd. Dit proces is dan onderworpen aan
alle gebruikelijke methoden van taakbeheer die hier in detail zijn 
beschreven.
</para>
</listitem>

<listitem><para>[<command>bg</command> <literal>taak</literal>]
Dit is een shellopdracht die ervoor zorgt dat een opgeschorte taak 
in de achtergrond wordt uitgevoerd. Om erachter te komen welke dit 
standaard is, geef je de opdracht <command>jobs</command> en zoekt 
naar de taak met het teken <literal>+</literal>.

Parameters: Optioneel taaknummer. De standaard is het proces 
ge&iuml;dentificeerd met het teken <literal>+</literal>.
</para>
</listitem>

<listitem><para>
[<command>kill</command> <emphasis>%taak</emphasis><emphasis>PID</emphasis>] 
Dit is een shellopdracht waarmee een achtergrondtaak, opgeschort of 
actief, wordt be&euml;indigd. Geef altijd een taaknummer of 
<abbrev>PID</abbrev> op en denk er bij het gebruik van taaknummers aan 
ze te laten voorafgaan door een <literal>&percnt;</literal>. 

Parameters: Het taaknummer (voorafgegaan door <literal>&percnt;</literal>) 
of het PID (een <literal>&percnt;</literal> is hier niet nodig). 
Op &eacute;&eacute;n regel kunnen meer processen of taken worden opgegeven.
</para>
</listitem>

<listitem><para>[<command>jobs</command>] 
Deze shellopdracht toont gewoon wat informatie
over de taken die thans actief zijn of zijn opgeschort. Soms geeft
het ook informatie over taken die net zijn afgesloten of be&euml;indigd.
</para>
</listitem>

<listitem><para>[<keycap>ctrl-c</keycap>]
Dit is het algemene onderbrekingsteken. Gewoonlijk zal het 't 
programma stoppen als het programma in de voorgrond draait 
(soms zijn meer pogingen nodig). Echter niet alle programma's
reageren op deze methode van be&euml;indiging.
</para>
</listitem>

<listitem><para>[<keycap>ctrl-z</keycap>] Deze toetscombinatie maakt gewoonlijk dat een
programma wordt opgeschort, alhoewel een paar programma's het negeren.
Eenmaal opgeschort kan de taak in de achtergrond worden uitgevoerd of
worden be&euml;indigd.
</para>
</listitem>
</itemizedlist>

</sect2>

<sect2><title>De theorie van taakbeheer</title>
<indexterm><primary>shell</primary><secondary>taakbeheer</secondary>
<tertiary>concepten</tertiary></indexterm>
<para>
Het is van belang te begrijpen dat taakbeheer door de shell wordt uitgevoerd.
Er bestaat geen programma op het systeem met de naam <command>fg</command>;
<command>fg</command>, <command>bg</command> <command>&amp;</command>, 
<command>jobs</command>, en <command>kill</command> zijn allen
interne shellopdrachten (in werkelijkheid is <command>kill</command> soms 
wel een onafhankelijk programma, maar de <application>bash</application>
shell die door Linux wordt gebruikt heeft hier een interne opdracht voor).
Dit is logisch: gezien elke gebruiker zijn eigen ruimte voor taakbeheer wil,
en elke gebruiker reeds een eigen shell heeft, is het 't makkelijkst
<!--
% lg: why the quotes?
% kff: good question :-)... computer techies tend
% to use the word "space" in a way unfamiliar to many people, but I
% think readers can grok it from context, now that you bring it up, so
% I have killed the quotes.
-->
gewoon de shell de taken van de gebruiker bij te laten houden.
Daarom zijn de taaknummers van elke gebruiker alleen van betekenis voor
die gebruiker:
mijn taaknummer [1] en jouw taaknummer [1] zijn waarschijnlijk twee
totaal verschillende processen. Het is zelfs zo dat als je meer dan
eenmaal bent ingelogd, elk van je shells unieke taakbeheergegevens heeft.
Dus jij als een gebruiker kan twee verschillende taken met hetzelfde
nummer hebben draaien in twee verschillende shells.
</para>

<para>
De manier om hier zekerheid over te krijgen is door gebruik te maken van
Process ID nummers (<abbrev>PID</abbrev>'s). Deze zijn systeembreed; elk proces 
heeft een eigen uniek <abbrev>PID</abbrev> nummer. Twee verschillende 
gebruikers kunnen 
naar een proces refereren aan de hand van het <abbrev>PID</abbrev>
en weten dat ze het 
hebben over hetzelfde proces (in de veronderstelling dat ze op dezelfde 
machine zijn ingelogd!).
</para>

<para>
Laten we nog eens een opdracht bekijken om te begrijpen wat 
<abbrev>PID</abbrev>'s
zijn. De opdracht <command>ps</command> toont een lijst met alle actieve 
processen, waaronder je shell. Probeer het uit. 
Deze opdracht accepteert tevens een paar opties, waarvan (voor veel
mensen) de belangrijkste <option>a</option>, <option>u</option> en
<option>x</option> zijn. De optie 
<option>a</option> toont de processen die toebehoren aan alle gebruikers,
niet alleen die van jezelf. De <option>x</option> switch toont processen waarmee
geen terminal is verbonden.<footnote><para>Dit heeft alleen zin voor bepaalde
systeemprogramma's die niet hoeven te communiceren met gebruikers via een
toetsenbord.</para></footnote> Tenslotte geeft de <option>u</option> 
switch aanvullende informatie over het proces.
</para>

<para>
Om werkelijk een indruk te krijgen wat je systeem aan het doen is, combineer
je alle opties: <command>ps -aux</command>. Je kunt dan de processen zien 
die het meeste geheugen in beslag nemen door in de kolom <literal>%MEM</literal>
te kijken, en het meeste CPU door te kijken in de kolom <literal>%CPU</literal>
(In de kolom <literal>TIME</literal> wordt de <emphasis>totale</emphasis> 
hoeveelheid gebruikte CPU-tijd weergegeven.)
<indexterm><primary>CPU-tijd</primary></indexterm>
</para>

<para>
Nog even wat anders over <abbrev>PID</abbrev>'s. In aanvulling op de 
acceptatie door <command>kill</command> in de vorm <emphasis>job#</emphasis>,
accepteert het ook <abbrev>PID</abbrev>'s als optie. Plaats dus
een <command>yes > /dev/null</command> in de achtergrond, start 
<command>ps</command>, en zoek naar <command>yes</command>. 
Typ vervolgens <command>kill PID</command>
<footnote><para>Over het algemeen is het makkelijker om gebruik te maken 
van het taaknummer in plaats van het <abbrev>PID</abbrev>.</para></footnote>
</para>

<para>
Als je op je Linux-systeem begint te programmeren, dan zul je spoedig leren
dat de taakbeheer van de shell gewoon een interactieve versie is
van de aanroepen naar de functies <function>fork</function> en 
<function>execl</function>.  
Dit is te complex om hier verder op in te gaan, maar kan later van pas 
komen wanneer je gaat programmeren en meerdere processen wilt uitvoeren 
vanuit een enkel programma.
</para>
</sect2>
</sect1>

<sect1 id="virt-console">
<title>Virtuele Consoles: Op veel plaatsen tegelijkertijd zijn</title>
<para>
Linux ondersteunt <emphasis>virtuele consoles</emphasis>.
<indexterm><primary>virtuele consoles</primary></indexterm>
<indexterm><primary>VC</primary><see>virtuele consoles</see></indexterm>
Dit is een manier om je enkele machine
te laten lijken op meerdere terminals, die allen zijn verbonden met
&eacute;&eacute;n Linux-kernel. Gelukkig is het gebruik van virtuele 
consoles onder Linux zeer eenvoudig: er zijn "hotkeys"
beschikbaar om snel tussen de consoles te schakelen.
Om het uit te proberen log je in op je Linux-systeem, houd de linker
<keycap>Alt</keycap>-toets ingedrukt en drukt dan op <keycap>F2</keycap> 
(dat wil zeggen functietoetsnummer 2)

<footnote><para>Zorg dat je dit doet vanaf een tekstconsole: Draai je 
onder X-Window of andere grafische toepassing, dan zal dit waarschijnlijk
niet werken, alhoewel het gerucht gaat dat X-Window spoedig het 
overschakelen tussen virtuele consoles onder Linux mogelijk maakt.</para>
</footnote>.
<!-- % I think it does now. -M **** -->
Je hebt nu een andere loginprompt. Raak niet in paniek: je bevindt je nu
op de virtuele console (VC) nummer 2! Log hier in en doe wat --- een paar
keer de opdracht <command>ls</command> of iets dergelijks; ter bevestiging dat
dit een echte loginshell is. Nu kun je naar VC nummer 1 terugkeren door
de linker <keycap>Alt</keycap>-toets ingedrukt te houden en dan de <keycap>F1</keycap>
in te drukken. Of je kunt doorgaan naar een <emphasis>derde</emphasis> VC, 
met vanzelfsprekend de combinatie <keycap>Alt-F3</keycap>.
</para>

<para>
Standaard worden Linux-systemen over het algemeen geactiveerd met vier
VC's. Je kunt dit ophogen tot acht: dit wordt behandeld in &ldpsa;.
Je moet er &eacute;&eacute;n of twee bestanden in <filename>/etc</filename>
voor bewerken. Echter vier VC's is voor de meeste mensen wel voldoende.
<!-- % lg: just is more direct and better for both I&GS and UG
% yup, shouldn't take up space here with this stuff, you're right.
% Umm, the virtual consoles are enabled, there just aren't any
% shells running in them - you can start programs with stdin from
% other VCs and/or stdout to other VCs. -M **** -->
Als je er eenmaal aan bent gewend, zullen VC's waarschijnlijk een
onmisbaar hulpmiddel gaan vormen om veel tegelijkertijd gedaan te krijgen.
Ik draai bijvoorbeeld typisch Emacs op VC 1 (en verricht hier het meeste
werk), en een communicatieprogramma op VC 3 (zodat ik tijdens mijn werk
per modem bestanden kan downloaden of uploaden, of taken op remote
machines kan uitvoeren), en een shell openhouden op VC 2 voor het geval
ik nog iets anders wil doen zonder VC 1 daarvoor in beslag te nemen.
</para>
</sect1>
</chapter>
<!--
% Local Variables: 
% mode: latex
% TeX-master: "guide"
% End: 
-->