Nano
the
nanny of
pico
zelfevaluatie
v0.1
Naam : Van Belle
Werner
e-mail : we47091@is2.vub.ac.be
programmeerproject
1e licentie Computerwetenschappen
Projectbegeleider: Wolgang
Demeuter
Wel, ik ben beginnen implementeren voordat ik pico noch java grondig kende. Hierbij onderschatte ik pico en overschatte ik java. Een voorbeeld van een zwaar probleem dat ik tegen ben gekomen en dat ik niet opgelost heb zijn de 'functionele formele parameters met formele parameters.'. Om dit probleem op te lossen moet de runtime-representatie van de environments wijzigen alsmede de call-mechanismen veranderen en de compiler aanpassen zodat er 'name-information' doorsijpelt in de uitgevoerde code.
Het eerste idee van de begeleidende assistenten was dat ik java-bytecode zou uitvoeren. Na een weekje op dit idee gebroed te hebben heb ik het uiteindelijk toch moeten verwerpen omdat ik niet veel mensen natives zie schrijven in java bytecode. (En als het toegelaten zou zijn natives in java te schrijven, dan zijn de eventuele optimisaties die ik kan doorvoeren met betrekking tot environments de mist in)
Pico is een taal die eigenlijk niet gemaakt is om gecompileerd te worden. (getuige daarvan het feit dat men van plan is een 'eval'-functie toe te voegen.) Met als gevolg dat de gegenereerde code (die zeer sterk geoptimizeerd is) is HEEL wat trager dan de code die geïnterpreteerd wordt. Bovendien pakt ze ook nog meer plaats in. (misschien ware het beter een pico-interpreter te schrijven in java).
De taal was nog niet af toen ik ze moest compileren (Getuigen: eveneens de 'eval'-functie. En de function assignment die mij tot op heden nog steeds een raadsel is)
Een goede usermanual was absoluut niet voorhanden. De primitieven en dergelijke zijn rotslecht gedocumenteerd, en reverse engineering (zoals blijkbaar van mij verwacht werd) is nu niet echt een schitterend alternatief.
Java is een taal die veel te abstract en te highlevel is. (Ik geloof zeer zeker dat ze machine-independent is, maar ze is zo abstract dat ik nauwelijks nog een goed runtime-representatie voor de primitieve objecten kan voorzien. (Ze moeten afstammen van 'Object' en dat is duidelijk verre van performant.)
Ik heb bestaande code hergebruikt (de lexicale analyzer en grammatica parser) zodat er zeker geen onverwachtte "can't parse" errors optreden.
Volgende delen zijn zeer duidelijk gescheiden : 'optimizer', 'environments', 'code-generator', 'intermediate code'
De natives zijn op zeer cleane wijze aangebracht. Het toevoegen van eventuele nieuwe natives vergt slechts twee stappen: Een implementatie van de native schrijven in java (volgens de conventies uitgelegd in de user-manual) en de file 'natives.dat' aanpassen. (deze bevat informatie hoe de native gecalled wil worden). Het is inderdaad nog steeds mogelijk natives te herdefiniëren. In een gesprek met Wolf wou hij een soort 'up/down' mechanisme geïmplementeerd zien zoals in agora. Omdat dit het doel van dit project een beetje voorbij schiet heb ik dit niet gedaan.
De design van de environments is schitterend gevonden. Het feit dat er zoiets is als 'acties op environments' en dat deze gerepresenteerd worden ben ik toch wel trots op, des te meer dat ik het systeem zelf bedacht heb.
Ik heb een rijk scala aan ADT's in de compiler gestouwd. Maar dit is reeds duidelijk te zien in de opbouw van de compiler.
Als tools heb ik de command-line compiler Watcom C/C++ 10.5 gebruikt en DOS/4GW als dos-extender. Dat wil dus zeggen dat ik toch ontwikkelde onder hetzelfde platform waar java draait. Lex en yacc heb ik niet nodig gehad omdat Prof. Theo's code voldoende goed was. Als editor heb ik Turbo Pascal 6.0 (van Borland International) gebruikt.
De usermanual is goed, wel wat technisch, maar kom.
Het coderen zelf in C vond ik bijlange niet slecht, ik heb mooie code geschreven die grondig gedocumenteerd is. De code is portable naar andere architecturen.
Uiteindelijk vind ik de design die ik heb gedaan met de gegeven kennis op dat ogenblik goed. Alleen jammer dat er nadien nog plotsklaps een extra mogelijkheid bijkwam, waardoor de nauw sluitende design naar de knoppen was. In het algemeen was dit project juist voldoende om java & pico te leren (dus eigenlijk het schrijven van een prototype). Het spreken van C is duidelijk geen probleem.