Module 2 Principes van Operating Systems; werken met UNIXabhulai/icg/dictaat/module2.pdf · 2007....

Module 2 Principes van Operating Systems;

werken met UNIX

Inhoudsopgave Module 2 Principes van Operating Systems; werken met UNIX --------------------------------------------- 30 2.1 Computers en computersystemen ------------------------------------------------------------------------- 32 2.2 Het practicum bij module 2 -------------------------------------------------------------------------------- 40

2.2.1 Doelstellingen ------------------------------------------------------------------------------------------ 40 2.3 Introductie UNIX -------------------------------------------------------------------------------------------- 41

2.3.1 Een stukje geschiedenis ------------------------------------------------------------------------------ 41 UNIX en DOS ----------------------------------------------------------------------------------------------------- 41 Gebruik van handleidingen en help in UNIX ------------------------------------------------------------------ 41

2.4 Desktop-omgevingen onder UNIX ----------------------------------------------------------------------- 42 De werking van GNOME ---------------------------------------------------------------------------------------- 42

2.5 De (UNIX-) shell -------------------------------------------------------------------------------------------- 44 Functies van de shell ---------------------------------------------------------------------------------------------- 44 De shell opstarten ------------------------------------------------------------------------------------------------- 44

2.6 Enkele eenvoudige commando’s -------------------------------------------------------------------------- 45 Passwd, Date, who, ls, lpr en man ------------------------------------------------------------------------------ 45

Password wijzigen --------------------------------------------------------------------------------------------- 45 date --------------------------------------------------------------------------------------------------------------- 46 who --------------------------------------------------------------------------------------------------------------- 46 ls ------------------------------------------------------------------------------------------------------------------ 46 lpr ----------------------------------------------------------------------------------------------------------------- 47 man --------------------------------------------------------------------------------------------------------------- 47

Een commando afbreken ----------------------------------------------------------------------------------------- 48 2.7 Werken met directories ------------------------------------------------------------------------------------- 48

Directories maken, de inhoud bekijken en veranderen van directory -------------------------------------- 48 De weg kwijt?? ---------------------------------------------------------------------------------------------------- 50

2.8 Werken met files -------------------------------------------------------------------------------------------- 52 2.9 Meer commando’s------------------------------------------------------------------------------------------- 52

Commando’s combineren ---------------------------------------------------------------------------------------- 53 Speciale tekens----------------------------------------------------------------------------------------------------- 53

? ------------------------------------------------------------------------------------------------------------------- 53 * ------------------------------------------------------------------------------------------------------------------- 53

Redirectie van invoer en uitvoer -------------------------------------------------------------------------------- 54 Pipes ----------------------------------------------------------------------------------------------------------------- 54 Grep ----------------------------------------------------------------------------------------------------------------- 55 Sorteren ------------------------------------------------------------------------------------------------------------- 55 Met meer programma’s tegelijk werken ----------------------------------------------------------------------- 56

Processen op de achtergrond zetten -------------------------------------------------------------------------- 56 Processen beheren ---------------------------------------------------------------------------------------------- 56

Rijmwoordenboek ------------------------------------------------------------------------------------------------- 57 2.10 Werken met een editor -------------------------------------------------------------------------------------- 58

Wat is een editor --------------------------------------------------------------------------------------------------- 58 De editor jEdit opstarten ----------------------------------------------------------------------------------------- 58 jEdit opstarten onder UNIX -------------------------------------------------------------------------------------- 58

___________________________________________________________________________________ Inleiding Computergebruik 31 Module 2

jEdit opstarten onder Windows ---------------------------------------------------------------------------------- 58 Het beginscherm --------------------------------------------------------------------------------------------------- 59 Belangrijke toetsen: CTRL en ALT ---------------------------------------------------------------------------- 59 Noodrem ------------------------------------------------------------------------------------------------------------ 59 Bewegen door de file --------------------------------------------------------------------------------------------- 59 Wijzigingen aanbrengen ------------------------------------------------------------------------------------------ 60 Wijzigingen opslaan en de editor verlaten --------------------------------------------------------------------- 61

2.11 Meer mogelijkheden met de editor ------------------------------------------------------------------------ 62 Een file opnieuw openen ----------------------------------------------------------------------------------------- 62 Meer wijzigingen aanbrengen ----------------------------------------------------------------------------------- 63 Volgorde veranderen en tekst wissen --------------------------------------------------------------------------- 64 Woorden zoeken --------------------------------------------------------------------------------------------------- 64 Woorden vervangen ----------------------------------------------------------------------------------------------- 65 Een nieuwe file maken ------------------------------------------------------------------------------------------- 65 Met meer files tegelijk werken ---------------------------------------------------------------------------------- 65

Schakelen tussen files ------------------------------------------------------------------------------------------ 65 Meerdere files tegelijk in beeld ------------------------------------------------------------------------------- 65

2.12 Het gebruik van floppies en CD-ROM’s binnen UNIX ------------------------------------------------ 66 2.13 Shell-scripts -------------------------------------------------------------------------------------------------- 66

Een zeer eenvoudig shell-script --------------------------------------------------------------------------------- 67 Shell-scripts met variabelen -------------------------------------------------------------------------------------- 67 Een shell-script executable maken ------------------------------------------------------------------------------ 68 De plaats van shell-scripts --------------------------------------------------------------------------------------- 68 Argumenten meegeven aan een shell-script ------------------------------------------------------------------- 69 Keuzes maken------------------------------------------------------------------------------------------------------ 69 Keuzes: de case-functie ------------------------------------------------------------------------------------------- 70 Herhalen: de while-functie --------------------------------------------------------------------------------------- 71 Meer mogelijkheden met shell-scripts -------------------------------------------------------------------------- 72

2.14 Protectie en Permissie -------------------------------------------------------------------------------------- 72 Werkwijze 1 -------------------------------------------------------------------------------------------------------- 72 Werkwijze 2 -------------------------------------------------------------------------------------------------------- 73 Voor gevorderden: Bash ------------------------------------------------------------------------------------------ 74

2.15 Extra: UNIX-applicaties ------------------------------------------------------------------------------------ 76 Gebruiksomgevingen --------------------------------------------------------------------------------------------- 76 Diskquota’s en budgetten ---------------------------------------------------------------------------------------- 77 Printen -------------------------------------------------------------------------------------------------------------- 78 Procescontrole met Bash ----------------------------------------------------------------------------------------- 78


2.1 Computers en computersystemen

P.R.J. Asveld, A. Nijmeijer, J. Reuzel, J. Scholten, J.T. van der Veen, W.A. Vervoort (1997) 1

Inleiding Door de grote opkomst van computers en computersystemen in de laatste tientallen jaren is de belangstelling voor computerprogrammering en computergebruik groter dan ooit tevoren. Het hoofdthema van deze cursus is computergebruik. We zullen in grote lijnen aangeven wat een computer en een computersysteem is en wat er zoal komt kijken bij het programmeren en gebruiken daarvan.

Programmeerbare automaten Computers zijn programmeerbare automaten die in staat zijn gegevens te verwerken. Computers zijn niet de oudste programmeerbare automaten. Van veel oudere datum is bijvoorbeeld het weefgetouw van Jacquard. Dit getouw wordt gestuurd door een soort ponsband waarin door middel van gaatjes wordt aangegeven welk patroon geweven moet worden. Deze ponsband is het programma dat door het weefgetouw wordt uitgevoerd. Een andere ponsband, dus een ander programma, betekent een ander weefpatroon. Ook een draaiorgel is een voorbeeld van een programmeerbare automaat. Een draaiorgel wordt gestuurd door eenzelfde soort ponsband als het weefgetouw van Jacquard. Specifiek én algemeen Programmeerbare automaten zijn enerzijds heel specifiek, anderzijds toch ook algemeen. Ze zijn specifiek omdat zij slechts in staat zijn bepaalde handelingen of instructies uit te voeren. Een weefgetouw van Jacquard kan alleen maar weven en een draaiorgel maakt alleen maar muziek.

Ze zijn algemeen omdat ze elk op hun eigen gebied, tot allerlei dingen in staat zijn. Het weefgetouw kan allerlei patronen weven. Door het programma wordt uit alle mogelijke patronen net dat ene uitgekozen dat gewenst wordt. En zo kan ook een draaiorgel allerlei muziek maken, van evergreens tot pop; het programma bepaalt weer welke melodie er ten gehore gebracht wordt. Het weven van patronen of het spelen van een bepaalde melodie gebeurt automatisch en onder besturing van het ingevoerde programma. Het automatisme bestaat daarin dat met elke programma-instructie een bepaalde handeling wordt verricht en dat bovendien, als een instructie is afgehandeld, de automaat vanzelf begint aan de uitvoering van de volgende nstructie. Dat de automaat zo werkt hangt samen met zijn constructie, meer kan hij ook niet. Geheugen Hetzelfde geldt voor een computer. Ook een computer is specifiek in die zin dat hij slechts een beperkt aantal instructies kan uitvoeren. Maar er is één groot en principieel verschil tussen computers en andere automaten: een computer beschikt over een geheugen. Dit geheugen wordt het interne geheugen of werkgeheugen genoemd. Daarin worden bij het begin van de uitvoering van het programma de invoergegevens (de gegevens die verwerkt moeten worden) en het programma geplaatst. Ook zullen hierin de resultaten of tussenresultaten van de bewerkingen worden opgeslagen. Dit alles blijft aanwezig tot het programma volledig is afgewerkt.

Dat het programma zelf gedurende zijn uitvoering in het interne geheugen is opgeslagen, staat bekend als het stored-program concept (store = opslagplaats; stored = opgeslagen in het geheugen). Alle computers, in tegenstelling tot andere programmeerbare automaten, maken gebruik van dit principe. Omdat bij een computer invoergegevens, (tussen)resultaten en programma tegelijk in het werkgeheugen aanwezig zijn, is het mogelijk een speciaal soort

1 Dit artikel is met goedkeuring ontleend aan: Practicumhandleiding Computergebruik, Universiteit Twente, Faculteit der Informatica. In het artikel zijn gegevens aangepast aan de huidige stand van de techniek. Daarnaast is hoofdstuk 7 toegevoegd.


instructies op te nemen in een computerprogramma. Instructies namelijk die bedoeld zijn voor besturing van het programma (program control).

Er kan bijvoorbeeld in het programma worden voorgeschreven om bepaalde gegevens met elkaar te vergelijken en op grond hiervan kan dan een deel van het programma worden herhaald (het programmadeel moet hiervoor wel aanwezig zijn!), een bepaalde instructie worden overgeslagen (voorwaardelijke uitvoering) of een keuze worden gemaakt uit een tweetal instructies (alternatieve uitvoering).

Voorbeelden hiervan zijn: “ZOLANG x>0 HERHAAL instructie 1” “ALS x<0 DAN instructie 2” “ALS p=q DAN instructie 3 ANDERS instructie 4”

Zonder dit soort instructies voor programmabesturing zou een computer slechts beperkt bruikbaar zijn. Het is juist de combinatie van deze besturingsinstructies met de “gewone” rekeninstructies (als vergelijken of optellen) die ons in staat stelt programma’s te schrijven voor het verwerken van allerlei soorten gegevens. Dit kan variëren van het alfabetisch ordenen van een lijst met namen of het doen van spelletjes tot het laten uitvoeren van een zachte landing door een ruimtevaartuig. Door deze grote variatie aan toepassingsmogelijkheden heeft het computergebruik zo’n grote vlucht kunnen nemen.

Opbouw van een computer Een moderne computer is samengesteld uit een zeer groot aantal elektronische basiscircuits. Het zou te ver voeren om nader op de samenstelling van deze circuits in te gaan. Dit is iets voor hardware-specialisten (hardware = apparatuur) en niet van belang voor software-mensen (software = programmatuur). Om toch inzicht te krijgen in de bouw en de werking van een computer zullen we zeer schematisch te werk gaan en een computerinstallatie onderverdelen in een aantal blokken die elk een functionele eenheid vormen. Dit brengt ons tot het volgende schema van een computerinstallatie:

Figuur 1 Apparatuurcomponenten van een computerinstallatie

Componenten van een computer Het invoerorgaan is nodig om het programma (stored-program) en de invoergegevens in te voeren in het interne geheugen zodat er mee gewerkt kan worden. Het bestaat uit bijvoorbeeld een toetsenbord of een optische lezer.

Het uitvoerorgaan dient ervoor om de resultaten van de bewerkingen vanuit het interne geheugen in de buitenwereld, bijvoorbeeld een beeldscherm of printer af te leveren. Bij een PC, workstation of terminal zien we dat het in- en uitvoerorgaan gecombineerd zijn. Toch blijven het geheel gescheiden functies! Intikken van invoergegevens betekent dan ook niet, zoals bij een typemachine, dat deze zonder meer worden afgebeeld op het beeldscherm of op het papier. Dat afbeelden gebeurt onder controle van de computer en zoals altijd vanuit het geheugen. De

besturingseenheid

centrale verwerkingseenheid

bewerkingseenheid

interne geheugen

computer

invoerorgaan uitvoerorgaan


invoer wordt alleen maar weergegeven, geëchood zoals we dit noemen, als de computer daartoe opdracht heeft gekregen: de echo-functie kan aan- en afgezet worden. Normaal zal de echo aanstaan om de gebruiker in staat te stellen de ingevoerde gegevens te controleren op fouten. Maar soms is het aanstaan van de echo niet gewenst. Bijvoorbeeld bij het invoeren van geheime informatie als een password (een woord dat toegang verschaft tot de computer).

De computer zelf is opgebouwd uit 2 hoofdcomponenten: de centrale verwerkingseenheid (CVE of CPU van central processing unit) en het interne geheugen. De CPU zelf is weer opgebouwd uit een besturingseenheid en een bewerkingseenheid.

De besturingseenheid interpreteert instructies (decodeert ze) en genereert daarbij de nodige stuursignalen naar de overige componenten. Deze stuursignalen hebben een transport van gegevens of instructies tot gevolg, of een rekenkundige of logische bewerking. De besturingseenheid bestuurt en coördineert de hele computerinstallatie; er is niets dat niet via of op initiatief van de besturingseenheid gebeurt.

De bewerkingseenheid voert instructies voor rekenkundige of logische bewerkingen uit als optellen, aftrekken, vermenigvuldigen, delen of vergelijken. Andere namen hiervoor zijn rekenorgaan en ALU (arithmetic and logical unit).

Het interne geheugen kunnen we beschouwen als een rij cellen of locaties. Bestaat het geheugen uit n locaties dan kunnen we deze nummeren van 0 t/m n-1. Het aldus verkregen nummer van een locatie noemen we het adres van deze geheugenlocatie. De geheugencellen moeten instructies en gegevens kunnen bevatten. Deze moeten in de een of andere code vastgelegd worden. We gebruiken daarvoor een binaire code, dus een rijtje nullen en enen. Een geheugenlocatie is daarom samengesteld uit een aantal componenten die zich in slechts 2 toestanden kunnen bevinden. Deze toestanden worden aangeduid met 1 en 0 of met waar en onwaar (true en false). Zo’n 2-waardige component wordt bit genoemd. Dat is een samentrekking van binairy digit (een getal uit het 2-tallig stelsel). Een groepje van 8 bits wordt een byte genoemd en een groepje van een vast aantal, bijvoorbeeld twee bytes, een woord. Werking van een computer Nu we de voornaamste componenten van een computer hebben leren kennen vragen we ons af hoe een computer eigenlijk werkt. Om dit goed te kunnen bespreken, tekenen we het schema van een computerinstallatie nog een keer opnieuw, maar nu op een wat andere manier.

Figuur 2 Apparatuurcomponenten van een computerinstallatie en hun wisselwerking tijdens de uitvoering van een programma

