D KEEL

1. D KEEL http://www.arvutilaat.net/D/ Presentatsiooni ja näitefailide autor: Martin Laak

2. D KEELED • On loodud mitmeid D nimelisi keeli. Enamasti on eesmärgiks luua C++ parandus ja edasiarendus. • D keeled jagunevad kaheks • Keelde C++ transleeritavad • Täielikult kompileeritavad • Enamik nendest keeltest on välja surnud ja omab väga väikest kasutajaskonda. • Esimene ülemaailmse kuulsuse ja kasutajaskonna võitnud keel on firma DIGITAL MARS poolt loodud D keel.

3. DIGITAL MARS D KEEL • Enamik inimesi ei tea midagi D keeltest, teab vaid D keelest ja selleks on DIGITAL MARS D keel. See on ainuke omanimelistest, mis on saanud suure tuntuse, nii et tähestiku täht D kuulub õigusega neile ja edaspidi (siin presentatsioonis) D keel tähendab just selle firma D keelt. • Keele ja kompilaatori loojaks on Walter Bright, kes on enne loonud mitmeid C ja C++ kompilaatoreid, ühe Java kompilaatori ja kirjutanud artikleid programmeerimisest. • D keel sündis 1999 aastal ja on sestpeale kõvasti arenenud. Eksisteerib D foorum, kus arutatakse läbi keele muudatused ja täiendused. • Keele süntaks on väga sarnane C++ omale, sealt on aga eemaldatud ülearused käsud, C++ ehituslikud 'vead' ning lisatud mitmeid uusi ja huvitavaid võimalusi. Osad nendest võimaldavad kasutada uusimaid programmeerimistehnikaid nagu “Unit Testing”, osad aga lihtsalt kergendavad ja lühendavad programmide kirjutamist.

4. D KEEL • Keele kompilaator on vabavara ning kompileerib otse masinkoodiks; olemas nii Windowsi, kui Linuxi jaoks. • Kompileerimine on lihtne: dmd failinimi.d loob failinimi.exe (Windows) või siis lihtsalt failinimi (Linux) • Keelega koos on runtime library Phobos, mis sisaldab mitmeid standardseid funktsioone ja klasse. Peale muu huvitava on seal ka vahendid lihtsalt Tcp/Ip kasutamiseks ja .zip failidega manipuleerimiseks • NB Keel ja kompilaator on veel natuke arenemisjärgus, versioon on 0.93. See tähendab, et kes soovib, saab veel veidi keele kujunemisele kaasa rääkida! Hoolimata sellest, et asi veel areneb, saab seda juba professionaalseks tööks kasutada! Areng on aga juba lõppjärgus ning suuri muudatusi ilmselt enam ei tule. • Aadress on http://www.digitalmars.com/d/ või googlisse “D programming language”.

5. Milleks saab keelt D kasutada? • Ma teen ühte cgi webiserverit selles. • Kuna D Windowsi ja Linuxi versioonidel on väga vähe erinevusi, saab kirjutada koodi, mis töötab korraga mitme OS-i all. (Samast koodist saab kompileerida versioonid Windowsi ja Linuxi jaoks) • Kui on soovi, saab selles isegi operatsioonisüsteemi kirjutada. • Näidetena tegin peale muude ka ühe zip failide lahtipakija (myunzip.d 96 rida koos kommentaaridega), ühe webi lehe allalaadija, mis laeb koos lehega ka pildid ja pakib need kõik zip faili (httpzip.d 182 rida koos k.), failide tükeldaja ja kokkupanija (splitter.zip 96 rida) . • Kuna D on ühilduv kõigi C graafika teekidega, sobib väga kenasti tavarakenduste tegemiseks: mängud, kontoritarkvara jne. • Objetkorienteerituse ja hea modulaarsuse tõttu sobib hästi suurte projektide ja rühmatöö tarbeks. • Crosscompile: mul õnnestus Linuxis D failidest Windowsi exe-d kompileerida. (väikseks abiks oli Windowsi emulaator Wine)