We gaan er van uit dat het programma via het invoerorgaan in het interne geheugen is geplaatst op last van de besturingseenheid (stored program). Ook nemen we aan dat de te bewerken

route van gegevensroute van opdrachten

route van besturingssignalen

Betekenis van de symbolen

bewerkingseenheid

besturingseenheid

interne geheugeninvoerorgaan uitvoerorgaan


gegevens in het interne geheugen aanwezig zijn. De besturingseenheid zal er dan voor moeten zorgen dat de afzonderlijke instructies één voor één en in de juiste volgorde worden uitgevoerd. Om dit te kunnen doen zal de besturingseenheid moeten weten welke de eerste instructie is en ook welke instructie moet worden uitgevoerd steeds nadat er een is afgewerkt. De besturingseenheid zal daarom telkens het adres bijhouden van de geheugencel waarin de instructie staat die aan de beurt is of komt.

Het afwerken van de aan de beurt zijnde instructie verloopt als volgt.

Met behulp van het adres waarop de uit te voeren instructie staat, wordt deze vanuit het werkgeheugen gekopieerd en in de besturingseenheid geplaatst. Merk hierbij goed op dat er echt gekopieerd wordt en dat de instructie nu dus niet alleen in de besturingseenheid staat maar ook nog steeds in het werkgeheugen! Dit laatste is nodig voor eventuele herhalingen.

De (kopie van de) instructie wordt geïnterpreteerd door de besturingseenheid. Daarbij wordt vastgesteld wat de operatiecode (opcode) is, dus welke bewerking (operatie) moet plaatsvinden, welke gegevens (operanden) bewerkt moeten worden en waar het resultaat van de bewerking moet worden opgeslagen (resultaatadres). Dit alles wordt doorgegeven aan de bewerkingseenheid.

De instructie wordt daadwerkelijk uitgevoerd door de bewerkingseenheid.

Het resultaat wordt op initiatief van de besturingseenheid naar het resultaatadres gekopieerd.

Het adres waarop de volgende instructie te vinden is, wordt bijgewerkt.Deze cyclus wordt steeds automatisch herhaald totdat er een stopinstructie wordt uitgevoerd.

Achtergrondgeheugen en files Het tot nu toe geschetste beeld van de apparatuurcomponenten van een computerinstallatie, dus invoerorgaan, centrale verwerkingseenheid, intern geheugen en uitvoerorgaan, is voldoende om te kunnen begrijpen hoe een computer in principe werkt. In werkelijkheid komt er bij de apparatuur nog wel wat meer kijken, zelfs al bij een zeer eenvoudige computerinstallatie. Meestal is er namelijk naast het werkgeheugen nog een extra hulpgeheugen (ook wel: extern geheugen of achtergrondgeheugen) aanwezig. Dit externe geheugen bestaat vaak uit een magnetische schijveneenheid. Toevoeging van zo’n extern geheugen leidt tot het volgende blokschema:

Figuur 3 Het externe geheugen als onderdeel van de computer

Waarom een extern geheugen? Dat er meestal een extern geheugen aanwezig is komt doordat in een computersysteem vaak grote hoeveelheden gegevens langdurig of zelfs permanent bewaard moeten blijven. Denk maar eens aan een programma dat veelvuldig gebruikt wordt, aan een abonneebestand voor een

invoerorgaan uitvoerorgaaninterne geheugen

centrale verwerkingseenheid

computer

externe geheugen


tijdschrift of aan een grote hoeveelheid administratieve programma’s met bijbehorende gegevens in een bedrijf. Dit soort gegevens kan niet bewaard blijven in het interne geheugen om de doodeenvoudige redenen dat dit meestal een vluchtig geheugen is en bovendien de capaciteit ervan in het algemeen niet toereikend zal zijn. Vluchtig wil zeggen dat de gegevens er uit zullen verdwijnen (vervluchtigen) zodra de computer wordt uitgeschakeld (door de gebruiker of ten gevolge van een storing). Bij magnetische opslag daarentegen op band of schijf blijven de gegevens gewoon bewaard, ook al wordt het apparaat uitgeschakeld. Vergelijk dit maar met muziek die in magnetische vorm is opgeslagen op een cassettebandje. Opslagcapaciteit en toegangstijd De opslagcapaciteit van het interne geheugen ligt in de orde van grootte van enkele tot enkele honderden Mbytes (1 M = 1 mega = 220) en die van het externe geheugen bedraagt al gauw enkele Gigabytes. Dat de werkgeheugencapaciteit relatief laag is, is een kwestie van prijs. Werkgeheugen is per eenheid vele malen duurder dan extern geheugen omdat het werkgeheugen zo nauw gekoppeld is aan de centrale verwerkingseenheid. Tussen deze twee componenten bestaan altijd rechtstreekse verbindingen waarlangs de besturingseenheid de afzonderlijke bytes in het werkgeheugen rechtstreeks kan adresseren (benaderen) en waarlangs er rechtstreeks gegevens uitgewisseld kunnen worden tussen werkgeheugen, besturingseenheid en bewerkingseenheid. Dit alles vergt vele en mede daardoor complexe en dure elektronische schakelingen.

Externe geheugens zijn typisch bedoeld voor de min of meer permanente opslag van grote hoeveelheden gegevens. De tol die voor de grote capaciteit van een extern geheugen betaald moet worden is een drastische verhoging van de toegangstijd (accesstijd) van gegevens op het externe geheugen in vergelijking tot die van gegevens in het werkgeheugen. Het grootste deel van de tijd wordt hierbij in beslag genomen door de noodzakelijke mechanische instelbewegingen van het medium. Bij een schijfeenheid is dat de insteltijd van de leesarm en het wachten (gemiddeld een halve omwentelingstijd lang, of minder als er meer koppen gemonteerd zijn) tot het begin van de gegevenslocatie onder de leeskop aankomt. De feitelijke overdracht van de gegevens gaat vervolgens weer snel. Om de insteltijd zoveel mogelijk te ontlopen en optimaal gebruikt te kunnen maken van deze hoge overdrachtssnelheid, vindt het gegevenstransport van of naar achtergrondgeheugen meestal niet per woord plaats, maar broksgewijs, dat wil zeggen met een groot aantal woorden tegelijk (bijvoorbeeld 1 kilobyte of een veelvoud hiervan, afhankelijk van het computersysteem). Zo’n blok gegevens wordt dan in z’n geheel getransporteerd naar of van een bufferruimte in het werkgeheugen.

Buffering in deze vorm komt ook vaak voor bij het invoerorgaan en het uitvoerorgaan. Want in vergelijking met de centrale computer zelf zijn ook dit meestal erg langzame (gedeeltelijk mechanische!) apparaten. Bewaren van gegevens Het bewaren van gegevens in het externe geheugen zelf gebeurt in de vorm van files. Een file (of eigenlijk de inhoud ervan) is een hoeveelheid gegevens die bij elkaar hoort en samen één geheel vormt. Niet alle files zijn even lang. De lengte van een file wordt bepaald door de hoeveelheid gegevens die er in opgeslagen wordt. Een file kan bijvoorbeeld bestaan uit een tekst, uit de invoergegevens van een programma of uit de gegevens van alle abonnees van een tijdschrift.

Iedere file heeft een unieke naam, de systeemfilenaam. Deze unieke systeemnaam is vanzelfsprekend nodig om eenmaal opgeslagen gegevens weer te kunnen bereiken. Ook kunnen files op het achtergrondgeheugen worden gemanipuleerd. Ze kunnen bijvoorbeeld worden gelezen, beschreven, gecreëerd of vernietigd.


Systeemprogrammatuur Als we een computer gebruiken dan hebben we niet alleen te maken met een brok hardware (apparatuur) maar ook met een hoeveelheid systeemsoftware (systeemprogragrammatuur). Dit geheel van hardware en systeemsoftware noemen we een computersysteem.

De systeemprogrammatuur wordt meestal meegeleverd door de computerfabrikant of -leverancier en dient er voor te zorgen dat we op een acceptabele manier kunnen werken met de computer. Naast de systeemprogrammatuur onderscheiden we de gewone toepassings- of gebruikersprogrammatuur. Deze is voor de gebruiker ontwikkeld ten behoeve van de een of andere toepassing, bijvoorbeeld het werken met teksten of het uitvoeren van berekeningen.

De systeemprogrammatuur kent vele taken. Een ervan is bijvoorbeeld het beheren van files op het achtergrondgeheugen. Dit gebeurt door het operating system. Het operating system is een speciaal programma dat in feite alles wat er zich in de computer afspeelt bijhoudt, bestuurt, controleert en coördineert. Om files te kunnen beheren worden deze aan de hand van een unieke systeemfilenaam ondergebracht in bibliotheken. Een bibliotheek is op zichzelf genomen een hoeveelheid gegevens (van files) en als zodanig ook weer ondergebracht in een file die op het achtergrondgeheugen bewaard wordt. Het spreekt vanzelf dat in grotere computersystemen de nodige voorzorgsmaatregelen getroffen moeten worden om de inhoud van de bibliotheken tegen ongewenst gebruik te beveiligen.

Het zou te ver voeren om uitgebreid aandacht te besteden aan de systeemprogrammatuur en de daarmee samenhangende taken. Dit is ook niet nodig omdat het juist de hoofdtaak is van de systeemprogrammatuur de gebruiker en de programmeur in dit opzicht te ontlasten.

Voorbeeld van het gebruik van een computersysteem Laten we eens nagaan wat er zoal komt kijken bij het gebruik van een computersysteem, als we er een door ons zelf ontworpen en geprogrammeerd programma op willen draaien. Programma ontwerpen Nadat de programmeur zijn programma heeft ontworpen en zich er van overtuigd heeft dat het correct is (het programma staat dan nog slechts op papier) biedt hij het aan de computer. Programma in editor zetten Daartoe moet hij het operating system opdracht geven om een tekstverwerker (Engels: editor) aan het werk te zetten. De editor is een systeemprogramma waarmee files aangemaakt kunnen worden die een of andere ingetoetste tekst bevatten. Bijvoorbeeld een programmatekst of een tekst met invoer-gegevens voor een programma. Zo’n editor maakt deel uit van een ontwikkelomgeving voor programma’s.

Eerst moet aan het operating system opdracht gegeven worden om de ontwikkelomgeving op te starten. Daarna kan het programma worden ingetoetst. Fouten corrigeren (I) Bij dit intoetsen worden vaak fouten gemaakt. Het editor programma biedt dan ook faciliteiten om dergelijke fouten te herstellen. Als het intoetsen en verbeteren beëindigd is dan wordt de editor door een opdracht daartoe verlaten en keert het systeem terug in de ontwikkelomgeving. Het programma is nu in de vorm van een tekstfile aanwezig. Deze tekstfile heeft (natuurlijk) een unieke systeemnaam gekregen. Zouden er voor dit programma nog invoergegevens nodig zijn die op file moeten staan, dan wordt opnieuw de editor aangeroepen. Compileren van het programma Nadat het programma is ingetoetst moet het vertaald (gecompileerd) worden. Dit komt doordat een programma geschreven wordt in een hogere programmeertaal als C, Modula of Java, terwijl een computer alleen maar programma’s kan uitvoeren die zijn geschreven in de bij de computer behorende machinetaal.

Machinetalen zijn erg georiënteerd op de hardware van de computer en ongeschikt om algoritmen in te formuleren. Voor het programmeren maken we dan ook gebruik van meer probleemgeoriënteerde talen, de hogere programmeertalen (higher level languages).


De vertaling laten we uitvoeren door een speciaal systeemprogramma dat vertaler of compiler genoemd wordt. Ook een compiler maakt deel uit van de ontwikkelomgeving. Vanzelfsprekend moet daarbij worden meegedeeld welke systeemnaam de file heeft waarin de programmatekst staat. Zo’n vertaler produceert een file met daarin de machinetaalversie van het programma, tenminste als de aangeboden tekst geen fouten bevat. Fouten corrigeren (II) Bevat deze wel fouten tegen de syntaxregels (taalregels) van de gebruikte hogere programmeertaal, dan detecteert de compiler die en geeft in dat geval zogenaamde foutmeldingen. Zo’n foutmelding bevat doorgaans aanwijzingen over het soort fouten dat is gedetecteerd. De ontwikkelomgeving zorgt meestal voor automatische terugkeer in de editor.

Na het aanbrengen van de wijzigingen kan de vertaler weer aan het werk gezet worden. Als de vertaler tenslotte geen fouten meer vindt, dan wordt er (door de vertaler dus) een machinetaalversie van het programma geproduceerd in een file. Linken van het programma Het vertaalde programma kan nu meestal nog niet rechtstreeks verwerkt worden. Eerst moet de zogenaamde linker (weer een ander systeemprogramma dus) nog enkele zaken afhandelen. Bijvoorbeeld het koppelen of toevoegen van subprogramma’s voor in- en uitvoer. Als de linker klaar is dan staat het nu uitvoerbare programma of reeds in het werkgeheugen of wederom in een file. Laden en uitvoeren van het programma In het laatste geval moet het dan nog eerst vanaf het achtergrondgeheugen in het werkgeheugen worden gekopieerd. Dit in het werkgeheugen laden zoals dat heet gebeurt door de lader. En nu pas kan de computer de opdracht gegeven worden om het programma uit te voeren (executeren).

Meestal kan er overigens worden volstaan met het geven van één enkele opdracht (als run of execute) waardoor verder automatisch wordt vertaald (indien nodig na verbetering), gelinkt, geladen en geëxecuteerd.

Groei De opkomst van de computer is er niet één van geleidelijke groei. Het tegenovergestelde is juist het geval: computers worden steeds sneller steeds krachtiger. Dit gaat zo snel dat je wanneer je drie jaar geleden een hypermoderne en zeer snelle (100 Mhz) computer kocht deze vandaag als oud wordt omschreven. Van je aankoopbedrag van enkele duizenden guldens krijg je met veel geluk nu tweehonderd gulden terug!

Onderzoeker Gordon Moore van Intel kwam al in 1965 met een opvallende observatie naar buiten. Hij ontdekte dat de prestaties van computerchips bij elke nieuwe versie ongeveer zijn verdubbeld en dat elke chip ongeveer 18 tot 24 maanden uitkomt na de vorige. Op basis van deze informatie concludeerde hij dat de groei van de mogelijkheden van computers exponentieel is.

Deze observatie is later bekend geworden als de Wet van Moore. Opvallend is dat deze trend zich sinds 1965 nog steeds heeft doorgezet en ook nog op dit moment nog actueel is. Bijvoorbeeld: sinds 1971 is het aantal transistoren op een chip meer dan 3200 keer gegroeid, van 2300 tot 7.500.000.

Ook op andere (computer)gebieden is de groei exponentieel: bijvoorbeeld als het gaat om de snelheid van een computer, de omvang van het externe geheugen en de groei van het aantal websites op Internet. In onderstaande figuur worden de exponentiële groei van het aantal transistoren in een computer en de snelheid geïllustreerd.


Figuur 4 Grafische weergave van de toename van het aantal transistoren en de snelheid van computers


2.2 Het practicum bij module 2

2.2.1 Doelstellingen Aan het eind van het practicum:

• ken je de basisprincipes van en kun je werken met het UNIX besturingsysteem.

• kun je werken in GNOME

• ken je de mogelijkheden van een shell

• ken je de opzet van het hiërarchische bestandsysteem binnen UNIX

• kun je werken met een groot aantal commando’s in UNIX

• kun je werken met een teksteditor

• kun je enkele eenvoudige shell-scripts maken en gebruiken


2.3 Introductie UNIX

2.3.1 Een stukje geschiedenis UNIX is het systeem waarmee binnen de afdelingen Wiskunde, Informatica en Natuurkunde & Sterrenkunde wordt gewerkt. Ook bij de afdelingen Scheikunde en Farmacochemie kun je met UNIX te maken krijgen tijdens het uitvoeren van een eindproject of in de masterfase. Natuurlijk zijn er ook andere systemen denkbaar, maar UNIX heeft al geruime tijd zijn waarde bewezen voor de universitaire omgeving. Een achtergrondartikel over de geschiedenis van UNIX is te vinden op: http://www.bell-labs.com/history/unix/ . Wij gebruiken Linux en Solaris, 2 UNIX varianten die in veel opzichten op elkaar lijken.

UNIX en DOS In tegenstelling tot bijvoorbeeld Microsoft Windows is UNIX van zichzelf geen grafische omgeving waarin je met behulp van de muis kunt manoeuvreren, maar wordt er gebruik gemaakt van commando’s. De grafische laag die op de meeste UNIX systemen wordt gebruikt heet het X Windowing System, kortweg X.

Tijdens je studie zul je zeer veel commando’s leren gebruiken. Tijdens Inleiding Computergebruik leer je enkele (maar lang niet alle) zeer belangrijke commando’s.

Wanneer je wel eens met DOS of Linux hebt gewerkt zul je merken dat er veel overeenkomsten zijn. Hieronder is een tabel opgenomen met enkele veelgebruikte commando’s in UNIX en DOS. Tijdens het practicum zullen we met deze commando’s oefenen.

ACTIE UNIX DOS Maak een directory mkdir mkdir Verander van directory cd cd Geef de inhoud van een directory weer

ls dir

Verwijder een directory rmdir rmdir “Edit” een bestand emacs of vi edit Verwijder een bestand rm del Kopieer een bestand cp <oldfile> <newfile> copy <oldfile> <newfile>

Wijzig de naam van een bestand mv <oldfile> <newfile> rename <oldfile> <newfile>

Toon bestand more <filename> type <filename> | more

Gebruik van handleidingen en help in UNIX De informatie die in deze cursus wordt gepresenteerd is lang niet volledig, een voorzichtige schatting is dat maar 5% van de mogelijkheden van UNIX aan bod komt. Een handleiding over UNIX waarin alle mogelijkheden worden besproken is vele honderden pagina’s dik!

Toch zul je als je deze module hebt doorlopen redelijk met UNIX uit de voeten kunnen. Het is daarna belangrijk om regelmatig zelf op zoek te gaan naar de informatie die je nodig hebt. Je kunt dat doen door die dikke boeken te gaan lezen. Een andere mogelijkheid is om de manual-pages te raadplegen die al in UNIX zijn ingebouwd. Hoe je dat moet doen staat beschreven in hoofdstuk “


Enkele eenvoudige commando’s” van deze module.

Belangrijk is dat je je realiseert dat je met UNIX zeer veel kunt doen. Alleen door jezelf steeds vragen te blijven stellen en de antwoorden in de manuals op te zoeken leer je UNIX echt goed gebruiken.

Een goede houding is om er steeds vanuit te gaan dat binnen UNIX alles kan. Slechts zeer zelden zul je merken dat deze uitspraak toch niet helemaal waar is.

2.4 Desktop-omgevingen onder UNIX Wanneer je inlogt in UNIX (zie module 1) verschijnt over het algemeen een scherm dat eruit kan zien als het onderstaande: het GNOME scherm. GNOME is op een soortgelijke manier opgebouwd als Windows. Op het bureaublad staan snelkoppelingen er is een menu van waaruit programma’s gestart kunnen worden en draaiende programma’s verschijnen als knoppen.

De werking van GNOME Zoals eerder opgemerkt, kun je onder UNIX ook met GNOME in plaats van CDE werken. In deze paragraaf gaan we nader in op enkele onderdelen van deze omgeving.

Panelen Veel handelingen kun je verrichten met behulp van de GNOME-panelen. Hiernaast zie je hoe een paneel eruit kan zien.

Als je wilt kun je een paneel verbergen door op een pijltje te klikken dat zich aan de uiteinden bevindt.

Er zijn meerdere soorten panelen: gewone panelen en een menu panel. Er is maar één menu-panel, die is niet verplaatsbaar en dit bevat onder andere het GNOME-hoofdmenu (met het voetje). Er zijn al een aantal nuttige programma’s in dit menu voor je ingesteld.

Veelgebruikte programma’s kun je toevoegen aan een paneel zodat je er snel bij kunt. Klik daarvoor met de rechtermuisknop op een leeg stukje van een paneel. In het contextmenu dat verschijnt staat (Panel →) Add to Panel → Launcher from Menu →. Beweeg met je muispijl door de submenu’s heen om de launcher, oftewel de naam van het programma, die je wilt toevoegen te vinden. Een object op het paneel kan weer verwijderd worden door er met de rechtermuisknop op te klikken en Remove from panel te kiezen uit het contextmenu.


Vensterlijst

Helemaal rechtsboven in het scherm vind je een knop die met een pictogram aangeeft welk programma momenteel de aandacht (focus) heeft. Wanneer je op deze knop drukt zie je een lijst van alle programmavensters die op dat moment open zijn. Door op een item in de lijst te klikken ga je naar het corresponderende programma toe.

Werkbladwisselaar

Hiernaast zie je hoe de werkbladwisselaar (ook wel pager genoemd) eruit kan zien. Het idee is dat je meerdere “virtuele” werkbladen tot je beschikking hebt in plaats van slechts één. In situaties waar je veel vensters tegelijkertijd geopend hebt, zoals tijdens programmeerpractica, kan dit je helpen het overzicht te

bewaren. Op de eerste drie werkbladen staan vensters, op de vierde niet. Klik met de muis op een werkblad om ernaartoe te schakelen.


2.5 De (UNIX-) shell De server-computers bij FEW aan de VU werken allemaal onder het bedrijfssysteem UNIX (wettig gedeponeerd handelsmerk van Bell Laboratories).

Functies van de shell Shell is de naam van het programma dat de commando’s van je scherm leest of ontvangt en zorgt dat de commando’s worden uitgevoerd. Er zijn verschillende soorten shells en als je een loginnaam krijgt toegewezen wordt daarmee een van die typen shells aan jou verstrekt. In principe werken we met de Bash-shell. De shell is niet alleen een programma dat je commando’s interpreteert, maar begrijpt ook een speciale shell-programmeertaal. Tijdens het vak Inleiding Programmeren zul je nog uitgebreid met deze functie van bash kennismaken.

Van de shell zijn verschillende versies in omloop. De originele versie, de zogenaamde Bourne shell, heet sh. Als student krijg je meestal de Bourne-again shell, ofwel ‘bash’2. Deze lijkt in heel veel aspecten op ‘sh’ maar kan ook een aantal handige dingen meer. Zo probeert bash als je tijdens het intikken van een commando op de TAB toets drukt zo goed mogelijk waar je mee bezig was voor je af te maken. Als je dus een file met een heel lange naam zou willen bewerken bv. ‘dit_is_een_file_met_een_hele_lange_naam’ kun je na het intikken van ‘dit’ (maar voordat je op return drukt) op TAB drukken waarna de shell de naam voor je afmaakt, vooropgesteld dat er in je directory geen andere file is die zo begint. Als die wel zou bestaan geeft bash de verschillende mogelijkheden en kun je wat karakters aan de filenaam toevoegen om de keuze duidelijk te maken.

Verder beschikt bash over een geheugen: er wordt onthouden welke commando’s je allemaal al hebt ingetikt. Met behulp van de pijltjestoetsen kun je door de lijst van opdrachten wandelen en het geschikte commando opnieuw laten uitvoeren. Dit kan je een hoop denkwerk schelen bij meer ingewikkelde commando’s.

Er zijn nog meer zaken waarop sh en bash verschillen, maar bovengenoemde mogelijkheden kunnen je al heel wat tikwerk besparen.

Gebruik nooit twee shells door elkaar, dit kan door de verschillen behoorlijk verwarrend zijn. Over het algemeen is het is beter eerst één shell heel goed te leren kennen en eventueel later over te stappen.

De shell opstarten

Een GNOME Terminalvenster kun je openen door op het hiernaast afgebeelde pictogram in het paneel/GNOME menu te klikken.

Er verschijnt nu een schermpje waarin je commando’s kan intikken.

2Uitgebreide documentatie voor bash is te vinden op http://www.gnu.org/software/bash/bash.html .


2.6 Enkele eenvoudige commando’s Voor het werken met de shell gebruiken we shell-commando’s. In dit hoofdstuk komen enkele eenvoudige, maar veelgebruikte commando’s aan de orde.

Passwd, Date, who, ls, lpr en man Commando’s zoals passwd, date, who, ls en man worden ook wel shell-commando’s genoemd. In de loop van deze module kom je nog een aantal andere shell-commando’s tegen. Een overzichtje van nuttige shell-commando’s staat achterin de handleiding van Inleiding Programmeren (appendix A).

Zorg ervoor dat je een window hebt waarin een shell draait (zie het vorige hoofdstuk). Plaats de muiswijzer binnen het window zodat je commando’s kunt invoeren.

Iedere opdracht die je aan de computer geeft moet altijd met de toets waar ENTER op staat afgesloten worden. Dat is het teken dat jij klaar bent met intikken en dat de computer nu aan het werk moet met jouw commando. Als je geen ENTER intikt gebeurt er dus niets. We zullen dat van nu af aan er niet meer bij vertellen. Als je je afvraagt of het klopt dat er niks gebeurt, geef dan nog een keer ENTER, misschien was je het vergeten (teveel keer kan nooit kwaad).

Linksboven in het window staat op de onderste niet-blanco regels de prompt (een $ of een %, afhankelijk van de instellingen van je shell) gevolgd door de cursor. De prompt geeft aan dat de computer klaar is met het verwerken van je vorige opdracht. Je zou het inloggen dus kunnen beschouwen als het eerste commando dat jij aan de computer gegeven hebt. Achter de prompt kun je opdrachten voor UNIX intikken.

druk op ENTER Als dat het enige is wat je doet, je hebt dus geen commando ingetikt, dan wordt dit verstaan als “Voer geen opdracht uit’’. Daar is het systeem (vrijwel) meteen mee klaar, en je wordt daarvan op de hoogte gesteld door de volgende prompt.

Password wijzigen Het password dat je van de afdeling systeembeheer hebt gekregen is meestal een ingewikkeld, moeilijk te onthouden password en bovendien op het moment dat je het krijgt niet alleen aan jou bekend (immers ook aan systeembeheer). Omdat het niet verstandig is je password in je agenda te schrijven (het zou gestolen kunnen worden), is het handig je password te wijzigen in een voor jou wel makkelijk te onthouden password. Ook wanneer je denkt dat iemand achter je password is gekomen kun je dit het beste wijzigen.

passwd