6. C++ VEADC++ oli hea edasiarendus C keelele, kuid sellel on ka mõned vead. • C++ on liiga keeruline, keele standard on üle 750 lehekülje pikk ning sisaldab ka palju vananenud tehnikaid. See põhjustab kolme sorti probleeme. • On väga vähe programmeerijaid, kes tunnevad kasvõi poolt standardit. Paljud kasutavad ainult ühte osa keele võimalustest ja neil võivad tekkida probleemid, kui on vaja koostööd teha. • Enamus C++ kompilaatoreid pole standardiga ühilduvad. Kompilaatorite tegemine on kulukas ja aeganõudev. Keele keerukuse tõttu esineb mitmetes kompilaatorites vigu. • Uute võimaluste toomine keelde on väga raske, kuna uued käsud ei tohi mingil moel vastuollu minna eelneva standardiga. Ja kuna standard on väga pikk ja keeruline, siis võib keele uuendamiseks kuluda aastaid.

7. VEEL C++ VIGU • C-l ja C++-l puudub automaatne mälu vabastamine. Seda on küll võimalik väliste teekidega juurde pookida, aga standardisse see ei kuulu. Siit võivad tulla mälu lekked. • Puudub võimalus teada saada massiivide ja mäluväljade (array) pikkust. Pikkus tuleb alati kaasa anda teise muutujaga. (Näiteks standardne main(int n,char **s). • Puudub mäluväljade piiride kontroll. Kui ühes programmi osas jookstakse massiivi piiridest välja, siis võib viga ilmneda hoopis muus programmi osas. • C ja C++ on tekstipõhised. Kõigil varemkompileeritud moodulitel peab kasutamiseks olema päisefail, mis sisaldab tekstina meetodite signatuure. See põhjustab kompileerimise aeglust. (Näiteks programmid, mis kasutavad win.h faili, kompileerivad väga tüütult kaua) • Klasside kirjutamine (eriti operator overloading) on keeruline ja tüütu. • Täielik ühilduvus C-ga teeb standardi keeruliseks ja toob kaasa mitmed C võimalused, mida tänapäeval enam vaja ei ole. • Puuduvad mitmed tänapäeval vajalikud võimalused, nagu näteks automaatne testimine, automaatne mälu majandus, design by contract jne. Standardi keerukuse tõttu on neid ka raske lisada.

8. KÜSIMUS: MITU C++ PROGRAMMEERIJAT LÄHEB VAJA, ET ELEKTRIPIRNI VAHETADA? VASTUS: ÜHTE, AGA PEALE SEDA EI TÖÖTA ENAM EI KÜLMKAPP EGA TUALETT. Paraku iseloomustab antud nali C++ vigu üsna hästi.

9. MIS PARANDUSI D PAKUB? • D standard on u 200lk (C++ 750 asemel). Lihtsam programmeerida, lihtsam kompilaatoreid teha. • Automaatne mäluvabastamine on olemas, aga seda on võimalik vajadusel seadistada või isegi välja lülitada (näiteks kui on vaja teha süsteemi taseme programmeerimist) • Massiividel ja mäluväljadel (array) on pikkus. Kui a on massiiv, siis selle pikkus on a.length. Parameetritega main funktsioon näeb välja “int main(char[][] args)” • Mäluväljade piirid on kontrollitud ja teistesse mäluväljadesse sissesõitmine on välistatud. Genereeritakse runtime exception. Selle exceptioni peale lootma jäämine aga pole standardi järgi lubatav. Kui näiteks Javas võib massiivi rahulikult kirjutama hakata, ilma selle pikkust teadmata ning erindit ootama jääda (ja isegi massiivi pikkuse nii järgi uurida), siis D-s see pole lubatud. • D kasutab eelkompileeritud mooduleid. “#include<stdio.h>” asemel on “import std.file;” • D ei erista . -> operaatoreid. • Klasside kirjutamine ja operator overloading on lihtsmad. Näiteks selle asemel, et kõik operaatorid > < >= <= üle kirjutada, piisab ainult funktsiooni opCmp ülekirjutamisest. • C-ga on täielik ainult binaarne ühilduvus, tähendab, et saab kasutada C eelkompileeritud mooduleid ja library-d, aga kompilaator ei pea tundma C süntaksit. • On lisatud enamus tänapäeval vajaminevaid võimalusi.

10. MIKS D EI OLE JAVA?Kuigi D võtab Javast eeskuju, seda võib mõnes mõttes vaadata kui Java parandust, on siiski neil keeltel mitmeid erinevusi. • Java jookseb virtuaalmasinas (VM) . See teeb Java väga aeglaseks ja mälunõudlikuks. Samuti ei saa Javaga süsteemitasemel programmeerida. D aga on täielikult kompileeritav ja sisaldab kõiki vahendeid süsteemtaseme programmeerimiseks (nagu näiteks pointerid). D lubab isegi inline assemblerit oma koodi kirjutada. • Java ei võimalda operator overloading-ut. • D ei sunni kasutajale peale object orienteeritud lähenemist. • D ei sunni kasutajat erindeid püüdma. • Keeles D on tihtikasutatavad asjad tehtud lihtsaks ja loogiliseks! • D ei sunni pidevalt tuhnima apis. (“Write code, not research api”). • Einevalt Javast on D-l täielik binaarne ühilduvus C-ga. (kompileeritud moodulid, library-d)

11. MÕNED D UUED HUVITAVAD VÕIMALUSED • Mitmetest skriptikeeltest tuntud foreach. • Kogu massiivi saab korraga väärtustada. • Näiteks A[]=5; kirjutab kogu massiivi täis arvuga 5. • Operaator .. • Mäluväljade kokkukleepimine operaatoriga ~ • Assotsiatiivsed massiivid. Näiteks Tervitused[“Martinile”]=”Terekest”; Muutuja Tervitused deklareeritakse lihtalt char[] Tervitused[char[]]; • Koodi kirjutamine HTML-i ja selle kompileerimine. • Property-d. • Design by Contract • Nested functions (pesastatud funktsioonid)

12. FOREACH foreach(int a;M){ printf(“%d\n”,a); } Prindib kogu M massiivi sisu ekraanile. Algul omistataks a=M[0], siis a=M[1] kuni a=M[M.length-1].

13. FOREACH int main(){ int M[5]; for(int loendur=0;loendur<M.length;loendur++)M[loendur]=loendur; for(int loendur=0; loendur<M.length;loendur++){ int a=M[loendur]; printf("%d\n",a); } foreach(int a;M){ printf("%d\n",a); } printf(“Antud näites teevad for ja foreach sama asja\n”); printf(“Foreach aga palju lihtsamalt\n”); return 0; }

14. OPERAATOR .. //Algul omistame massiivi M elementidele väärtused 0..20 int M[20]; for(int x=0;x<20;x++)M[x]=x; //See prindib välja 0,1,2 kuni 17,18,19 foreach(int a;M){printf(“%d,”,a);} //See prindib välja 0,1,2 kuni 7,8,9 foreach(int a;M[0..10]){printf(“%d,”,a);} 0..10 tähendab null kuni 10, kusjuures 10 on välja arvatud. Operaatorit .. saab kasutada massiivide ja mäluväljade puhul. Veel näiteks M[1..3]=M{5..7]; M=M[1..10]~M[25..M.length]; (Lõikab massivist M tüki välja.)

15. Mäluväljade kokkukleepimine • Esmapilgul võib olla vähetähtis omadus, tegelikult aga väga vajalik • Toimub märgi ~ abil. Näiteks massivc=massiva~massiivb; • Kasulik näiteks stringidega töötamisel • s=”Tere “~nimi~” meeldiv tutvuda”; • (D stringidel pole lõpus baiti 0. Sellepärast saab neid liita kui mäluvälju) • Võib kasutada mäluväljalt tüki välja hammustamiseks. • s=s[0..25]~s[100..s.length]; • Või lihtsalt mäluväljade ühendamiseks • s=u~k[0..199]~t;

16. ~ja... //fail: kleepimine.d importstd.stream; int main(){ char A[]="Mingi suvaline tekst"; char B[]="koos suvaliste sõnadega"; char C[]=A~B; stdout.writeLine(C); C=C[0..10]~C[35..40]; stdout.writeLine(C); C=C[0..6]~C[11..C.length]; stdout.writeLine(C); return 0; }

17. Assotsiatiivsed massiivid (Associative Arrays ) • Lihtne deklareerida int VANUS[char []]; • Lihtne kasutada VANUS[“Martin”]=20; VANUS[“Jüri”]=19; VANUS[“Madis”]=VANUS[“Martin”]+VANUS[“Jüri”]; • Võtmete jaoks on keys property foreach(char []s; VANUS.keys){ printf(“%.*s on %d aastat vana\n”,s,VANUS[s]); } • Deklareerimise kohta: • int VANUS[char []]; tähendab int massiivi, mille võtmeteks on stringid. • char MASSIIV[double]; on char massiiv, mille võtmeteks ujukoma arvud

18. ASSOTSIATIIVSED MASSIIVID //Fail assot.d import std.stream; int main(){ char []VASTUS[char[]]; VASTUS["Tere"]="Tere ka sulle!"; VASTUS["Exit"]="Nägemist"; VASTUS["Bye"]="Nägemist"; VASTUS["Kes sa oled?"]="Olen Tehisintellektitus."; VASTUS["Mis on su lemmikmuusik?"]="Mis asi on muusik?"; VASTUS["Jah"]="Tore!"; VASTUS["Ei"]="Kahju"; VASTUS["Miks?"]="Ei tea, kahjuks."; printf(">>>Tere, kas räägime!\n"); while(1){ char s[]=stdin.readLine(); stdout.writeLine(">>>"~VASTUS[s]); if(s=="Exit" || s=="Bye")break; } return 0; }

19. Property-d • Samasugused nagu on Delphis ja C-Builderis. • Näiteks Aken1.left=50; liigutab akent. (Kutsutakse välja funktsioon). • Ilma property-ta oleks Aken1.setleft(50). • Aken1.left=Aken1.left+90; >>>>>> Aken1.setleft(Aken1.getleft()+90); • Muudab koodi arusaadavamaks, lihtsustab selle kirjutamist. • Keeles D käib nende defineerimine lihtsalt. On vaja kahte samanimelist funktsiooni int left(int val){ WindowSendMessage(this.handle, Setlefpos, val); return val; } int left(){ return WindowGetMessage(this.handle, GetLeftpos); } • Üks funktsioon omab sisendparameetrit, teine mitte. Kompileerimise aja teisendatakse: left=1; >>>> left(1); a=left=x; >>>> a=left(x); n=left; >>>> n=left();

20. Nested functions (pesastatud funktsioonid) • Mõnikord kasutatakse osasid funktsioone ainult ühes teises funktsioonis. • Sellisel juhul pole mõtet deklareerida funktsioone globaalsetena ja risustada aadressiruumi. (Näiteks kogemata 2 samanimelist funktsiooni vms.) • Lihtne näide: int funk1(int n){ int funk2(int n){ printf(“%d”,n/2) } if(n<5)funk2(n*7); return n-1; }

21. Phobos (Runtime Library) • Keelega D on kaasas runtime library Phobos. Kõik moodulid, mis algavad std. , nagu näiteks std.string või std.c.linux on pärit sealt. • Phobos sisaldab standardseid vahendeid. Nagu C puhu standardsed .h failid (stdio.h stdlib.h jne). Phobose vaste on std.stream, std.socket jne. • Tuuakse sisse käsuga import. • C #include <stdio.h> • D import std.stream; • Kõik kasutatavad Phobose moodulid kompileeritakse programmi sisse. Phobost pole eraldi vaja kaasa panna. Phobose lähtekood on avatud. See on täielikult kirjutatud keeles D. Phobose dokumentatsioon on veel veidi puudulik, nii et selle lähtekoodi lugemine osutub mõnikord vajalikuks.

22. Phobos – tähtsamad moodulid • std.file – lihtsamad failioperatsioonid. Kirjutamine, lugemine, lisamine. • std.stream – sisend-väljund streamid, k.a. failistreamid. • std.string – operatsioonid stringidega, näiteks toString(uint) jne. • std.conv – stringi konvertimine arvuks. • std.math – matemaatikafunktsioonid. • std.socket – Tcp/Ip socketid. • std.socketstream – Tcp/Ip streamid. Lihtsam kasutada, kui otse socket. • std.zip – Vahendid Zip failidega manipuleerimiseks. • std.regexp – regulaaravaldiste töötlemine. • std.md5 – md5 checksummide arvutamine.

23. Phobos – std.file • write(char[] failinimi, void[] failisisu) -kirjutab faili • näiteks write(“valja.txt”,MAS); kirjutab masiivi 'MAS' sisu tervenisti faili 'valja.txt' • void []read(char[] failinimi) -loeb faili mällu ja tagastab viida • MAS=read(“valja.txt”); - peale seda on kogu faili 'valja.txt' sisu massiivis 'MAS', • append(char[] failinimi, void[] failisisu)-kirjutab faili lõppu • uint getSize(char[] nimi) – tagastab faili suuruse • remove(char[] nimi) - kustutab faili • mkdir(char []nimi); - loob kataloogi • JA PALJU MUUD • NB! char[][] listdir(char[]) pole neil veel täielikult valmis. Ei tööta Linuxis!

24. Phobos – std.stream • class Stream • uint read(ubyte []buffer) – loeb streami sisu massiivi, loetakse maksimaalselt buffer.length baiti. Massiivi suurust ei muudeta, see jääb sama suureks, kui oli enne streamist lugemist. Funktsioon read tagastab tegelikult loetud baitide arvu. Näiteks int n=mingistream.read(BUF); loeb streami massiivi BUF, kusjuures massiivi suurust ei muudeta. Muutuja n näitab nüüd, mitu baiti tegelult loeti. Kui massiivi BUF suurus oli enne näiteks 100 baiti, siis loetakse maksimaalset 100baiti. Kui streamis on infot rohkem, kui 100 baiti, siis jäetakse ülejäänu lihtsalt lugemata. Seda saab siis lugeda järgmise read käsuga. Kui streamis on vähem kui 100 baiti, siis jäävad massiivi BUF ülejäänud baidid lihtsat puutumata. • readLine() – loeb streamist rea teksti mällu ja tagastab viida sellele mälule Näiteks char []s=stdin.readLine(); Ootab kasutajalt sisestust, kui kasutaja on rea teksti sisestanud, siis loetakse see mällu ja edaspidi sisaldab massiiv s seda rida. NB, luuakse uus mäluväli ja tagastatakse viit sellele! • scanf(char[] format, ...) - nagu tavaline C scanf, aga konkreetsel streamil. näiteks stdin.scanf(“%d”,&a);

25. Phobos – std.stream • class Stream • bit eof() – tagastab true, kui on käes streami lõpp (näiteks faili lõpp), false, kui streamist on veel midagi lugeda. Näiteks while(!minustream.eof()){ char []s=minustream.readLine(); stdout.writeLine(s); } • uint write(ubyte []malu) – kirjutab terve massiivi sisu streami (Vähemalt niipalju, kui võimalik). Tagastab kirjutatud baitide arvu. Näiteks stdout.write(MAS) kirjutab kagu massiivi MAS sisu ekraanile. • void writeLine(char[] tekst) – kirjutab rea teksti ekraanile, lisab reavahetuse. näiteks writeLine(“Tere”); või writeLine(CMAS); kus CMAS on char massiiv. • writeString(char []tekst) – sama mis eelmine, aga ei lisa reavahetust. • printf(char []s, ...) – nagu tavaline printf, aga suunatud konkreetsele streamile näiteks stdout.printf(“%d”,a); • NB! std.stream sisaldab Stream tüüpi objekte stdin ja stdout

26. Phobos – std.stream • class File : Stream (Klass File lainendab klassi Stream) Kõik klassi Stream funktsioonid + veel mõned: • this() - konstruktor, loob uue Fail tüüpi objekti, pärast kasutage open või create. • this((char[] failinimi, FileMode mode) – loob Fail tüüpi objekti ja avab soovitud faili. • open(char[] failinimi, FileMode mode) - avab faili. Parameeter mode saab olla kas FileMode.In (lugemiseks) või FileMode.Out (kirjutamiseks) • close() – sulgeb faili. • create(char[] filename) – loob faili kirjutamiseks Näiteks File f=new File(); f.create(“logifail.txt”); f.writeLine(“Tere fail!”); f.close():

27. Phobos – std.string • char []toString(int n); • char []toString(double d); • char []toString(char c); Muudab mistahes arvu stringiks. Näiteks: stdout.writeLine(“5+5=”~toString(5+5)); • real atof(char[] s) – konverdib Stringi reaalarvuks. (double d=atof(.....)) • find(char []kust, char []mis) - leiab stringi mis esimese esinemise stringis kust, tagastab asukoha indeksi või -1, kui ei leidunud. • int cmp(char s1[],char s2[])- võrdleb kahte stringi. Ei erista suuri/väikseid tähtti. <0 kui s1<s2 =0 kui s==s2 >0 kui s1>s2 • int icmp(char s1[],char s2[]) -võrdleb kahte stringi, eristab suuri/väikseid tähti.

28. Phobos – std.conv Funktsioonid, mis konverdivad stringi arvuks: • byte toByte(char[] s) • ubyte toUbyte(char[] s) • short toShort(char[] s) • ushort toUshort(char[] s) • int toInt(char[] s) • uint toUint(char[] s) • long toLong(char[] s) • ulong toUlong(char[] s) • Et muuta stringi reaalarvuks, kasutage real std.string.atof(char [])

29. Phobos näide (naide.d) import std.conv; importstd.string; importstd.stream; int main(){ char []nimi; char []arv; stdout.writeLine(“Tere, mis Teie nimi on?”); nimi=stdin.readLine(); stdout.writeLine(“Tere“~nimi~”meeldiv tutvuda”); stdout.writeLine(“Palun kirjutage üks arv”); arv=stdin.readLine(); if(find(arv,”.”)==-1){ printf(“sisestasite arvu %d\n”,toInt(arv)); } else printf(“sisestaside realarvu %f\n”,cast(double)atof(arv)); File f=new File(); f.create(“logifail.txt”); f.writeLine(“korras”); f.close(); return 0; }

30. Phobos lõpetuseks • Phobos ei ole veel täiesti valmis, on paar asja, mis ei tööta veel korralikult, või töötavad aeglaselt. Need hõlmavad põhiliselt Linuxi versiooni. • Kuna see on avatud kood, siis saab need ise ära parandada. • Phobos areneb ja laieneb veel kindlasti palju. • Mõned Phobose eelised • Lihtne programmeerida Tcp/Ip • Lihtne zip failidega manipuleerida • Kõik muu vajalik olemas • Lihtne ülesehitus

31. D keel – lõpetuseks • Arvan, et D väärib kohta senise kahe suure, C++ ja Java, kõrval. • D muudab programmeerimise lihtsamaks ja vähendab töömahtu (minu isiklik kogemus) • D on suutnud võtta parima nii keelest C++, kui keelest Java. • Sellel on C++ võimsus, aga on palju lihtsam ja kontrollitum. • Paljud Java võimalused, aga mitte selle kohmakus! • Kui ma esimest korda sellest keelest kuulsin, ei pööranud ma sellele eriti tähelepanu. Alles palju hiljem hakkasin seda lähemalt vaatama ja proovima. • Avastasin, et selles on edukalt lahendatud mitmed probleemid, mis mind teiste keelte juures on häirinud. • Ligi 7 aastat oli mu lemmikkeeleks C/C++, nüüd on D. • Tasub proovida!

32. Lisa: näitefailid • array.d – tehted massiividega • asm.d – inline assembleri kasutamine • assot.d – assotsiatiivsed massiivid • cast.d – casting, erinevat tüüpi viidad ja nende omavaheline omistamine • convert.d – stringide arvudeks konvertimine ja arvude stringideks konvertimine • esimene.d – lihtsaim programm, mis kompileerub • fil2.d – failide io, stdout. • files.d – failide io, see programm avab ühe faili ning kirjutab selle sisu muudetud kujul teise • foreach.d – demonstreerib tsüklidirektiivi 'foreach' kasutamist • httpzip.d – tõmbab html lehe koos piltidega ning pakib need zip arhiivi.

33. Lisa: näitefailid • io.d – standardne sisend ja väljund • klass2.d – klasside ja liideste kasutus, pärilus, property-d • klassjaisend.d – klasside ja nende isendite kasutus • kleepimine.d – mäluväljade kleepimine operaatori ~abil, operaator .. • kuva.d – fail io, kuvab faili sisu ekraanile, kusjuures iga lause uuele reale. • label.d - Label, tsüklid, break ja continue koos sellega. • maillist.d – kuvab mailboxis olevate kirjade pealkirjad • myunzip.d – failide lahtipakkija. • naide.d – näide Pohobose kasutamisest. • nimed.d – assotsiatiivsed massiivid. • printf.d – funktsiooni printf kasutamine

34. Lisa: näitefailid • simpleip.d – lihtne näide Tcp/IP programmeerimisest • splitter.d – failide tükeldaja • suhtle.d – property tööpõhimõte • unittest.d – unit testing näide • version.d – direktiivi version kasutamine, koodi kirjutamine mitmele OS-ile. • yhenda.d – mäluväljade kokkukleepimine • zipsisu.d – näitab arhiivi pakitud failide nimekirja.