Er wordt eerst gevraagd om je oude password in te tikken, dit om te controleren of jij het wel bent. Bedenk nu een nieuw password. Wacht met het intypen van het password totdat de computer daar om vraagt. Een password moet tenminste 6 karakters of tekens en maximaal 8 karakters of tekens lang zijn, en bij voorkeur niet alleen kleine letters bevatten maar ook hoofdletters en tekens als [, %, en &. Passwords met alleen kleine letters zijn makkelijker te kraken en passwords die alleen uit een voornaam of een straatnaam bestaan zijn voor een beetje computerinbreker helemaal kinderspel.

Let op: een te makkelijk password of een die te veel op het oude lijkt wordt automatisch geweigerd. Zie de manual-page voor meer informatie.

Wacht niet te lang met het veranderen van je password, want na een aantal weken zorgt systeembeheer er voor dat de logins van studenten die hun password niet hebben veranderd worden geblokkeerd.


Een goede manier om een password te bedenken is een zinnetje te nemen waar niet alleen letters in voorkomen maar bijvoorbeeld ook haakjes, cijfers, komma’s enzovoorts. Door dan de eerste letters van de woorden achter elkaar te zetten en ook wat leestekens mee te nemen heb je een vrij moeilijk te kraken password.

N.B. Onthoud dit password, want anders kun je de volgende keer niet meer inloggen.

date

date

De computer geeft de datum en het tijdstip. Ten teken dat de opdracht uitgevoerd is verschijnt op de volgende regel dus weer een prompt.

who

who

Het resultaat is een lijst van personen die op dit moment op de computer zijn ingelogd. Ook is de tijd te zien waarop ze hebben ingelogd en hoe de terminal heet waarop ze werken. Wanneer je op een Windows-machine of een workstation bent ingelogd dan wordt na dit commando alleen je eigen naam genoemd. Dit komt omdat op een Windows-machine of een workstation maar één persoon tegelijkertijd kan inloggen, terwijl je via terminals met een aantal mensen op hetzelfde systeem werkt.

Wanneer de uitvoer meer dan een scherm beslaat kun je dat scherm voor scherm (of regel voor regel) bekijken, door de commando’s more, yap of less aan het commando who mee te geven.

who | more

Het “|”-teken heet een pipe. Je vindt het meestal naast de BACKSPACE-toets op je toetsenbord (met SHIFT). Meer over pipes in paragraaf 0. Met more wordt zoveel van een file afgedrukt tot het scherm vol is. Door op ENTER te drukken worden nieuwe regels weergegeven, met de spatiebalk verschijnt een nieuwe pagina. Wanneer alle regels zijn afgedrukt keer je automatisch terug naar de prompt. Met q (quit) kun je tussendoor terugkeren naar de prompt.

who | yap

Het commando yap (yet another page) drukt ook de eerste pagina van de output af. Met ENTER kun je de pagina regel voor regel laten verschijnen. Druk op h (HELP) om een lijst te krijgen van alle opties die er zijn om binnen de output te navigeren. Met q kan je terugkeren naar de prompt.

ls

ls

Iedere gebruiker heeft een zogeheten home directory, een eigen map in het externe geheugen waar je automatisch terechtkomt als je inlogt (hierop komen we later nog terug). Die plaats wordt door systeembeheer ingesteld en aangemaakt. Het adres van je home directory is: /home/loginnaam , ook aan te duiden met ‘~’ .Wanneer je het commando ls geeft en op Enter drukt, dan wordt de inhoud van je home directory getoond. Als dit de eerste keer is dat je inlogt, zullen er nog geen bestanden zichtbaar zijn.

Aan een commando kun je in het algemeen twee soorten argumenten toevoegen:

1. argumenten die bepalen op welke manier het commando wordt uitgevoerd (zgn. opties). Deze argumenten beginnen met een ‘-’, en heten ook wel ‘vlaggen’. Bijvoorbeeld:

ls -l (dit is geen één, maar een L)


Optie -l bepaalt dat niet alleen de namen van de files worden afgedrukt maar ook een aantal nadere gegevens, zoals de soort file, de grootte, de naam van de eigenaar, wat je er mee mag doen en het laatste moment van wijziging. Je hebt dus een commando en je kunt daarachter argumenten/vlaggen zetten (gescheiden door spaties) die meestal met ‘-’ beginnen, maar soms ook met ‘--’.

ls -a

Dit commando toont alle files in je huidige (in dit geval home-) directory. Er zijn namelijk al een paar files voor je aangemaakt door het systeem. De namen daarvan beginnen met een punt. Je home-directory wordt aangegeven door een . (punt).

Wat ook werkt is dit:

ls -al

(een combinatie van ‘ls -a -l’). Welke mogelijkheden er allemaal zijn bij ‘ls’ kun je vinden in de handleiding van ls, zie paragraaf 0.

2. argumenten die bepalen waarop het commando wordt uitgevoerd. Stel je even voor dat er zich in de directory waar je op dat moment bent een file bevindt met de naam fred.

ls –l fred

Je krijgt dan niet van alle files de bovengenoemde gegevens te zien, maar alleen die van de file fred. Omdat je nog geen file hebt met de naam fred wordt dit je keurig meegedeeld.

Vergelijk de output van ls met het overzicht wat je krijgt met de File Manager van je desktop environment (paragraaf 0). Vergelijking de View met optie Hidden Objects aan met ls –al. Vergelijking de View met optie View by tree met ls –lR.

lpr Het printen van files kan met het commando lpr gevolgd door de filenaam.

Alleen Wiskunde en Informatica: omdat je maar een beperkt printbudget hebt zullen we je niet vragen dit commando uit te voeren. Uitdraaien gaan standaard naar de grote Océ-laserprinter (Pen genaamd) op de vierde etage.

Het commando pbudget geeft aan hoeveel pagina’s je nog kunt printen. Wanneer je pbudget -all doet krijg je een overzicht van alle pagina’s die je geprint hebt met een aanduiding wanneer dat was.

Kijk achterin de Appendix voor meer informatie over welke opdrachten je kunt geven die met afdrukken te maken hebben.

man We hebben je er al gewezen dat het kunnen hanteren van de manuals van groot belang is voor het leren werken met UNIX. De manual roep je op door het commando man met als argument het onderwerp waarover je meer informatie wilt

man ls

Je komt nu in een aparte help-file terecht. Vaak past niet alle informatie op één scherm: met de pijltjestoetsen kun je door het document lopen. Met de spatiebalk spring je naar de volgende pagina. Met q (quit) verlaat je de manual en keer je terug naar de prompt van de shell.


Een commando afbreken Soms kan het voorkomen dat je een commando wilt afbreken voordat het volledig uitgevoerd is. Dat doe je door de control toets (meestal linksonder op het toetsenbord met afkorting CTRL) in te drukken, deze vast te houden en de c in te drukken.

who

Zodra de lijst met loginnamen begint:

druk je op CTRL-c

De computer breekt het commando dan af, en antwoordt weer met een prompt.

2.7 Werken met directories Directories zijn te vergelijken met grote multomappen waarin verschillende soorten documenten (files) zitten. Bijvoorbeeld notities, memo’s, schetsen en berekeningen. De vergelijking met een multomap gaat echter niet helemaal op, omdat een directory ook weer verschillende sub-directories kan bevatten. Dit is in het echt natuurlijk niet mogelijk.

Het UNIX-systeem heeft een hiërarchisch filesysteem, dit houdt in dat directories en files in relatie tot elkaar zijn georganiseerd.

Directories maken, de inhoud bekijken en veranderen van directory Als je steeds meer files maakt en geen verdere actie onderneemt zal je home-directory heel onoverzichtelijk worden. Zo’n handelwijze zou overeenkomen met het op één grote stapel leggen van alle papieren die je ontvangt zodat je tenslotte in die stapel niets meer kunt terugvinden. Als je dat beter wilt beheren doe je er verstandig aan om bij elkaar horende spullen ook bij elkaar te bewaren. In het UNIX filesysteem kan dat gelukkig ook. Je kunt nieuwe directories maken met het commando mkdir (make directory). Achter dit commando typ je de naam van de directory die je wilt aanmaken.

Je kunt bijvoorbeeld een directory maken waarin je je files kunt zetten die je maakt bij het practicum Inleiding Computergebruik. De naam die je voor die directory zou kunnen gebruiken is icg.

mkdir icg

In je home-directory is nu een sub-directory met de naam icg gemaakt.

ls

Je ziet de directory icg die je net hebt aangemaakt staan.

mkdir ip1

ls


Je hebt nu alvast een directory aangemaakt waarin je de bestanden van het vak Inleiding Programmeren, dat binnenkort start, kunt plaatsen. Met het commando ls zie je nu de twee subdirectories icg en ip1 staan. Schematisch kunnen je je dit zo voorstellen:

Dit proces van creëren van directories kun je verder doorzetten. Ook in de directory icg kun je weer directories maken enz. Je krijgt op deze manier een (omgekeerde!) boom van directories. Aan de uiteinden van de takken zitten de bladeren (de files) waarin gegevens staan. Over files meer in het volgende hoofdstuk. Het hele filesysteem van UNIX is dus in boomvorm georganiseerd. Uiteraard is jouw homedirectory niet de belangrijkste file in het hele systeem (behalve dan misschien vanuit jouw optiek). Ook boven jouw directory bevindt zich een hele boom van directories. Het startpunt van de hele boom is de zogenaamde ‘root’, die wordt aangeduid met het teken ‘/’. Deze wortel bevindt zich volgens het spraakgebruik van de informatica bovenaan de boom. Zoals je misschien al had gemerkt groeien in de informatica de bomen op hun kop!

Via het commando cd (change directory) kun je door een groot gedeelte van de boom wandelen. Sommige delen van de boom zijn echter niet voor iedereen toegankelijk, je kunt deze directories dan ook niet bekijken.

cd icg

Homedirectory: ~ je VU-net ID

icg ip1

/

cache ............ home tmp usr

home-directory: ~loginnaam

icg ip1

etcetera etcetera

etcetera


Met het commando cd verplaats je dus je werkdirectory (de directory waarmee je aan het werk bent) naar die nieuwe directory. Je stapt als het ware de directory binnen en kunt daar vanaf nu subdirectories en files bekijken en maken.

ls

Via ls kun je weer bekijken welke documenten of sub-directories er aanwezig zijn in de directory icg. Hij is natuurlijk nog leeg.

Je kunt altijd direct terug naar je home-directory met het commmando cd ~ (~ is de naam van jouw home directory). De home directory van een andere gebruiker, bv. van piet wordt aangegeven door ~piet). Een andere mogelijkheid om naar je home directory te gaan is door het tikken van cd zonder argument.

Ga terug naar je homedirectory.

De directory ‘boven’ de directory waar je bent wordt de parent directory van die directory genoemd. Een parent directory wordt in UNIX aangegeven met ‘..’. Met ‘.’ wordt de directory aangegeven waar je op dat moment bent. Je kunt één stap teruggaan in de directory-boom door het commando cd .. te gebruiken.

Ga naar de parent directory van je home-directory. Bekijk welke documenten en/of subdirectories in deze directory te vinden zijn.

Gebruik hiervoor het commando ls -l. Als het goed is zie je je eigen home-directory staan met al zijn eigenschappen. De home-directories van je medestudenten zijn ook te zien.

Ga naar je home-directory. Met het commando ls -l icg krijg je informatie over wat er in de directory icg staat. Ga met behulp van de manual na welke optie je aan ls kunt meegeven zodat niet de inhoud maar de eigenschappen van de directory worden getoond.

De weg kwijt?? Wanneer je de weg kwijt bent en niet meer precies weet in welke directory je je bevindt dan kun je dat vragen aan UNIX met het commando pwd (Print Working Directory).

Ga terug naar je home-directory

pwd

Wat wordt afgedrukt is de volledige padnaam (pathname) van de directory waar je op dat moment bent. De naam ontstaat door achter elkaar alle directories (gescheiden door het symbool ‘/’, de zogenaamde slash) op te schrijven die je vanaf de root moet doorlopen om bij de huidige directory te komen: dus via / kom je bij de sub-directory home en daarna bij je home-directory. Oftewel: /home/jeloginnaam.

Wanneer een padnaam begint met een “/” wordt vanuit de root directory naar die file gezocht, we noemen dit de absolute padnaam. Wanneer een padnaam niet begint met een “/’’ wordt naar de file gezocht vanuit de directory waarin je je bevindt, dit is de relatieve padnaam. Relatieve en absolute namen onderscheiden zich dus doordat de absolute namen beginnen met een slash, en de relatieve juist niet.


Het kan natuurlijk voorkomen dat je een file zoekt die ergens op de schijf staat, maar waar? Het volgende commando begint te zoeken in de huidige directory (daar staat het puntje ‘.’ voor) en zal afdrukken waar de file met de naam ‘verhaaltje’ staat.

find . –name verhaaltje

Je kunt altijd teruggaan naar je home directory met het commando cd

Let op: in andere systemen (MS-DOS of Windows) wordt voor de slash ‘/’ het teken ‘\’ (backslash) gebruikt. Dit teken heeft binnen UNIX een andere betekenis.

Binnen UNIX mogen in een directory- of filenaam geen spaties voorkomen, behalve als je er quotes om plaatst (bijvoorbeeld: “a b”) of een backslash voor zet.


2.8 Werken met files Een file is een bestand ergens in het geheugen van de computer. Alle informatie in de computer en de daarbij behorende geheugensystemen is georganiseerd in de vorm van files. In feite kunnen ze niet alleen tekst bevatten maar ook computerprogramma’s in machinetaal.

Zorg ervoor dat je in je home-directory staat.

cp /usr/prac/ip/file icg/mijnfile

Let er op dat er een spatie is tussen cp en de eerste slash(/).

Met dit commando kopieer je het bestand met de naam file dat staat in de subdirectory ip van de subdirectory prac van de subdirectory usr van de root.

Met icg/mijnfile geef je aan waar je deze file precies wilt neerzetten (gerekend vanaf de directory waar je je op dat moment bevindt, in dit geval je home-directory) en hoe je hem noemt: je plaatst hem in de subdirectory icg en je geeft het oorspronkelijke bestand file nu de naam mijnfile.

cd icg

ls

De file mijnfile staat in de subdirectory icg

De inhoud van een file kun je bekijken met het commando cat.

cat mijnfile

UNIX antwoordt met de inhoud van de file. Deze bestaat uit drie regels tekst.

cp mijnfile file2

Nu heb je twee files met identieke inhoud. Je kunt dat controleren door met cat de beide files te bekijken.

diff mijnfile file2

De computer schrijft alle regels op het scherm die niet gelijk zijn in beide files (in dit geval nul regels).

Het is mogelijk files van naam te laten veranderen. Daarvoor is het commando mv (“move’’).

mv mijnfile rommel

Stel vast met het commando ls dat de file nu rommel heet.

Het verwijderen van een file gaat met het commando rm (“remove’’).

rm rommel

Ga na dat deze inderdaad verdwenen is. Kijk altijd uit met het gebruik van het remove-commando. Als je een file hebt weggegooid is deze onherroepelijk verdwenen. Er bestaat niet zoiets als een prullenbakje waaruit je nog wel weer je documenten kunt opvissen.

2.9 Meer commando’s In dit hoofdstuk laten we de werking zien van enkele veelgebruikte commando’s. We geven slechts een korte uitleg over deze commando’s. Wanneer je meer wilt weten over de mogelijkheden van een commando maak dan gebruik van de manual.


Commando’s combineren De shell kan nog veel meer dan regel voor regel commando’s uitvoeren. Zo kun je twee commando’s op een regel combineren door ze, gescheiden door een puntkomma achter elkaar te zetten

who;date Nu worden achtereenvolgens de personen die ingelogd zijn en de datum en tijd afgedrukt.

Speciale tekens Er zijn een paar karakters, die in de shell een speciale betekenis hebben. ? betekent ieder willekeurig karakter

* betekent nul of meer willekeurige karakters

Deze worden ook wel wildcards (jokers) genoemd.

?

ls f?le2

Er wordt hier gezocht naar alle files in de directory waar deze beschrijving op past (het is er maar één: file2).

* Het is niet altijd nodig om de volledige naam van een file als argument aan een commando mee te geven. Je kunt een soort kortschrift gebruiken waarbij het systeem zelf aanvult wat je niet hebt meegegeven. De aanduiding m* in een commando betekent: “alle files in de directory die beginnen met een m’’. Een enkele “*’’ is een kortere schrijfwijze voor “alle files in de directory”. Ze mogen ook in combinatie gebruikt worden.

Voorbeeld 1:

ls /u*/pr??/ip/?anton*

Er blijken twee files te zijn die aan deze beschrijving voldoen.

Voorbeeld 2:

Neem even aan dat je in je directory een aantal versies hebt staan van een bepaald programma dat je aan het schrijven bent, die je allemaal zou willen afdrukken (niet iets om in werkelijkheid aan te raden want misschien wel een flinke hap uit je printerbudget).

prog prog1.1 prog1.2 prog1.3 prog1.4 prog2

Je kunt dat doen door het commando lpr prog*. Alle files waarvan de naam begint met ‘prog’ worden dan naar de printer gestuurd. De * staat dus voor een willekeurig aantal tekens.

Die speciale betekenis van ? en * kun je weer omzeilen door de naam waar ze in voorkomen tussen enkele aanhalingstekens te zetten zoals bv. in ls ‘?’. Hiermee wordt alleen de file gemeld waarvan de naam ook werkelijk ? is.


Redirectie van invoer en uitvoer De meeste commando’s die we tot dusver hebben gezien produceren output op het beeldscherm. Sommige vragen ook om input vanuit het toetsenbord. Je kunt in UNIX de input of output ook altijd uit een file halen of naar een file wegschrijven.

Je kunt de output van ls bijvoorbeeld naar een file sturen in plaats van naar het scherm.

ls > naarfile

cat naarfile

De output van ls komt nu in de file naarfile terecht. Wanneer de file naarfile nog niet bestaat wordt die aangemaakt. Als de file al wel bestaat is de oude inhoud nu verdwenen!! Pas daarmee op! Als je wilt dat de output van het commando niet de gegevens in de file vervangt, maar ze er achter plakt dan kun je >> in plaats van > gebruiken.

date >> naarfile

cat naarfile

Op dezelfde manier kun je een programma dat invoer van het toetsenbord verwacht in plaats daarvan uit een file laten lezen door achter het commando een < teken en de naam van de file te zetten.

Pipes Het commando who vertelt wie er ingelogd zijn op de machine waarop jij op dat moment aan het werk bent. Veronderstel dat je die lijst zou willen bekijken met yap; dat kan door de output van who eerst naar een file te sturen en daarna die file met yap te bekijken:

who > temp

yap temp

In UNIX bestaat de mogelijkheid om dit proces te stroomlijnen door middel van een zogenaamde pipeline of pipe: je geeft de output van het ene commando (who) mee als input voor het tweede commando (yap) door ze achter elkaar te zetten met een ‘|’ (verticaal streepje) symbool ertussen.

who | yap

Het resultaat is hetzelfde als hierboven, alleen wordt de file temp niet gecreëerd of gewijzigd. Het voorkomt dus dat je veel tijdelijke files moet aanmaken die je later weer moet weggooien. Yap sluit je overigens af met de letter q.

Kijk erg goed uit bij het gebruik van * bij het weggooien van files. Of liever nog, gebruik het dan helemaal niet. Als je bedoelt rm *2 (gooi alle files weg die op 2 eindigen) maar je tikt per ongeluk rm * 2 (met een spatie tussen de * en de 2), betekent dat: gooi alle files weg, en bovendien de file 2. Het systeem klaagt dan dat de file 2 niet bestaat, nadat (zoals je zelf hebt opgegeven) al je files zijn weggegooid!


Grep Een heel handig commando is grep (afkorting van: Get Regular ExPression). Grep doorzoekt een file naar een woord of een combinatie van karakters dat je opgeeft en drukt de regels waarin dit woord voorkomt af.

grep drie file2

Het resultaat is dat de regel in de file file2 waarin het woord drie voorkomt wordt afgedrukt. Geef dus altijd eerst aan welk woord je zoekt en daarna in welke file.

Het kan zijn dat je in een file een bepaalde naam zoekt, maar dat je niet weet of die wel of niet met hoofdletters is geschreven. Je kunt dan aan grep een extra optie meegeven zodat naar beide mogelijkheden wordt gezocht. Ga met behulp van de manual na hoe je dit moet doen.

Vul in: De optie om zowel naar hoofd- als kleine letters te zoeken is: ___________

Ga na hoe je kunt zoeken naar regels waarin een woord NIET voorkomt. Druk hierbij ook de regelnummers af. Laat je methode controleren door de student-assistent.

Sorteren Sort is een commando dat de regels van een file (bv. een file met namen) alfabetisch lexicografisch sorteert en het resultaat afdrukt.

sort file2

Het resultaat van deze sorteeractie komt op je beeldscherm. Je kunt dit resultaat echter ook in een nieuwe file zetten:

sort file2 > alfa

Controleer dat er een file met de naam alfa is gemaakt. Bekijk de inhoud.

Ga met behulp van de manual na:

1) hoe je de file in omgekeerde volgorde kunt sorteren

2) hoe je de gegevens in de oorspronkelijke ongesorteerde file kunt vervangen door de gesorteerde gegevens met behulp van een hulpfile

Wanneer je geen tweede argument (in dit geval mijnfile) meegeeft aan grep dan wordt er gezocht in de inputfile, oftewel datgene wat jij op je terminal intikt. Er wordt net zolang gezocht totdat jij de inputfile sluit. Zolang je de file niet gesloten hebt blijft grep zoeken in de inputfile en is je terminal niet beschikbaar voor iets anders! Sluiten van de file gaat met CTRL-d.

Pas op met sort lijst > lijst. Als je dat doet wordt de inhoud van lijst eerst weggegooid (altijd bij redirectie) waarna er niets meer te sorteren is, en je al je gegevens kwijt bent. Experimenteer alleen met files waarbij het niet erg is als je de inhoud kwijt raakt!


De volgende moeilijke opgave is niet verplicht, maar wel een uitdaging!

3) hoe je de gesorteerde gegevens zonder een hulpfile in de oorspronkelijk ongesorteerde file kunt krijgen

Vul hier je antwoorden in laat deze controleren door de student-assistent:

1) ____________________________

2) ____________________________

3) ____________________________

Met meer programma’s tegelijk werken

Processen op de achtergrond zetten Tegelijkertijd met verschillende programma’s werken heeft als voordeel dat je bijvoorbeeld ingewikkelde berekeningen die veel tijd kosten kunt uitvoeren terwijl je tegelijk je verslag aan het schrijven bent.

xcalc&

ipe&

xcalc is een rekenmachine. ipe is een uitgebreide tekst-editor. Met de editor leer je werken in het volgende hoofdstuk. Door achter de naam van het programma een & te zetten geef je aan dat je deze applicatie wilt starten terwijl je ook met de andere programma’s blijft werken. De programma’s worden ieder in een afzonderlijk window geopend. Door op de applicatie te klikken waarmee je wilt werken haal je deze naar de voorgrond en kun je gegevens invoeren.

Mocht je een programma gestart hebben zonder een ampersand (&) erachter, dan zit je terminal nog niet op slot. Gebruik CTRL+Z om je programma te pauzeren en je prompt terug te krijgen, en het commando bg (background) om het op de achtergrond verder te laten werken.

Processen beheren De uitvoer van het jobs commando toont de processen die je al in de shell had opgestart, en hun status (gestopt, draaiende enzovoort).

jobs

Stel nu dat je het eerst opgestarte proces, xcalc, weer naar de voorgrond wilt halen. jobs geeft dit proces waarschijnlijk aan met een [1] ervoor. Je adresseert het xcalc-proces dan met %1 en geeft dat mee aan fg:

fg %1

UNIX geeft aan elke applicatie een process-id, waarmee de draaiende programma’s kunnen worden geïdentificeerd. Niet alleen de programma’s die je toevallig in de shell had gestart vallen hieronder, maar alle processen die op de computer actief zijn.

ps -a

Met het commando ps -a (Process Status) krijg je een overzicht van de processen die op de achtergrond draaien met hun process-id (PID).


Wanneer je een proces geforceerd wilt stoppen, bijvoorbeeld omdat deze niet meer normaal af te sluiten valt, gebruik je het commando kill -9 gevolgd door het PID.

Sluit een programma door eerst de lijst van processen op te vragen, en vervolgens het juiste proces te killen. Bijvoorbeeld:

kill –9 516

waarna het bijbehorende proces stopt. Kill begrijpt ook de %-notatie.

Rijmwoordenboek In dit onderdeel is het de bedoeling dat je zelf een rijmwoordenboek bouwt. De manier waarop dit kan is al gedeeltelijk voorgedaan op de sheets van het college van A. Tanenbaum die je achterin dit dictaat kunt terugvinden.

We gaan er vanuit dat je je nog steeds in de shell bevindt.

/usr/dict/words is een file “words” dat staat in directory /usr/dict . We willen graag weten uit hoeveel losse woorden deze file bestaat. Het commando wc doet een word count.

Ga met behulp van de manual na wat volgens wc de definitie van een word is. Probeer het hieronder in je eigen woorden uit te leggen:

wc /usr/dict/words

Wat is de uitvoer van dit commando?

Bekijk met behulp van more eens de file ‘/usr/dict/words’

more /usr/dict/words

Wat is het verschil tussen hoe het more-commando hier wordt gebruikt en hoe het wordt gebruikt in paragraaf 0?

De manual-page van het commando rev ziet er als volgt uit:

rev Command Purpose Reverse characters in each line of a file.

rev < /usr/dict/words > outfile

Wat doet dit commando? (Hint: zie paragraaf 0).

Controleer of wat je hebt opgeschreven inderdaad klopt door de file outfile met more te bekijken.

Bedenk nu een samengesteld commando dat een file ‘rijmwoordenboek’ als uitvoer heeft, en de file ‘/usr/dict/words’ als invoer. De file ‘rijmwoordenboek’ moet alle woorden uit ‘/usr/dict/words’ bevatten en gesorteerd zijn op woorduitgang. Maak gebruik van een pipe .

Oplossing:


2.10 Werken met een editor

Wat is een editor Je gaat nu zelf een file “editen” (bewerken) met een zogeheten editor. W & I maakt gebruik van de editor met de naam jEdit. Alleen de manier waarop de editor wordt opgestart en de vormgeving van het window zijn verschillend, de eigenlijke werking van het programma is daarna nagenoeg gelijk.

Eenvoudig gezegd is een editor een applicatie om tekst in een file te zetten en te veranderen. Aangezien je nog veel met de editor zult moeten werken, is het belangrijk om deze paragraaf goed door te nemen. Appendix D in de syllabus van Inleiding Programmeren geeft je een handig overzicht van vaak gebruikte toetscombinaties.

cd

Terug naar je home-directory.

cd icg

De directory van Inleiding Computergebruik die je net hebt aangemaakt.

cp /usr/prac/ip/maan maan

Je hebt nu een kopie gemaakt van de file met de file maan in de sub-directory ip naar de directory icg en je hebt hem maan genoemd.

De editor jEdit opstarten Met een editor kun je zowel bestaande files veranderen als nieuwe files creëren. We gaan de editor eerst gebruiken om een bestaande file te veranderen; hoe je nieuwe files creëert wordt verderop uitgelegd.

Er wordt voor het practicum Inleiding Programmeren gebruik gemaakt van de editor jEdit. jEdit is goed uitgerust om met de programmeertaal Java om te gaan. Java is de programmeertaal die in het Inleiding Programmeren practicum gebruikt wordt. Er is een gemakkelijk te onthouden commando ipe (Inleiding Programmeren Editor) dat jEdit voor je opstart.

jEdit opstarten onder UNIX

Zorg ervoor dat je een terminalvenster open hebt staan

Het shell commando ipe roept de editor jEdit aan. Typ in het terminalvenster het volgende in:

ipe maan

jEdit opstarten onder Windows Zit je achter een Windows computer, dan werkt jEdit sneller wanneer je het direct via Windows opstart, in plaats van via UNIX (Cygwin-X). Hiertoe moet je het programma IPE uitvoeren dat zich in je Startmenu bevindt. Open nu het bestand h:\icg\maan (zie paragraaf 2.11 over het openen van een file).

De H:\ schijf onder Windows is dezelfde directory als je home directory onder UNIX.


Het beginscherm Het opstarten duurt even, afhankelijk van achter welke computer je zit duurt dit enkele seconden tot ongeveer een halve minuut. Je krijgt een scherm zoals hieronder. De file maan blijkt een bekend lied te bevatten. Alleen zijn er op onverklaarbare wijze een paar fouten ingeslopen die we gaan herstellen. Boven het tekstgedeelte zie je de Buffer Switcher, een balk waarin staat met welke file je op dit moment bezig bent.

Onderaan het venster zien we een balk, die de status bar wordt genoemd. In deze balk staat onder andere de regel en kolom waar de cursor zich bevindt.

Belangrijke toetsen: CTRL en ALT Er zijn twee belangrijke toetsen die je veel zult gebruiken, CTRL (control) en ALT. De CTRL toets zit meestal linksonder op het toetsenbord. De ALT-toets zit ernaast. Soms zit naast ALT een toets met een ◊ (ruit/diamant) erop. Dit is de META-toets die in sommige UNIX-programma’s gebruikt kan worden.

De notatie CTRL-a betekent: druk de CTRL toets in, houdt deze toets vast en druk op ‘a’.

Noodrem Bij het gebruik van een nieuw instrument is het altijd nuttig om te weten waar de noodrem zit. Wanneer er iets mis gaat probeer dan de Escape-toets (helemaal linksboven op je toetsenbord, met het opschrift Esc).

We doen nu even expres iets fout en corrigeren de fout dan weer:

CTRL-f

Een zoekvenster verschijnt. Je kunt tekst invoeren die de editor voor jou moet zoeken in het bestand.

Stel nu dat je je vergiste, je wilde helemaal geen tekst zoeken.

ESC

Als het goed is is nu alles weer normaal.

Bewegen door de file We gaan nu door de file bewegen met de pijltjestoetsen, HOME en END. Deze toetsen bevinden zich aan de rechterkant van het toetsenbord.


pijltje-naar-links (of ALT-j): beweeg de cursor één positie naar links

pijltje-naar-rechts (of ALT-l): beweeg de cursor één positie naar rechts

pijltje-naar-beneden (of ALT-k):beweeg de cursor één regel naar beneden

pijltje-naar-boven (of ALT-i): beweeg de cursor één regel naar boven

HOME: naar begin van de regel

END: naar einde van de regel

CTRL-HOME: naar het begin van de file

CTRL-END: naar het eind van de file

CTRL-l: ga naar de opgegeven regel (line)

CTRL-pijltje-naar-rechts: één woord vooruit

CTRL-pijltje-naar-links: één woord achteruit

PAGE DOWN (of ALT-a): ga een scherm omlaag (vooruit)

PAGE UP (of ALT-q): ga een scherm omhoog (terug)

beweeg de cursor door de file met behulp van deze commando’s/toetsen.

Er is nog een andere manier om de cursor op een bepaalde positie te zetten: de muis. Als je met de linker muisknop op een letter klikt, komt de cursor op die positie te staan.

Wijzigingen aanbrengen We gaan de tekst nu veranderen.

ga met de cursor naar het eind van de zesde regel. Vul deze regel aan totdat er staat (je kunt gewoon gaan typen): Hoe huplt zijn paardje het dek op en neer. Als je typfouten maakt kun je ze uitwissen met de toets BACKSPACE.

Ga nu met de cursor terug naar het begin van het woord het op dezelfde regel en druk een paar keer op de toets DELETE. Het blijkt dat de letter waar de cursor op staat van het scherm verdwijnt, iedere keer als we DELETE gebruiken. Na acht keer staat er dus: Hoe huplt zijn paardje op en neer

Er zijn dus twee manieren om een letter te wissen: BACKSPACE en DELETE. Het verschil is dat BACKSPACE het karakter links van de cursor wist, terwijl DELETE het karakter waar de cursor op staat verwijdert.

Voeg nu de woorden het dek weer in. Ga terug naar het woord huplt, en verander dit in huppelt.

Probeer, om enige vaardigheid te krijgen, de letters pe weer uit te wissen met DELETE en voeg ze daarna op dezelfde plaats weer in. Zet de cursor achter het woord paardje op de zesde regel, en druk op ENTER. Je ziet dat de regel gesplitst wordt. Met ENTER voeg je dus een nieuwe lege regel in. Gebruik BACKSPACE om de oude toestand weer te herstellen.

Voeg na regel 6 de nieuwe regel Hoe zwaaien de wimpels al heen en al weer toe.


Er is nog een ander commando om tekst weg te gooien: CTRL-SHIFT-DELETE. Dit commando wist alles vanaf de positie van de cursor tot aan het einde van de regel. Het omgekeerde (alles wissen vanaf de positie van de cursor tot aan het begin van de regel) kan ook: CTRL-SHIFT-BACKSPACE.

Zet de cursor op de tweede regel tussen het woord somber en zwijgen. Druk op CTRL-SHIFT-DELETE. Je ziet dat het woord zwijgen gewist is.

Druk nu alleen op DELETE.

De derde regel is aan de tweede toegevoegd. We realiseren ons hoe stom we zijn geweest: het woord zwijgen moet helemaal niet weg, en die twee regels moeten ook niet samengevoegd worden. Maar geen paniek, met behulp van het ‘undo’-commando kunnen we onze laatst uitgevoerde commando weer herstellen.

Druk nu twee keer CTRL-z.

Als het goed is, is onze fout weer hersteld. Door meerdere keren CTRL-z te gebruiken, kun je steeds meer wijzigingen ongedaan maken.

Wis de regels Hoe huppelt... en Hoe zwaaien....

Wijzigingen opslaan en de editor verlaten Voordat je de editor verlaat is het belangrijk om te beslissen of je de gemaakte wijzigingen wilt bewaren of niet. Alle wijzigingen die je met de editor hebt aangebracht staan namelijk nog niet in de file in jouw directory! Je kunt de (oude) file in je directory overschrijven met de nieuwe, verbeterde file met het commando CTRL-s (save). Daarna kun je de editor verlaten met CTRL-q (quit).

Wanneer je de wijzigingen nog niet zelf had opgeslagen vraagt de editor bij gebruik van het commando CTRL-q of je de wijzigingen wel of niet wilt opslaan. Als je heel beslist uit de editor wilt zonder de file terug te schrijven moet je ‘No’ antwoorden. Dit is gevaarlijk! Daarom vraagt de editor nu of je dit echt wel wilt. Antwoord alleen in dat geval ‘yes’. Realiseer je dat de file in je directory is bijgewerkt tot op het moment dat je voor het laatst hebt gesaved. Heb je tijdens het editen nooit gesaved, dan is dus al het edit-werk verloren gegaan. Soms kan het gebeuren dat je met editen de zaak totaal verknoeid hebt. In dat geval is dit een mogelijkheid om de oude versie van de file terug te krijgen.

Bewaar het bestand

Je ziet op de onderste regel nu staan dat de file is weggeschreven (Input/output complete).

En sluit tot slot de editor af

De editor wordt gesloten en je keert nu terug naar de shell.

cat maan

Acties zoals het opslaan van een bestand en het verlaten van de editor kunnen uiteraard ook bereikt worden met gebruikmaking van de muis en de werkbalken/menu’s. Probeer, wanneer je in een editor aan het werk bent, echter zoveel mogelijk gebruik te maken van het toetsenbord. Dit helpt het risico op RSI-klachten te verminderen. Regelmatig pauzeren bij het typen en een goede werkhouding zijn natuurlijk het allerbelangrijkst.


Je ziet dat de file maan inderdaad de inhoud heeft die we het laatst op het scherm hadden.

2.11 Meer mogelijkheden met de editor

Een file opnieuw openen Zorg er eerst weer voor dat de working directory van de shell de directory is waar het bestand maan zich bevindt.

ipe (UNIX) of

Start, Programs, IPE (Windows)

We hebben de editor nu gestart zonder een bestand mee te geven. Als het goed is opent jEdit vanzelf de file maan weer, omdat dit het laatst geopende bestand was. Mocht dit om wat voor reden dan ook niet zo zijn, toets dan CTRL-o. (Open)

Het File System Browser-venster wordt geopend. Het bovenste gedeelte toont in welke directory je je bevindt; het onderste gedeelte toont de files die in de geselecteerde directory staan.

Klik met de muis éénmaal op de file die je wilt openen (in dit geval dus maan), en klik dan op de knop Open.

Het kan gebeuren dat de computer “down’’ (plat) gaat terwijl je aan het editen bent. In dat geval staat in jouw file natuurlijk nog steeds de oude versie die je als laatste bewaard hebt. De editor bewaart voor noodgevallen ongeveer elke minuut een versie van de file waarop jij aan het werk bent. Start jEdit gewoon weer op, en als het goed is krijg je de waarschuwing: An auto-save file was found!(...) Would you like to open the autosave file?. Toets Enter om te bevestigen dat je dit wilt. Controleer of dit inderdaad de gewenste versie van de file is. Zo ja, bewaar deze dan met behulp van CTRL-s. Misschien blijkt dat niet al je wijzigingen bewaard zijn gebleven maar de schade zal beperkt zijn.

Je files steeds consequent “saven” als je belangrijke wijzigingen hebt aangebracht is de beste manier om er zeker van te zijn dat jouw briljante invallen bewaard blijven.


Dit kan eventueel natuurlijk ook via het toetsenbord:

Druk een aantal keer op TAB totdat de cursor in het File name-vakje knippert en vul zelf de naam van de file in. Druk tot slot op Enter.

Na het opstarten van jEdit hoor je dit op het scherm te krijgen.

Mocht het er helemaal niet op lijken dan kun je:

• uit de editor gaan,

• maan weggooien,

• een nieuwe file maan kopiëren,

• weer in de editor gaan, of

• regel 6 weggooien.

Meer wijzigingen aanbrengen Probeer nu de volgende dingen te veranderen:

Vervang achter op de eerste regel door door en wolken door bomen.

Ga een regel naar beneden, en vervang somber zwijgen door wild geraas.

Verander Vrienden in Makkers.

De vierde regel is dubbel, dus wis die in z’n geheel (met CTRL-D).

Verander Zwarte Piet (nu op de vierde regel) in Sinterklaas.

Het woord koek is dubbel, verwijder er één.

Als alles gelukt is hebben we nu de situatie zoals hieronder:


Volgorde veranderen en tekst wissen We hebben ons tot nu toe alleen bezig gehouden met invoegen, verwijderen en veranderen. Wat er nu echter moet gebeuren is het veranderen van de volgorde van tekst. We gaan proberen het woord ‘avondje’ op de derde regel te kopiëren.

Selecteer het woord ‘avondje’ op de derde regel. Dat doe je door de cursor naar de ‘a’ van ‘avondje’ te bewegen en CTRL-SHIFT- → in te toetsen. Gebruik CTRL-c om het geselecteerde gedeelte te kopiëren naar een denkbeeldig klembord. Beweeg de cursor naar de spatie achter het woord ‘schijnt’ op de eerste regel. Gebruik CTRL-v om het zojuist gekopieerde gedeelte “in te plakken”. Je kunt het woord ook een aantal keren achter elkaar invoegen door meerdere keren CTRL-v in te toetsen.

Gebruik CTRL-z om de zojuist ingevoegde woorden weer te verwijderen.

Het kopiëren van meerdere woorden, of zelfs hele regels gaat op precies dezelfde manier. Je kunt tekst ook verplaatsen: selecteer eerst de tekst en voer daarna het commando CTRL-x uit. De oorspronkelijke tekst verdwijnt dan eerst, maar met behulp van CTRL-v kun je de tekst weer invoegen op de plaats waar jij dat wilt.

Klik op de ‘a’ van ‘avondje’ op de derde regel en houdt de muisknop ingedrukt. Beweeg (nog steeds met de muisknop ingedrukt) de muis zodanig dat de muis-cursor naar de spatie achter ‘avondje’ wijst. Laat de knop los. Druk op CTRL-x. Beweeg daarna de cursor in de file (met de pijltjestoetsen of de muis). Je ziet dat het gemarkeerde woord verdwenen is.

Plak het “uitgeknipte” gedeelte achter het woord ‘schijnt’ op de eerste regel met

CTRL-v.

Naast verplaatsen en kopiëren kun je op deze manier ook tekst wissen, door in plaats van een CTRL-combinatie op DELETE te drukken.

Onder UNIX is het vaak ook mogelijk om geselecteerde tekst in één keer te plakken door met de middelste muisknop te klikken op de gewenste invoegpositie.

Zorg ervoor dat de zesde regel de vierde regel wordt

Verplaats de regels 1 t/m 3 naar het eind van het liedje.

Het verwijderen van enkele woorden of een regel kan ook heel handig met de volgende toetscombinaties:

CTRL-BACKSPACE wis het vorige woord

CTRL-DELETE wis het volgende woord

CTRL-d wis een regel

Woorden zoeken Zoeken naar een woord in de tekst kan met CTRL-, (komma)

1) Zet de cursor aan het begin van de file (CTRL-HOME)

2) Druk op CTRL-,

3) Tik het woord in wat je zoekt. Terwijl je de letters intikt zoekt de editor al naar het woord en springt de cursor naar het eerste woord dat voldoet aan wat jij intikt.


4) Met ENTER spring je naar het volgende woord dat voldoet aan de letters die je hebt ingetikt.

5) Wanneer je het juiste woord hebt gevonden, druk je op de ESCAPE-toets. Hiermee geef je aan dat je klaar bent met zoeken en verlaat je de zoekfunctie.

Woorden vervangen Soms wil je in de tekst een woord door een ander woord vervangen. Dat kan met CTRL-f.

3. Zorg dat de cursor aan het begin van de file staat (CTRL-HOME)

4. Druk nu op CTRL-f.

5. Je kunt nu intikken welk woord er vervangen moet worden. Typ het woord in en sluit af met TAB. Je springt nu naar het Replace with-invoerveld. Typ in welk woord het moet worden.

6. Klik nu met de muis op de Replace All -knop of toets ALT-a wanneer je in één klap alles wilt vervangen. Wil je liever dat je per woord kunt beslissen of het veranderd moet worden of niet, klik dan op Replace & Find (ALT-r). De cursor komt terecht op de eerste keer dat het gezochte woord voorkomt. Wil je dit vervangen, toets dan CTRL-e CTRL-g achter elkaar. Wil je dit niet vervangen maar de volgende keer dat het woord voorkomt zoeken, toets dan alleen CTRL-g.

Vervang alle woorden ‘de’ door ‘deze’.

Een nieuwe file maken Je kunt een nieuwe file creëren door de naam van een niet-bestaande file aan de editor op te geven. In de editor kun je het menu item File → New kiezen of een sneltoets gebruiken:

CTRL-N

Je komt in de (geheel lege) file Untitled-1 terecht. Tik één of twee regels onzin in en bewaar het bestand onder de naam xyz. Overtuig je ervan dat de file xyz met deze inhoud nu daadwerkelijk bestaat.

Met meer files tegelijk werken

Schakelen tussen files Het is met jEdit heel eenvoudig met meerdere files tegelijk te werken. Als je een tweede file opent zonder de eerste te sluiten dan blijft de eerste file ook nog open. Gebruik hiervoor de eerder besproken toetscombinatie CTRL-o. Typ de naam in van de file die je wilt openen of selecteer hem met de muis.

Als je klikt op de Buffer Switcher (de balk met de bestandsnaam) zie je daar beide files staan. Door met je muis naar de file te gaan waar je nu in wilt werken wordt deze geselecteerd en zie je op het scherm de tweede file verschijnen. Op dezelfde manier kun je weer terug gaan naar de eerste file. Met het toetsenbord is het wel zo makkelijk:

CTRL-PAGE UP om naar een file terug te schakelen;

CTRL-PAGE DOWN om er één vooruit te schakelen;

CTRL-` (het spiegelbeeldapostrofje ofwel backtick) wordt gebruikt om heen en weer te schakelen tussen de laatste twee geopende files.

Meerdere files tegelijk in beeld Soms is het handig twee bestanden naast elkaar in beeld te hebben. jEdit kan het tekstvenster daarom ook “splitsen”:

CTRL-2: Horizontaal splitsen


CTRL-3: Verticaal splitsen

CTRL-1: Alle splitsingen ongedaan maken; terug naar één file tegelijkertijd in beeld.

Wanneer je meerdere werkbladen gebruikt kun je ook meerdere vensters van jEdit op verschillende werkbladen hebben. De optie New View uit het View menu opent een nieuw venster, dat je vervolgens kunt verplaatsen naar een ander werkblad.

Sla het bestand op en log uit

2.12 Het gebruik van floppies en CD-ROM’s binnen UNIX In MS-DOS en Windows is elk diskettestation en elke harde schijf een apart filesysteem. Onder Unix is er maar één systeem met de root als basis. Eventuele andere systemen kunnen daaraan worden gekoppeld. De technische term daarvoor is mounten. Daarvoor bestaan commando’s, die alleen door de afdeling systeembeheer kunnen worden gebruikt.

Toch heb je wel de mogelijkheid om een floppydrive aan het bestaande filesysteem te koppelen Dit gaat als volgt:

Stop een floppy of CD-ROM in het workstation

volcheck Je hoort het diskette station draaien en de diskette wordt gemount. Je hebt het filesysteem nu uitgebreid met de opslagcapaciteit van je floppy. De inhoud van de diskette vind je in de directory /floppy/floppy0. Met die directory ga je precies zo om als met andere Unix files. Voor CD-ROMs is de directory, analoog aan de floppy, /cdrom/cdrom0.

Je kunt nu bijvoorbeeld files kopiëren van een willekeurige plaats in het filesysteem naar je floppy (of andersom) via de bekende Unix commando’s en je kunt binnen die floppy-directory ook weer nieuwe directories maken.

Als je klaar bent met werken op de floppy wil je natuurlijk de floppy meenemen

Zorg dat je de directory met de schijfinhoud hebt verlaten, want een directory waar je op dat moment in bezig bent kun je niet unmounten.

eject

De diskette / CD komt naar buiten.

2.13 Shell-scripts Je hebt al kennis gemaakt met een groot aantal commando’s in UNIX. Vooral in het begin zul je met deze commando’s voldoende uit de voeten kunnen. Na verloop van tijd zul je echter merken dat je sommige handelingen te vaak moet uitvoeren of een aantal commando’s achter elkaar moet intypen. Dit wordt al snel vervelend. In deze gevallen is het handig om een shell-script te schrijven dat deze handelingen voor je kan uitvoeren.

Een shell-script wordt geschreven in de editor, waarna deze file door UNIX wordt aangeroepen en uitgevoerd. Net zoals je dat met een willekeurig commando als grep of sort kunt doen, kun je tegen de shell zeggen dat zijn invoer uit een file komt en niet van het toetsenbord.

Eigenlijk is een shell-script dus niets meer dan een file met tekst, maar deze tekst moet wel aan bepaalde regels voldoen: het moet een syntactische structuur bezitten, zodat het voor UNIX duidelijk is dat het om een script gaat. UNIX kan het shell-script dan lezen, de commando’s interpreteren en zorgen dat deze commando’s worden uitgevoerd. Op deze manier gebruik je de shell (zowel sh als bash) dus niet alleen als een programma dat je commando’s interpreteert, maar ook als programmeertaal. Op deze manier kun je lange, moeilijk te onthouden commando’s of een serie commando’s afkorten tot enkele letters.


Een zeer eenvoudig shell-script We hebben al eens de commando’s date en who gecombineerd (zie paragraaf 0). Wanneer je deze informatie wilt hebben, maar je hebt geen zin om de commando’s steeds in te tikken, dan kun je hiervan een shell-script maken.

Start de shell

Start ook de jEdit-editor (zie paragraaf 0) en zorg ervoor dat de windows van de shell en jEdit tegelijk op je scherm leesbaar zijn. Pas hiervoor zonodig de grootte van vensters aan.

Typ in de editor onderstaande tekst letterlijk over en bewaar de file onder de naam whodate in de directory icg. Een script hoort standaard te beginnen met ‘#!/bin/sh’ - dit vertelt aan UNIX voor welk soort shell het script is geschreven, zodat het gegarandeerd goed wordt uitgevoerd.

#!/bin/sh who date

Ga naar de shell. Zorg ervoor dat je in de directory icg staat.

sh whodate Met dit commando draai je het script in de shell. Met het commando sh roep je eerst de shell aan, die het shell-script whodate voor je uitvoert. De gevraagde gegevens worden op je scherm gezet. Op zich bespaart dit shell-script je niet heel veel tijd (je moet nu zelfs meer letters intypen!), maar het geeft wel in een notendop de werking van een shell-script weer.

Shell-scripts met variabelen In shell-scripts (en in computerprogramma’s in het algemeen) wordt veel met variabelen gewerkt. Een variabele is een plaats waar een waarde kan worden opgeslagen. Deze waarde kan van geval tot geval verschillen, afhankelijk van de keuze van de gebruiker. Een variabele begint altijd met een letter, gevolgd door een combinatie van letters, cijfers of andere tekens.

Binnen UNIX zijn al een groot aantal standaard variabelen in gebruik, deze worden in hoofdletters geschreven. Daarnaast kun je zelf in je shell-scripts variabelen definiëren, wanneer je kleine letters gebruikt ontstaan er geen problemen met de standaard gedefinieerde variabelen.

Typ in de editor onderstaande shell-script letterlijk over en bewaar de file onder de naam welkom in de directory icg.

#!/bin/sh echo Wat is je naam? read antwoord echo Hallo $antwoord, welkom bij Inleiding Computergebruik

Run het shell-script welkom. Beantwoord de vraag die je gesteld wordt.

Dit shell-script maakt gebruik van de variabele antwoord.

$antwoord geeft aan dat de waarde moet worden genomen van de variabele antwoord.

Het commando echo drukt altijd het argument (datgene dat er achter staat) af.

Wanneer je een fout hebt gemaakt in het overtypen, dan verschijnt er een foutmelding op het scherm. Probeer de fout te herstellen en bewaar de file weer. Run het shell-script opnieuw. Wanneer je de foutmelding niet begrijpt of de oplossing niet weet vraag dan je practicumbegeleider of een medestudent om je even te helpen.


Probeer nu zelf de shell-script uit te breiden met de volgende vragen: hoe oud ben je, waar woon je en welke studierichting doe je? Verzin zelf leuke reacties op de antwoorden die je in moet voeren. Laat je script op correctheid controleren door de student-assistent. Bewaar en run het script.

Een shell-script executable maken Wanneer je een shell-script wilt uitvoeren typ je nu steeds sh gevolgd door de filenaam. Wanneer je de file executabel maakt hoef je alleen nog maar de filenaam in te typen. Het executabel maken van een file gaat door middel van het commando chmod 700 of chmod +x. Beide commando’s hebben dezelfde werking, namelijk ervoor zorgen dat de file nu door de shell uitvoerbaar (executabel) is. Een script werkt, als je het executabel hebt gemaakt, dus op dezelfde manier als een UNIX-commando.

chmod 700 welkom

Het intypen van de naam van de file is nu voldoende om het shell-script uit te voeren.

welkom

De plaats van shell-scripts De file welkom uit de vorige paragraaf moet voordat die kan worden uitgevoerd wel staan in de directory waar je op dat moment bent. Als je niet bent in de directory waar de file staat dan kan de shell je opdracht niet vinden en komt er een foutmelding:

Ga naar je home-directory.

welkom

Je kunt er echter voor zorgen dat je vanuit elke plaats een (zelfgemaakt) commando kunt uitvoeren door de file waarin het commando staat te verplaatsen naar de subdirectory met de naam bin in je home-directory. Als die directory er nog niet is moet je die eerst maken. De shell zoekt standaard op een aantal plaatsen waar commando’s zouden kunnen staan, en één daarvan is je bin (bin staat voor binary) directory.

Ga na of je in je home-directory een subdirectory hebt met de naam bin. Maak deze directory zonodig aan.

Verplaats de shell-script welkom naar de directory bin. Voer de shell-script (als je in de directory bin staat) een keer uit om te controleren of deze nog werkt.

Ga naar je home-directory.

welkom

Je merkt dat het shell-script nu wel werkt.

Als je wilt weten op welke plaatsen de shell zoekt kun je dat opvragen door te kijken naar de waarde van de variabele PATH.

echo $PATH

Voor verschillende soorten shells (sh, csh, ksh, enz.) kan de werking anders zijn. Studenten Wiskunde & Informatica hebben steeds te maken met wat beschreven staat voor de Bourne shell (sh)!


Je ziet dan, gescheiden door ‘:’ de locaties waarin de shell naar commando’s zoekt. Tezamen vormen ze de waarde van de variabele PATH.

Voor de duidelijkheid: onderstaand commando drukt alleen het woordje PATH af.

echo PATH

Je kunt de waarde van de PATH-variabele, en ook die van allerlei andere variabelen, zelf instellen.

Het meest gebruikelijk is dat te doen door allerlei waarden die bepalen hoe jij de shell wilt gebruiken in te stellen in de file .bashrc die zich in je home-directory bevindt. De punt aan het begin van de filenaam betekent dat het bestand hidden (verborgen) is en normaal gesproken niet wordt getoond na een ls-commando.

De commando’s die in die file staan worden uitgevoerd als je inlogt, en de dan ingestelde waarden gelden dan verder voor de duur van de sessie, tenzij je ze tussendoor weer verandert. Je kunt de file .bashrc op de gebruikelijke manier met de editor bewerken.

Argumenten meegeven aan een shell-script Je kunt, net als bij bestaande UNIX-commando’s, argumenten meegeven aan een shell-script. Wanneer het commando of shell-script wordt uitgevoerd wordt de waarde van de argumenten meegenomen bij het berekenen van het antwoord.

Typ in de editor onderstaande shell-script letterlijk over en bewaar de file onder de naam showarg in de directory bin.

#!/bin/sh echo Het aantal argumenten is $# echo Het eerste argument is $1 echo Het tweede argument is $2 echo Het derde argument is $3

sh showarg jan piet (wanneer je het shell-script eerst executabel hebt gemaakt typ dan showarg jan piet)

Je voert hier het commando showarg uit met twee argumenten: argument jan en argument piet.

De waarden van deze argumenten worden opgeslagen in de parameters $1 en $2. Bij dit commando is er geen derde argument, deze krijgt dan ook geen waarde. Het totale aantal argumenten wordt geteld en bevindt zich in $#.

sh showarg jan piet klaas

Nu is er ook een derde argument. De waarde wordt opgeslagen in parameter $3.

Keuzes maken Met behulp van de variabelen en/of parameters kun je in het shell-script keuzes maken.

Als je de waarde van een variabele wilt gebruiken moet je dus de naam van de variabele vooraf laten gaan door een $-teken.


Typ in de editor onderstaande shell-script letterlijk over en bewaar de file onder de

naam moeilijk in de directory bin.

echo Vind je shell-scripts schrijven moeilijk? Typ ja of nee. read antwoord if test $antwoord = ja then echo Je hebt $antwoord ingetikt. Je vindt het moeilijk else echo Je hebt $antwoord ingetikt. Je vindt het niet moeilijk fi

Run shell-script moeilijk. Beantwoord de vraag eerst met ja. Run het script daarna nog een keer met het antwoord nee.

Typ in de editor onderstaande shell-script letterlijk over en bewaar de file onder de naam verwijder in de directory bin. echo Wil je echt $1 verwijderen? read antwoord if test $antwoord = ja then echo $1 is verwijderd! rm $1 else echo dan verwijder ik niets fi

sh verwijder moeilijk

Wanneer je ‘ja’ invoert wordt het shell-script moeilijk verwijderd.

De variabele test is hier het hulpmiddel dat een berekening uitvoert over wat er achter staat, d.w.z. kijkt of dat waar of niet waar is. Op grond van de berekende waarheidswaarde kiest het script de actie die tussen then en else staat (in het geval van true) of de actie die tussen else en fi staat, in het geval van false.

test kan ook voor je kijken of een file, waarvan je de naam als argument meegeeft, wel of niet bestaat. Ga na hoe je dat moet doen en laat je oplossing controleren door de student-assistent.

Keuzes: de case-functie Een andere mogelijkheid om keuzes te maken is de case functie. Daarbij wordt datgene wat na het commando case staat vergeleken met elk van de patronen in de rij die volgt op het woordje in.

Typ in de editor onderstaande shell-script letterlijk over en bewaar de file onder de naam stoplight in de directory bin. Test of het shell-script naar behoren werkt.

echo Geef een kleur read stoplicht case $stoplicht in rood) echo STOP ;; oranje) echo Stoppen als het kan, anders doorrijden ;; groen) echo Doorrijden ;; blauw|bruin|paars) echo Dit zijn geen stoplichtkleuren! ;; esac

sh showarg Commando’s als if en case dien je altijd op een goede manier af te sluiten, zodat de

computer weet dat hij niet verder hoeft te zoeken naar meer keuzemogelijkheden. Het einde van een if-statement wordt aangegeven met fi, het einde van een case-statement met esac. (de commando’s achterstevoren gelezen).


Het script showarg dat je eerder hebt gemaakt werkt niet helemaal naar behoren. Als je geen argumenten meegeeft wordt toch drie keer een regel begonnen over de waarde van een argument, zonder dat het script er iets achter kan invullen. Kun je met behulp van case het script showarg zo veranderen, dat het eerst meldt hoeveel argumenten er zijn, en daarna: - bij 0 argumenten klaar is

- bij 1 argument meldt: “het enige argument is ....”

- bij 2 argumenten: “het eerste argument is ......”

“het tweede argument is ...”

- bij 3 of 4 argumenten: “meer dan twee argumenten mag niet”

Herhalen: de while-functie Door middel van het commando while kun je de shell één of meer opdrachten laten herhalen, zolang aan een bepaalde voorwaarde is voldaan.

Typ in de editor onderstaande shell-script letterlijk over en bewaar de file onder de naam herhalen in de directory bin.

#!/bin/sh antwoord=“ja” while test $antwoord = “ja” do echo “OK, nog een keer” echo “Moet ik nog steeds doorgaan?” read antwoord done

Deze shell-script voert de regels tussen do en done uit zolang de gebruiker als antwoord ja intikt.

In plaats van de regel while test $antwoord = “ja”

mag je ook schrijven: while [ $antwoord = “ja” ]

Zowel de functie test als de vierkante haken zorgen ervoor dat de uitdrukking $antwoord = “ja” wordt geëvalueerd. Op grond van de uitkomst (true of false) wordt besloten of er nog moet worden doorgegaan met herhalen.

Schrijf nu zelf een script dat de gebruiker steeds om twee dingen vraagt: een zoekterm en de naam van een file. Als de laatste de naam is van een bestaande file uit de huidige directory, zoekt je script op in hoeveel regels van de file de zoekterm voorkomt en drukt dat aantal af. Dit proces wordt steeds herhaald totdat de gebruiker de naam van een niet-bestaande file opgeeft. Het script geeft dan een melding en stopt.

HINT: je kunt van een regel een aantal karakters afhakken met behulp van het ‘cut’ commando. Kijk in de manual hoe dat precies moet.


Meer mogelijkheden met shell-scripts Met shell scripts kan nog veel meer. Het is zelfs mogelijk om complete programma’s te schrijven met specifieke shell commando’s samen met gewone UNIX commando’s. Het voert echter te ver om hier dieper op in te gaan; zie voor meer informatie de manual of een andere uitgebreide handleiding over UNIX.

2.14 Protectie en Permissie Niet iedereen mag zomaar alles doen met elke file. Als je een file creëert ben je eigenaar en kan je zelf bepalen wie er wat mee mag doen. Voor dat doel is de UNIX-wereld verdeeld in drie categorieën:

4) de eigenaar van de file

5) de mensen die in zijn “groep” zitten

6) overige personen.

Voor elk van deze categorieën kun je apart opgeven wat ze wel of niet met jouw files mogen doen. Er zijn twee werkwijzen om de protectiemode van je directories en files in te stellen, ze komen hier beide aan de orde. Kies voor het instellen van de protectiemodes de werkwijze die jij het prettigst vindt. Raadpleeg ook eens de manual page over dit onderwerp (man chmod)!

Werkwijze 1

ga binnen je home-directory naar de directory icg

ls -al

Je krijgt nu een overzicht van de bestanden met veel informatie.

Voor iedere file staat een aanduiding in de vorm “-rw-r--r--’’. Deze aanduiding geeft aan welke gebruikers wat mogen doen met de file. Hierbij staat r voor read (lezen), w voor write (schrijven) en x voor execute (uitvoeren). Deze regel van 10 karakters heeft een eerste karakter die aangeeft of het een directory (d) is of niet (-), De volgende negen karakters wordt onderverdeeld in 3 stukjes van 3 karakters:

• De meest linkse drie posities (rw-) geven aan wat de user (dat ben jij) mag doen met de file.

• De volgende drie posities (r--) geven aan wat mensen uit jouw group (alle medestudenten van jouw jaar) met de file mogen doen.

• De meest rechtse drie posities (r--) geven aan wat alle andere gebruikers met de file mogen doen. In dit voorbeeld (-rw-r--r--) mag dus iedereen de file lezen, maar alleen jij mag de file ook veranderen.

Met het commando chmod kun je deze bescherming veranderen. chmod who=permission filenaam verandert de protection mode van de file genaamd filenaam. Hierbij is who u (voor user), g (voor group), o (voor others) en a (voor all).

Bijvoorbeeld:

u=rw : maak lees en schrijfbaar voor jezelf.

g=rx : maak lees en uitvoerbaar voor iedereen in jouw groep.

ug= : jij en iedereen in je groep kunnen de file niet lezen, schrijven en uitvoeren

(gevaarlijk!).

ugo=rwx: maak leesbaar, schrijfbaar en uitvoerbaar voor iedereen (gevaarlijk!).

a=r : maak leesbaar voor iedereen

chmod u= maan


chmod g=rw maan

chmod o=r maan

ls -l

Nu blijkt de file leesbaar te zijn voor derden, lees- en beschrijfbaar voor groepsleden maar niet lees- of beschrijfbaar voor jezelf!

ipe maan Je krijgt nu de mededeling dat de file wel bestaat, maar dat je hem niet mag lezen.

Uiteraard mag je alleen de mode veranderen van files waarvan je zelf eigenaar bent. Het is verstandig om files alleen voor jezelf lees- en beschrijfbaar te houden, zodat anderen niet je files kunnen verpesten. Daarom veranderen we de protection mode weer:

chmod ugo= maan

chmod u=rw maan

Controleer dat je de file maan weer kunt lezen en veranderingen kunt aanbrengen.

Werkwijze 2 Bij methode twee maken we gebruik van de binaire notatie van de protectiemodes. Voor elk van de hierboven aangegeven categorieën eigenaren kunt je de protectiemode instellen door middel van een getal van 0 tot 7.

Het handigste is om je dat getal voor te stellen in binaire notatie (zo wordt het natuurlijk ook opgeslagen); dan gaat het dus om getallen tussen 000 en 111. Stel dat voor een bepaalde categorie het meest rechtse binaire cijfer een 1 (dat staat voor het voorkomen van 1 in de binaire ontwikkeling) is, dan mogen de personen uit die categorie de file gebruiken (= execute) en als het cijfer een 0 is dan mag dat niet.

Als het middelste binaire cijfer een 1 is (dat staat dus voor het voorkomen van 2 in de binaire ontwikkeling) mag je in de file schrijven (= write). Met 0 mag je weer niet schrijven.

Het meest linkse cijfer (dat staat voor het voorkomen van 4 in de binaire ontwikkeling) bepaalt op dezelfde manier of je in de file mag lezen (= read) of niet: 1 is wel lezen, 0 is niet lezen.

Als het binaire getal dus 101 is mag de betreffende categorie de file gebruiken en er in lezen, maar er niet in schrijven.

Voor elk van de drie categorieën gebruikers ontstaat er zo dus een binair getal. Deze drie binaire getallen worden weer vertaald naar de decimale notatie: de 101 wordt dan een 5. Omdat voor alle drie de categorieën zo’n getal wordt bepaald krijgen we dus een rijtje van drie octale cijfers, waarvan het eerste gaat over de mogelijkheden van de eigenaar, de tweede over die van de andere leden van zijn groep, en het derde over alle andere personen. Deze drie octale cijfers vormen samen de protectiemode.


Onderstaand ter verduidelijking een tabel met enkele codes in de binaire en octale notatie en de protectie-mode.

Binaire notatie Octaal getal Protectiemode Betekenis

000 000 000 000 --------- Niemand mag lezen, schrijven of uitvoeren GEVAARLIJK.

100 100 100 444 r--r--r-- Iedereen mag lezen, maar niemand mag schrijven of uitvoeren.

110 100 100 644 rw-r—r-- Eigenaar mag lezen en schrijven, anderen alleen lezen.

111 100 100 744 rwxr—r-- Eigenaar mag lezen, schrijven en uitvoeren, anderen alleen lezen.

110 110 100 664 rw-rw-r-- Eigenaar en groep mogen lezen en schrijven, rest alleen lezen.

111 111 111 777 Rwxrwxrwx Iedereen mag lezen, schrijven en uitvoeren. GEVAARLIJK!!

Je kunt als eigenaar de protectiemode weer zelf instellen door middel van het commando chmod.

chmod 444 maan

Verander de protectiemode van de file maan zodanig dat de eigenaar mag lezen en schrijven en de andere categorieën alleen mogen lezen.

Voor gevorderden: Bash Op de VU wordt standaard gebruik gemaakt van de bash-shell. Informatie over wat bash precies is, is te vinden op de website: http://www.gnu.org/software/bash/ Bash heeft een aantal configuratiebestanden, waaronder het bestand genaamd '.bashrc'. Deze is te vinden in de homedirectory van de gebruiker. In dit bestand staat een aantal commando's dat bash uitvoert zodra het gestart wordt. Een voorbeeld hiervan zou kunnen zijn: echo "hallo $USER" Dit commando drukt de tekst “hallo <de gebruikersnaam>” af. Het is mogelijk ieder willekeurig commando/programma te laten starten als je je bash opstart. Zo is het ook mogelijk om gelijk het mailprogramma pine te starten, simpelweg door dit in de .bashrc te zetten. Zoals te zien is in het voorbeeld kan je met $USER je gebruikersnaam afdrukken. Dit komt omdat bash een aantal variabelen van tevoren heeft aangemaakt. Met het commando 'set' kan je zien welke variabelen dat allemaal zijn. Je kunt ook zelf variabelen toevoegen met het commando: $ variabele1="waarde" Als je je variabele wilt bewaren buiten alleen de huidige terminal, typ dan:

export variabele1="waarde"


Een speciale variabele is PROMPT_COMMAND. Dit is een variabele waarvan de inhoud elke keer dat je de prompt te voorschijn komt uitgevoerd wordt. Een van de variabelen is de tekenreeks genaamd de prompt (standaard een '$' teken). Dit is wat je dus standaard ziet voor elk commando dat je intypt. Deze variabele heet PS1. Deze is ook te zien als je het commando 'set' uitvoert en is ook op te vragen met

echo $PS1 Bash is (ook) een programmeertaal. Er kunnen functies gemaakt worden is bash, en dat is ook wat je nodig hebt voor deze opdracht. Jouw opdracht is om te zorgen dat de promt (de PS1 variabele) verandert in een iets meerzeggend geheel. Oftewel: Zorg dat de prompt verandert in de huidige werkmap (op te vragen met het commando 'pwd', gevolgd door een linebreak waarna alsnog de $ staat. Je prompt ziet er dan zo uit: /home/<user> $ En na het uitvoeren van het commando 'cd bin', zo: /home/<username>/bin $ Je moet je prompt variabele laten bepalen door een functie aan te roepen die je zelf schrijft. Een voorbeeld van een zelfgeschreven functie opgeslagen in een variabele: VARIABELE="functie" functie() {

echo "Hallo, dit is een functie waar je alles in kan zetten" banner hoi

} Om deze functie uit te voeren typ je

$VARIABELE Dit is hetzelfde wat bash doet voor elke prompt; hij voert het commando uit dat in de variabele PROMPT_COMMAND is opgeslagen. Voor meer informatie kan je het beste kijken in de manual pages van bash en echo. Deze kan je openen met de UNIX commando’s ‘man bash’ en ‘man echo’.


2.15 Extra: UNIX-applicaties We zijn met dit hoofdstuk begonnen als een losse aanvulling op Inleiding Computergebruik, primair bedoeld voor studenten W&I. De bedoeling ervan is om diegenen die nieuwsgierig zijn naar wat er op UNIX mogelijk is, een vliegende start te geven. Intussen is de appendix een vast onderdeel van de syllabus, omdat hij voorziet in een behoefte van veel studenten om voor hun dagelijkse activiteiten niet van een Windows-PC afhankelijk te zijn.

Natuurkundestudenten die op een UNIX-systeem werken kunnen hier ook wat aan hebben maar niet alle programma's die hier besproken worden, hebben zij tot hun beschikking. Anderzijds zijn de beperkingen genoemd in paragraaf 3 niet op hen van toepassing.

Op de website van de IT-groep, http://www.few.vu.nl/itg, is veel meer informatie te vinden dan in deze appendix. Jullie worden aangeraden om die website regelmatig te raadplegen aangezien de geïnstalleerde programma’s aan verandering onderhevig zijn. In deze appendix is slechts een selectie gemaakt van de informatie die voor de meeste studenten van belang kan zijn.

Zoals eerder opgemerkt is dit appendix een aanvulling en dus slechts “ter informatie”. Alleen nieuwsgierige mensen hoeven vanaf hier verder te lezen. Waarschuwing: werken met UNIX kan grote voldoening geven - er is meer mogelijk dan je op het eerste gezicht zou denken...

Gebruiksomgevingen

De PATH variabele

Allerlei veelgebruikte programma's staan in de directory /usr/local/bin. In de praktijk merk je hier niet zoveel van, omdat deze directory al in je path staat, en de programma's die daarin staan worden vanzelf gevonden als je ze aanroept vanuit een terminal.

Maar de nieuwste versies van veel programma's, alsmede een hoop andere nuttige (of nutteloze) programma's zijn niet zomaar aan te roepen vanaf een standaard gebruikersaccount! Deze staan bij W & I in de directory /usr/local/public/bin. Het woordje 'public' betekent dat het bijgehouden wordt door de public maintainers, een aantal studenten dat hiermee het systeembeheer wat werk uit handen neemt.

Je snapt dat het erg handig is om deze directory ook in je path te hebben staan. Je kunt een directory aan je path toevoegen door eerst het bestandje .bashrc te openen in een text editor (we gaan ervan uit dat je de bash-shell gebruikt). Ga helemaal naar onderaan in de file en voeg de regel export PATH=/usr/local/public/bin:$PATH

toe. Als je dit gedaan en gesaved hebt, log dan uit en opnieuw in. Open een shell en probeer eens: fortune. Werkt dit, dan is het je gelukt!

Er zijn nog meer environment variabelen waar je op moet letten. Zo is er ook een LD_LIBRARY_PATH waar je paden naar libraries (``bibliotheken'' die door meerdere programma's kunnen worden aangeroepen) in kunt zetten. Hoe je deze aanpast zie je in de paragraaf hierna.

N & S-studenten hoeven hun path niet aan te passen want de programma's genoemd in deze appendix zijn daarin al te vinden.

Om snel in je path te zoeken naar een programma kun je het commando 'which' gebruiken. Bijvoorbeeld: which ipe


GNOME-alternatieven

De GNOME desktop omgeving zoals beschreven in de syllabus is niet de enige grafische interface die je kunt gebruiken. Het kan prettig zijn om een andere window manager te gebruiken als die meer aan jouw wensen voldoet. Een window manager zorgt ervoor dat de titelbalken, knoppen en desktop-achtergrond op je scherm komen en bepaalt ook hoe ze eruit zien en hoe ze op je muis reageren. Op het systeem zijn er meerdere beschikbaar, waaronder fvwm (in diverse smaken), icewm, KDE en GNOME.

In de syllabus staat het inlogscherm beschreven. Als je in dit scherm op 'Options' klikt dan kun je 'X11 session' selecteren. Dan start je niet op met GNOME maar met een simpele window manager, twm. Door het bestandje .Xsession in je home directory te bewerken met een text editor (een eenvoudige en praktische text editor voor dit doeleinde is pico, zie ook het hoofdstukje Editors) kun je een andere window manager opstarten. Een .Xsession bestandje voor icewm kan er zo uitzien (de schuingedrukte tekst is commentaar en hoort er niet bij):

#!/bin/sh dit is een shellscript, zie ook syllabus Module 2 PATH=$PATH:/usr/local/public/bin LD_LIBRARY_PATH=/usr/local/public/lib:/usr/local/X11R6/lib export PATH LD_LIBRARY_PATH xterm -sb & open standaard een x-terminal schermpje exec icewm start icewm op

Vergeet niet dat de .Xsession file executable moet zijn (chmod +x .Xsession). Mocht er bij het inloggen nog iets misgaan dan kun je altijd nog de Failsafe session kiezen in het inlogscherm.

Als je ervoor kiest om met CDE te werken dan is het instellen van de LD_LIBARY_PATH variabele zoals hierboven desondanks nog wel een goed idee. In dat geval zou je die regel neerzetten in je .bashrc zoals beschreven in par. 2.1.

Diskquota’s en budgetten

Quota

Iedere gebruiker van het systeem heeft een bepaalde hoeveelheid schijfruimte gekregen die hij/zij mag gebruiken. Dit is meestal rond de 100 MB. Dat is genoeg voor al je practicabestanden en dergelijke, maar je kunt er niet onbeperkt in schrijven. Downloaden van MP3-bestanden naar je home directory is bijvoorbeeld geen goed idee. Wanneer je je quota overschrijdt, dan heb je een week de tijd om ruimte vrij te maken zodat je weer binnen je quota zit. Daarna is het niet meer mogelijk om in te loggen! Je krijgt een automatisch gegenereerd mailtje met een melding dat je over je quota bent.

Om te zien wat je quota is en hoeveel je op dit moment gebruikt, gebruik je het commando 'quota -v'. Het kan gebeuren dat je veel schijfruimte gebruikt en dat je geen idee hebt waar dat vandaan komt. Dan is er waarschijnlijk een programma dat veel tijdelijke bestanden in je home directory zet (bijvoorbeeld Firefox). Wees voorzichtig met het verwijderen van bestanden, gebruik eerst het programma zelf om de bestanden op te ruimen.

Gebruikte- en vrije ruimte

Soms is het handig om te weten hoe veel schijfruimte de bestanden in een directory nu eigenlijk precies innemen. Als je het commando: du -k | xdu

geeft, dan krijg je een grafisch overzichtje van gebruikte schijfruimte, gerekend vanuit de huidige directory (dus de directory waarvandaan je du hebt gestart). du staat overigens voor


'disk usage', net zoals df voor 'disk free', vrije ruimte, staat. De parameter '-k' geeft aan dat je de getallen graag in kilobytes wil zien. Laat je ' | xdu' weg uit het commando dan wordt de uitvoer gewoon in je terminalvenster gegeven.

Ruimtebesparing: (g)zip en consorten

Vaak staan er een groot aantal bestanden die je niet vaak gebruikt maar een beetje stof te verzamelen, maar toch wil je ze niet weggooien. Dan kun je ze zippen, dat betekent dat al die bestanden worden samengeperst in één zip-bestand dat een stuk kleiner is dan alle losse bestanden bij elkaar opgeteld. Stel, je wilt de de bestanden die je hebt gemaakt voor het vak Inleiding Multimedia zippen. Ze staan allemaal in de een directory 'imm'. Dan tik je het volgende in: zip -R inleidingmultimedia.zip imm/*

daarmee houd je inleidingmultimedia.zip over en kun je de inhoud van je 'imm'-directory veilig weggooien. De '-R' (let op de hoofdletter) betekent 'Recursief', waardoor alle onderliggende directories ook worden meegenomen. Wil je zo'n zip-bestand later weer uitpakken dan doe je dat met 'unzip': unzip inleidingmultimedia.zip

Onder UNIX kom je ook regelmatig bestanden tegen die eindigen op '.tar.gz' of '.tar.bz2'. Dit zijn ook een soort zip-bestanden (ook wel archive genoemd) maar uitpakken gaat op een iets andere manier: tar xvzf archive.tar.gz

of bzcat archive.tar.bz2 | tar xv

Gebruik de man pages voor uitgebreidere beschrijvingen.

Printen

Meer pagina's op een A4

Docenten stellen wel eens sheets beschikbaar op het net die je dan zelf mag uitprinten. Met één blaadje per sheet tikt dat aardig aan. Gebruik 'psnup' om meerdere pagina's op een A4'tje te krijgen. Als de sheets nog niet in postscript formaat staan, maak er dan postscript van (onder Windows kan dit met de Print to File-functie) en type 'psnup -4 printdit.ps | lpr' om het naar de printer te sturen. Het getal achter het minteken geeft uiteraard aan hoeveel pagina's er op een A4'tje moeten. Voor uitleg over pipes en redirection ( de | ), zie Module 2.

Als je een platte-tekstfile iets mooier wilt afdrukken (nuttig bijvoorbeeld bij het uitprinten van mailtjes) dan kun je 'a2ps' gebruiken in plaats van 'lpr'.

Printer queue

Om te voorkomen dat je een heel eind naar de printerkamer loopt en erachter komt dat er net voor jou iemand heeft bedacht dat hij het Internet wil uitprinten, kun je 'lpq' gebruiken. Dit commando drukt af welke jobs er nog staan te wachten en van wie ze zijn. Er staat een scriptje op het systeem met de naam 'follow', deze toont de printer queue en ververst hem om de paar seconden zodat je kunt bijhouden hoe ver de printer is.

Procescontrole met Bash We hebben gezien dat er 1. user-defined functies zijn, 2. builtin's en 3. executable files. De "commando's" kill, jobs, fg en bg zijn alle builtins. Deze keer gaan we het hebben over "commando's" die geen builtins zijn maar executable files. Het grootste verschil tussen builtins


en executable files zit hem in het feit dat het laatste een nieuw proces wordt bij het uitvoeren. Dit gebeurt niet bij een builtin, want die "wordt gedraaid in de shell".

Hoe kun je alle processen zien die draaien op de computer? Dat kan met top. Top geeft een lijst van de huidige processen. Zie onderstaande tabel (uitvoer van top):

Op de eerste regel krijg je een overzicht met algemene informatie over de load. De "load" is het aantal processen dat in de rij staat om gedraaid te worden op de computer (gemiddelde). Er staan momenteel 0.03 processen in de rij, dus als ik een zware applicatie wil draaien die ook interactief is, dan heb ik geluk. Een hoge load op een server betekent meestal: probeer een andere studenten server!

Als er nu 2 matlabs (grote wiskundige opgaven voor de compu) worden gedraaid dan zal de load zeer waarschijnlijk >1.03 worden. Immers willen ze allebei graag gedraaid worden. De ene is bezig en de ander moet dan wachten en vice versa.

De tweede regel van top geeft informatie over het aantal processen. Een proces heeft een bepaalde state, waaronder sleeping, zombie, stopped en on cpu. Sleeping betekent: ik wacht ergens op. Zombie betekent: ik doe niets meer maar besta toch nog. Stopped: een proces gestopt, bijvoorbeeld door job control of debugger. On cpu: processen die op een processor draaien.

De derde regel geeft informatie over hoeveel geheugen er nog vrij is.

Daarna verschijnt er een lijst met heel veel info. In de meest rechtse kolom wordt het commando genoemd. (bv "top-sun4u-5.8"). Bij username vind je de eigenaar: "tvburger". Ook zie je de PID staan: process id, die heb je nodig als je de job wil identificeren. Ook zie je het percentage dat hij gebruikt van de hele computer (niet 1 cpu, maar alle). Bij TIME vindt je de tijd dat een job draait. Deze velden + NICE zijn de belangrijkste.

Mocht je ooit inloggen op een computer kijk dan altijd even of deze heel druk bezig is door middel van top. Als dat zo is kun je veel beter door- /inloggen op een andere computer. Al zie je bijvoorbeeld een Netscape draaien voor meer dan 4 uur op 20% cpu, dan kun je het beste een mailtje sturen naar de helpdesk. Als een computer plotseling traag wordt weet je nu hoe je dat kunt uitzoeken.

De NICE van een proces. De processen worden gescheduled op de processor aan de hand van een priority queue (dit gaat over Unix en niet over een ander systeem en zeker niet over windows...). De processen met de laagste priorities krijgen voorrang. Dus als een proces draait met nice 19 betekent dit dat hij19 veelheden lief is voor jouw processen! En aangezien alles uit nemen en geven bestaat moet jij hier ook rekening mee houden.

Alle studenten die matlab, genetische algoritmes of Java-rekenwerk uitvoeren dat langer duurt dan 30 minuten moeten gebruik maken van het commando renice. Doe je dit niet loop je de kans dat jouw proces wordt gekilled door zo'n vervelende :) systeembeheerder of helpdesker en krijg je ook nog een stomme opmerking naar je hoofd geslingerd! Je moet immers lief doen voor anderen. Kortom het volgende:

renice -d inc pid

load averages: 0.03, 0.03, 0.03 18:40:23 152 processes: 111 sleeping, 18 zombie, 22 stopped, 1 on cpu Memory: 4096M real, 3038M free, 402M swap in use, 33G swap free PID USERNAME THR PRI NICE SIZE RES STATE TIME CPU COMMAND 4003 tvburger 1 18 0 1656K 1248K cpu0 0:00 0.16% top-sun4u-5.8


Pid staat voor pid wat “process id” betekent. Dat kun je vinden met o.a. top. Inc staat voor het aantal hoeveelheden lief dat je wil toenemen. Nadat je een proces start zoek je de id op en geef je hem een nice van 19. Gelijk nice-en kan ook door middel van:

nice inc commando

Hiermee voer je het commando uit zoals je normaal doet alleen dan met nice 'inc'.

Module 2 Principes van Operating Systems; werken met UNIXabhulai/icg/dictaat/module2.pdf · 2007....

Documents

Transcript of Module 2 Principes van Operating Systems; werken met UNIXabhulai/icg/dictaat/module2.pdf · 2007....