LetOO en let måde at komme i gang med Objekt Orienteret programmering

Transkript

1 LetOO en let måde at komme i gang med Objekt Orienteret programmering BS3-projektet på 3. år af bacheloruddannelsen i datalogi under Åben Uddannelse ved Aalborg Universitet. Studerende: Brian Sejberg Christian Sejberg Vejleder: Per Madsen År 2001.

2 Forord Denne rapport er udarbejdet i forbindelse med BS3-projektet på 3. år af bacheloruddannelsen i datalogi under Åben Uddannelse ved Aalborg Universitet i år Formålet med dette projekt er at kunne anvende væsentlige principper i programmeringssprog og teknikker til beskrivelse og oversættelse af sprog generelt. Projektet består i en analyse af en datalogisk problemstilling, hvis løsning naturligt kan beskrives i form af et design af væsentlige begreber for et konkret programmeringssprog. Gruppen består af 2 studerende, der er uddannet henholdsvis datamatiker og datanom. Desuden har begge praktisk erfaring med programmering og systemudvikling. I bilag 7.1 fra side 33 har vi kort beskrevet projektetableringen, herunder arbejdsform, møder osv. Rapporten er opdelt efter de faser projektet har gennemgået. Kapitel 1 Kapitel 2 Kapitel 3 Kapitel 4 Kapitel 5 Kapitel 6 Kapitel 7 Projektintroduktion. LetOO. Leksikalsk analyse. Syntaktisk analyse Konklusion Litteraturliste Bilag Denne rapports målgruppe er personer med interesse for sprog og oversættelse. Rapporten er en helhed og alle kapitler bør læses for at få det størst mulige udbytte. Per Madsen fra Aalborg Universitet har været gruppens vejleder. På gruppens websted er gruppens nyeste dokumenter og programmer til rådighed. Brian Sejberg Christian Sejberg 1

3 Indholdsfortegnelse Forord Projektintroduktion PROBLEMFORMULERING PROBLEMAFGRÆNSNING LetOO INTRODUKTION DESIGN OVERVEJELSER Objekt orientering Typer Klasser Konstruktører og metoder Gentagelser og forgreninger GENNEMGANG AF LETOO Erklæringer Regneudtryk Betingede sætninger Gentagelser Klasser Standard metoder BESKRIVELSE I UDVIDET BNF STANDARD METODER ET SIMPELT PROGRAM SKREVET I LETOO Leksikalsk analyse Syntaktisk analyse Konklusion Litteraturliste Bilag PROJEKTETABLERING Gruppesammensætning Møder Brugerindflydelse Arbejdsform KILDEKODE

4 1 Projektintroduktion 1.1 Problemformulering Det kan ofte være svært for nybegyndere at komme i gang med at programmere, hvis de starter med et sprog som Java eller C++. På de korte videregående uddannelser som fx. datamatikeruddannelsen bliver de studerende introduceret for Java eller C++. Disse sprog har mange faciliteter som gør at sproget virker uoverskueligt for nybegyndere der ikke har programmeret før. Da uddannelserne er komprimeret i tid vil det lette forståelsen og introduktionen til objekt orienteret programmering for den studerende, hvis sproget er mere simpelt at lære og anvende. Derfor vil vi i dette projekt udvikle et simpelt objekt orienteret sprog, som vi har valgt at kalde LetOO, hvor nybegyndere hurtigt kan komme i gang. Efter at have anvendt dette sprog i en kort periode kan brugeren så begynde at anvende Java, C++ eller lign. Spørgsmålet er så om det er muligt for os i dette projekt at nå vores mål beskrevet ovenover. Er det muligt at udvikle et sprog LetOO, som gør det nemmere for en nybegynder at blive introduceret til objekt orienteret programmering. Kan vi designe et simpelt og overskueligt sprog som er objekt orienteret til en nybegynder, uden at det bliver så simpelt at det ikke kan anvendes til en introduktion overhovedet? 3

5 1.2 Problemafgrænsning For at udvikle et simpelt objekt orienteret sprog vil vi: Anvende danske termer i sproget, for at øge forståelsen for nybegyndere. Genbruge ordvalg fra Objekt Orienteret Analyse og Objekt Orienteret Design, så syntaksen bliver hurtigere at lære for personer med erfaring fra OOA og OOD. Begrænse sproget så det bliver nemmere at anvende. Vi vil bl.a. ikke gøre det muligt at anvende multipel nedarvning, og vi vil kun tillade et udpluk af kendte simple datatyper. De øvrige begrænsninger vil blive beskrevet i rapporten hvor LetOO beskrives. Leksikalsk analyse Vi vil anvende JFLex til at generere vores scanner, der udfører den leksikalske analyse. Vi startede med at bruge JLex, men JFLex er nemmere at anvende og har flere muligheder. Syntaktisk analyse Vores parser vil vi generere vha. LALR Parser generatoren CUP (Constructor of Useful Parsers). Den kan nemt integreres med scanneren dannet ved brug af JFLex. Parseren vil oversætte vores simple objekt orienterede sprog til Java kildekode. Vi vil derefter automatisk vha. Java s kompiler (Javac) oversætte Java kildekoden til Java bytekode. Vi vil dog prøve at fange så mange fejl som muligt inden Javac kaldes. Finder Javac alligevel en fejl, vil vi vise hvilken linie i den oprindelige LetOO kildekode fejlen stammer fra. 4

6 2 LetOO 2.1 Introduktion LetOO er et sprog der er beregnet til nybegyndere i programmering, som skal introduceres til objekt orienteret programmering. LetOO skal være det sprog en studerende starter med at lære, før et skift til fx. Java eller C++. Ved at starte med LetOO bliver den studerende bekendt med de grundlæggende objekt orienterede begreber, og kan hurtigt lave små simple applikationer. Vi har taget udgangspunkt i de begreber som Java og C++ indeholder, og taget de dele som er de mest basale, og som vi mener at en nybegynder bør kende til. 2.2 Design overvejelser Der er flere overvejelser forbundet med at udvikle et programmeringssprog som skal være objekt orienteret og simpelt. Der er lavet flere objekt orienterede sprog, bl.a. Java og C++, som indeholder meget funktionalitet som er nødvendig for at udvikle avancerede programmer. Fx. synkronisering og tråde. Vi har med inspiration fra disse to sprog udviklet LetOO. En nybegynder i objekt orienteret programmering har brug for et simpelt sprog, for at kunne komme hurtigt i gang uden at skulle bruge for meget tid til at opsætte udviklingsmiljø, og at skulle sætte sig ind i for mange regler. Vi har valgt at LetOO skal skrives i næsten naturligt sprog. Vi har undladt at anvende for mange specielle tegn for at nybegynderen hurtigere kan lære og nemmere kan huske syntaksen. Vi overvejede også at lave et udviklingsmiljø hvor brugeren nærmest klikker sig frem med musen til et færdigt program, men det har vi valgt ikke at gøre. Under designet af sproget er der nogle typiske ting der skal tages stilling til. Herunder bl.a. hvilke scopes vil vi lade sproget indeholde, skal der foretages dynamisk eller statisk type tjek. Da sproget er tiltænkt som en optakt til senere at programmere i fx. Java eller C++, må sproget ikke bygge på koncepter der ligger for langt fra disse sprog. Det skal være muligt at oprette objekter med metoder og attributter. De grundlæggende koncepter som LetOO bygger på er de samme som Java og C++. Genbrug af kode og indkapsling af data er nogle af de muligheder som skal være tilgængelige i LetOO. Genbrug er bl.a. gjort muligt ved at tillade nedarvning, og indkapsling af data ved at gøre attributter til private, og metoder til public. Private betyder at informationen (fx. en attribut) ikke er synlig for de klienter der anvender klassen. Omvendt betyder public at informationen er tilgængelig for klienterne. I LetOO har vi valgt at alle metoder er public og at alle attributter er private. Dette en klar grænseflade til klasserne og er lig den synlighed der er defineret i programmeringssproget Smalltalk. Vi har valgt at anvende klasse-, metode og blok scope, dvs. at en attribut der erklæres i klassen kan anvendes i alle klassens metoder, mens en attribut erklæret i en metode kun kan anvendes i den metode hvor den er erklæret. Endelig er der blok-scope fx. i forbindelse gentagelses-sætninger, hvor der kan erklæres attributter som kun kan anvendes i gentagelsens scope. Vi overvejede at anvende { og til at afgrænse klasse-, metode og blok scope, men valgte at bruge slut sammensat med 5

7 scope-typen, for at gøre det lettere for nybegynderen at læse programmet. Fx. afsluttes en metode med slutmetode. Vi har valgt at oversætte LetOO programmer til Java kildekode, og derefter anvende Java s kompiler for at oversætte til Java byte kode. Vi kunne også have valgt selv at danne fx. Java byte kode, men ved at danne Java kildekode opnår vi samme platformuafhængighed som Java. Samtidig giver det dog også den begrænsning at vi ikke kan lave noget i LetOO som ikke er muligt i Java. Typetjek vil blive foretaget i kompileringsøjeblikket, og dermed være statisk i LetOO. Da vi ikke tillader dynamiske typer er der ikke behov for dynamisk typetjek på kørselstidspunktet. Vi mener at statisk typetjek er et fornuftigt valg, da det fjerner mange fejlmuligheder som kun vil opstå på kørselstidspunktet Objekt orientering For at vores sprog bliver objektorienteret skal det understøtte de mest grundlæggende objektorienterede begreber som: Objekter Klasser Indkapsling Nedarvning Polymorfi Objekter er de grundlæggende elementer i objektorienteret analyse, design og programmering. I analysen bruger vi objekterne til at forstå edb-systemets omgivelser, og under design til at forstå og beskrive edb-systemet. Hvert objekt: Indeholder data som beskriver objektets tilstand Har et adfærdsmønster der defineres ved de operationer objektet har Har en individuel identitet Klasser bruges til at forstå og beskrive objekter. Definitionen på en klasse: En beskrivelse af en mængde af objekter med samme struktur, adfærdsmønster og attributter. Indkapsling anvendes bl.a. for at opnå en klar og entydig grænseflade til objektets og klassens data, hvilket øger gennemskueligheden ved anvendelse af klassen. Data tilknyttes de operationer der arbejder på dem. Edb-systemet nedbrydes i komponenter med veldokumenterede og velafgrænsede grænseflader, og indkapslingen sikrer at vi får robuste klasser, som kan ændres uden at det øvrige af edb-systemet skal ændres så længe klassens grænseflade ikke ændres. Derved bliver en disciplin som refactoring mere overkommelig. Nedarvning sikrer at vi kun behøver at oprette fælles data og metoder i en klasse. Herved undgår vi at skulle definere de samme metoder flere steder, og programmet bliver nemmere at vedligeholde og udbygge. Kort sagt er det en god måde at opnå genbrug af kode. Polymorfi gør det nemmere at sende beskeder til objekter som er relateret til hinanden igennem nedarvning. Et ofte anvendt eksempel til at beskrive anvendelse af polymorfi er et tegneprogram der 6

8 kan tegne cirkler, trekanter og firkanter. Disse geometriske figurer har nogle fælles egenskaber som med fordel kan samles i en superklasse, men de enkelte figurtyper har deres egen udgave af en draw metode til tegning af figuren på skærmen. Det vil så være muligt at sende beskeden draw alle figurtyper uden at bekymre sig om den aktuelle figurtype. Eksemplet er illustreret i nedenstående figur, hvor vi har anvendt Java syntaks og UML notation. abstract class Figur {... abstract public void draw();... class Cirkel extends Figur {... public void draw() {... class Trekant extends Figur {... public void draw() {... class Firkant extends Figur {... public void draw() { Typer Vi har valgt kun at tage typerne heltal og streng med. Heltal repræsenterer de hele tal, der i Java repræsenteres ved int, dvs. alle heltal fra og med og til og med I stedet for String i Java har vi valgt at kalde klassen streng. For at holde LetOO simpelt har vi ikke taget flere primitive datatyper med, som fx. flydende tal som float og double fra Java. Vi kunne have valgt at tage flere datatyper med, men med typerne heltal og streng, vil det være muligt for programmøren at komme hurtigt i gang og lave simple programmer, som er det primære formål med LetOO Klasser For at have en generel beskrivelse af fænomener med fælles egenskaber, har vi valgt at have klasser med i vores sprog. Det skal være muligt at oprette flere instanser af en klasse, og det gøres ved at oprette et nyt objekt for hver instans. For at genbruge de generelle egenskaber skal det være muligt at anvende nedarvning. Multipel nedarvning har vi dog ikke medtaget, da vi mener at det giver for mange komplikationer for nybegynderen, desuden understøttes det ikke direkte i Java. Det er dog muligt at opnå noget der ligner multipel nedarvning i Java ved fx. at have en reference til et andet objekt i en klasse, og samtidig nedarve fra en tredje klasse. Da klasser er et af de grundlæggende elementer i den objekt orienterede tankegang, er de taget med i LetOO. For at vænne programmøren til at udnytte, samt anvende nedarvning har vi gjort dette 7

9 muligt i LetOO. For at anvende en klasses generelle egenskaber skal der oprettes en instans af klassen; et nyt objekt. Vi har fravalgt den mulighed der er i Java for at oprette abstrakte klasser og metoder, og opererer i LetOO kun med konkrete klasser. I en abstrakt klasse defineres kun dele af implementeringen, og klasserne der nedarver implementerer så nogle af, eller alle klassens metoder. Muligheden for implementering af interfaces er ligeledes fjernet, for at afgrænse sproget. Det er dog muligt at overskrive metoder, dvs. at en subklasse kan overskrive en eller flere af sin superklasses metoder Konstruktører og metoder Konstruktører og metoder starter med en identifikation af om det er en metode eller konstruktør. Herved undgår vi at nybegyndere bliver forvirret over hvad det er, når de læser koden, og det er nemmere at huske hvordan definitionen skal være når programmet skrives. Adgangen til metoder er public og for attributter private. Herved opnår vi indkapsling af data, da attributterne kun kan tilgås af metoder som er defineret i klassen Gentagelser og forgreninger LetOO vil også indeholde mulighed for at programmere gentagelser og forgreninger, da det er nogle nødvendige muligheder for at få et program til at udføre selv simple opgaver. 2.3 Gennemgang af LetOO Erklæringer En variabel (id) skal erklæres før den bruges, og initieres i erklæringen. Eksempel på erklæring af et id af typen heltal med navnet tal og initieret med værdien 9. heltal tal tildeles 9; Eksempel på erklæring af en id af typen streng med navnet navn der initieres med værdien Hans. streng navn tildeles "Hans"; Eksempel på erklæring af en id af typen sandellerfalsk med navnet solgt der initieres med værdien falsk. sandellerfalsk solgt tildeles falsk; Vi har valgt at bruge tildeles i stedet for = som anvendes i Java til at initialisere en attribut. Herved bliver sætningen mere læsevenlig. I stedet anvender vi = til sammenligning af udtryk. 8

10 2.3.2 Regneudtryk Af regneudtryk har vi kun valgt at medtage mulighed for addition(+), subtraktion(-), multiplikation(*) og heltalsdivision(/) for at simplificere LetOO. Eksempler på anvendelse af regneudtryk, indsat som kommentarer og i parentes har vi angivet variablernes forventede værdier. heltal tal tildeles 0; (tal = 0) heltal tal2 tildeles 123; (tal2 = 123) tal tildeles 8 + 4; (tal = 12) tal tildeles * 2 3; (tal = 9) tal tildeles 8 + (2 * 2) 3; (tal = 9) tal tildeles tal2; (tal = 123, tal2 = 123) tal tildeles tal2 tal - 25; (tal = -25, tal2 = 123) tal tildeles 8/2; (tal = 4) tal tildeles 8/3; (tal = 2) Betingede sætninger For at give mulighed for at programmere forgreninger har vi medtaget en hvis-sætning, der evaluerer et boolsk udtryk og udfører efterfølgende sætninger indtil sluthvis, hvis udtrykket er sandt. Vi har medtaget flg. relationsoperatorer; >, <, =, >=, <=, <>. Vi har fravalgt en negationsoperator, fx.! i Java, for at holde sproget simpelt. Igen kunne vi også have valgt at anvende danske termer, fx. størreend i stedet for >, men efter vores mening er det nemmere for programmøren at anvende relationsoperatorerne. Vi har valgt at bruge termerne og og eller til at sammensætte udtryk. Fx. hvis saldo < kreditmax og overtrækbevilget. Eksempel hvor der udskrives Danmark hvis en streng type med navnet landekode har værdien DK : hvis landekode = "DK" skriv "Danmark" sluthvis Det er også muligt at bruge ellers til at angive en række sætninger der skal udføres hvis det boolske udtryk er falsk. Som i dette eksempel: hvis landekode <> "DK" skriv "Turist" ellers skriv "Dansker" sluthvis 9

11 Da vi har som mål at udvikle et meget simpelt sprog har vi valgt ikke at medtage muligheder som modsvarer switch-sætningen i Java Gentagelser For at give mulighed for at programmere gentagelser har vi medtaget en sålænge-sætning, der gentages sålænge udtrykket er sandt. Vi benytter + til sammensætning af strenge og addition. Vi kunne have valgt at anvende fx. satsammenmed i stedet for + ved sammensætning af strenge. Men vi mener at det vil være nemmere for programmøren at anvende +. sålænge valg < 10 skriv "Værdien af valg: " + valg; valg tildeles valg + 1; slutsålænge Gentagelsen starter med at validere om variablen valg, som skal være af typen heltal, er mindre end 10. Hvis valg er mindre end 10, fx. 5 skrives Værdien af valg: 5. Herefter tildeles variablen valg en ny værdi, Der gentages indtil valg er talt op til værdien 9, og derefter udføres sætningerne ikke mere Klasser En klasse har et navn og en krop. I kroppen erklæres og initialiseres variabler som fx. heltal, og metoder defineres. Navnet skal bestå af karakterer A..Å, a..å, hvor der ikke skelnes mellem store og små bogstaver, og hvor der kan indgå numeriske værdier i navnet. klasse MinKlasse... slutklasse En klasse kan nedarve egenskaber fra andre klasser ved at angive dette med nedarverfra klassenavn, hvor klassenavn er klassen der nedarves fra. Vi har valgt at benytte nedarverfra, da det er et term der ofte anvendes i forbindelse med omtale af nedarvning i OOA og OOD. klasse Bil nedarverfra Køretøj... slutklasse En instans af en klasse oprettes og instantieres. Objektet oprettes med de generelle egenskaber som er defineret i superklassen Køretøj. Igen har vi valgt at benytte instansaf, da det er et term der ofte anvendes i forbindelse med OOA og OOD. I hukommelsen reserveres plads til objektet, som nu kan bruges til at tilgå metoder og herved variabler med. Når objektet ikke bruges mere vil den reserverede plads i hukommelsen blive frigivet igen. Hertil anvendes Javas indbyggede Garbage Collector. min tildeles instansaf MinKlasse; 10

12 En metode kan modtage parametre og returnere et resultat af en bestemt type. I nedenstående eksempel erklæres metoden hentantalhjul. Den kan modtage variabler af typen heltal, og returnerer heltal. Ved at anvende de reserverede ord modtager og returnerer er metodens definition nemmere at læse for en nybegynder. Kaldes en metode med en forkert type som parameter, vil dette blive fanget i et type tjek i kompilerings øjeblikket. metode hentantalhjul modtager heltal type returnerer heltal... returner antalhjul; slutmetode Det er muligt at lave en start-slut metode, som den sidste metode i klassen. Denne metode modsvarer public static void main(..) i Java, og er metoden som først bliver udført når et LetOO program startes. start... bil instansaf Bil; skriv Bilens tophastighed : + henttophastighed fra bil;... slut Når der oprettes en instans af en klasse bliver klassen konstruktør automatisk kaldt. Her er det bl.a. muligt at initialisere nogle variabler. Nedarves fra en superklasse, skal man angive i starten af subklassen hvilken konstruktør der skal kaldes i superklassen. Er der ikke angivet noget, kaldes konstruktøren uden argumenter i superklassen, før subklassens implementation udføres. konstruktør skriv "Konstruktør i klassen X"; slutkonstruktør En klasse består af flere scopes. Der er et overordnet scope for hele klassen, og et scope for hver metode der oprettes i klassen. Erklæres en variabel i starten af klassen, kan denne variabel tilgås og modificeres i klassens metoder. Erklæres en variabel i en metode, kan den ikke tilgås fra andre metoder i klassen. I LetOO understøtter vi polyformi ved anvendelse af method overriding, method overloading og dynamic method dispath. Vi har valgt ikke at oversætte disse begreber for at undgå forvirring. Method overriding forekommer når en subklasses metode overskriver en metode i superklassen. Dette kræver at metoderne har samme signatur. Method overloading forekommer ved at flere metoder har samme navn men har forskellige parametre i antal og/eller type. Endelig forekommer dynamic method dispath ved at det dynamisk afgøres på kørselstidspunktet hvilken metode der skal udføres afhængig af instansens klassetype. Disse polyformiske begreber bliver anvendt senere i et eksempel på side Standard metoder Vi har valgt at indbygge 2 standard metoder i sproget. læs til modtage en indtastning fra brugeren og skriv til at udskrive en linie i konsollen. 11

13 Eksempel på brug af læs: streng resultat tildeles læs; Her indlæses en linie fra konsollen og resultatet gemmes i strengen resultat. Eksempel på brug af den anden standard metode skriv: skriv Dette er mit første program ; Ovenstående sætning udskriver blot Dette er mit første program i konsollen. 12

14 2.4 Beskrivelse i udvidet BNF Dette afsnit beskriver den formelle syntaks af LetOO i udvidet BNF. Alle mellemrum er medtaget for at øge læsbarheden. Der er forskel på store og små bogstaver. Der er foretaget følgende udvidelser af BNF for at gøre beskrivelsen mere kortfattet: <ting>* ingen eller flere <ting> <ting>+ mindst en <ting> <ting>? valgfri, dvs. ingen eller en <ting> Terminalsymboler Komplet liste over terminalsymboler i LetOO: heltal streng sandellerfalsk sand falsk ( ) klasse slutklasse start slut konstruktør slutkonstruktør metode slutmetode modtager returnerer fra i returner kald instansaf tildeles hvis ellers sluthvis og eller sålænge slutsålænge = <> + - * / > < <= >= ; Unicode Unicode refererer til alle tegn der indgår i Unicode tegnsættet. Symbolerne fra heltal til og med slutsålænge er reserverede ord. Desuden er læs og skriv også reserverede ord, da det er nogle indbyggede standard metoder. Et program kan indeholde mellemrum og linieskift de må dog ikke anvendes midt i et terminalsymbol eller en identifikator, men skal bruges til at adskille reserverede ord og identikatorer, som beskrives i det efterfølgende. Alle tegn efter semikolon indtil linieskift betragtes som kommentarer. En identifikator (id) må ikke være lig et reserveret ord, se terminalsymboler samt reserverede ord i Java. Dette problem kunne dog løses ved at sætte fx. user foran alle identifikationer ved oversættelse, så else bliver til userelse osv. For at en identifikator kan anvendes skal den først være erklæret og den må ikke erklæres flere gange i samme scope. Vi anvender samme scope-regler som Java, dvs. vi har klasse-, metode og blok scrope. En blok kan være en sålænge-sætning. En identifikator må ikke tildeles ulovlige værdier, fx. dette er en test til en identifikator af typen heltal. <id> <bogstav> <bogstav> (<bogstav> <ciffer>)* a b c... æ ø å A B C... Æ Ø Å <ciffer> <klasse definition> <klasse navn> <nedarvning> <klasse krop> klasse <klasse navn> <nedarvning>? <klasse krop> slutklasse <id> nedarverfra <klasse navn> (<klasse medlem definition> <konstruktør definition>)* <start-slut definition>? <klasse medlem definition> <felt definition> <metode definition> 13

15 <felt definition> <type> <konstruktør definition> <konstruktør krop> <type> <tildeling> heltal streng sandellerfalsk konstruktør (modtager (<type> <id>)*)? (,<type> <id>)*) <konstruktør krop> slutkonstruktør <konstruktør medlem definition>* <konstruktør medlem definition> <felt definition> <sætning> <start-slut definition> <metode definition> <metode krop> start <metode krop> slut metode <metode navn> (modtager (<type> <id>)*)? (,<type> <id>)*) (returnerer <type>)? <metode krop> slutmetode <metode medlem definition>* <metode medlem definition> <felt definition> <sætning> <sætning> <enkel sætning> <returner sætning> <udtryk sætning> <tildeling> <hvis sætning> <hvis-ellers sætning> <sålænge sætning> <enkel sætning> <returner sætning> <udtryk sætning> returner <udtryk> <udtryk> skal være af samme type som retur typen i <metode definition> <tildeling> <metode kald> <objekt> <id> tildeles <udtryk> <id> og <udtryk> skal være af samme type. <metode kald> (kald)? (<id>)? <metode navn> (<id> <konstant> (,<id> <konstant>)*)? ((fra i ) <id>)? Argumenterne angivet i metode kaldet skal være af samme type som metodens parametre. Det første og sidste <id> skal være af typen <objekt>. Det første <id>kan ikke anvendes samtidig med at fra i <id> anvendes. <objekt> <hvis sætning> <hvis-ellers sætning> <sålænge sætning> <konstant> <heltal konstant> <streng konstant> <sandellerfalsk konstant> <heltal> <id> instansaf <klasse navn> hvis <udtryk> <sætning>* sluthvis <udtryk> skal være af typen sandellerfalsk. hvis <udtryk> <sætning>* ellers <sætning>* sluthvis <udtryk> skal være af typen sandellerfalsk. sålænge <udtryk> <sætning>* ellers <sætning>* slutsålænge <udtryk> skal være af typen sandellerfalsk. <heltal konstant> <streng konstant> <sandellerfalsk konstant> <heltal> <streng> sand falsk <fortegn>? <ciffer>+ 14

16 <fortegn> + - <streng> <unicode>* <kommentarer> ; Alle efterfølgende tegn indtil linieskift er kommentarer. <udtryk> <streng sammensætning> <eller-udtryk> <og-udtryk> <relations-udtryk> <eller-udtryk> <og-udtryk> <relations-udtryk> <regne-udtryk> <fortegns-udtryk> <parentes-udtryk> <id> <konstant> <metode kald> <streng sammensætning> (<id> <streng konstant>) + (<id> <streng konstant>) Hvis <id> er af typen heltal eller sandellerfalsk udføres der automatisk en konvertering til typen streng. Fx. heltal=5 konverteres til 5 og sandellerfalsk=sand konverteres til sand. Enten venstre eller højre side i sammensætningen skal være et id af typen streng eller en streng konstant for at det betragtes som en streng sammensætning. <udtryk> eller <udtryk> <udtryk> skal være af typen sandellerfalsk. <udtryk> og <udtryk> <udtryk> skal være af typen sandellerfalsk. <udtryk> <relationsoperator> <udtryk> <udtryk> skal være af typen heltal eller streng. <relationsoperator> > < = <> >= <= <regne-udtryk> (<id> <heltal konstant>) <regne operator> (<id> <heltal konstant>) <id> skal være af typen heltal. <regne operator> <plusminus operator> * / <plusminus operator> + - <fortegns-udtryk> <parentes-udtryk> <plusminus operator> <udtryk> <udtryk> skal være af typen heltal. (<udtryk>) 2.5 Standard metoder Vi har kun medtaget to standard metoder i LetOO, de er ikke med i ovenstående BNF da kald af dem opfattes som et <metode kald>. <læs> <skriv> læs skriv <udtryk> 15

17 2.6 Et simpelt program skrevet i LetOO Vi vil her vise et simpelt program skrevet i LetOO, hvor der bl.a. indgår nedarvning og polyformi. I nedenstående figur er eksemplet beskrevet i et klassediagram vha. UML notation. Nedarvning er vist ved at klassen Bil og Motorcykel nedarver attributter og metoder fra klassen Køretøj. Polyformi er vist i form af method overriding, method overloading og giver mulighed for dynamic method dispatch. Vi har ikke oversat disse 3 begreber til dansk for at undgå forvirring. Køretøj - antalhjul : heltal - tophastighed : heltal + hentantalhjul() : heltal + henttophastighed() : heltal + hentlevealder() : heltal Motorcykel - nummerplade : streng - kåbe : sandellerfalsk + henttype() : streng + hentlevealder() : heltal + hentnummerplade() : streng + sætnummerplade(nummerplade : streng) Bil - soltag : sandellerfalsk - nummerplade : streng - airbag : sandellerfalsk + henttype() : streng + hentnummerplade() : streng + sætnummerplade(nummerplade : streng) + harairbag() : sandellerfalsk + sætairbag(airbag : sandellerfalsk) + harsoltag() : sandellerfalsk + sætsoltag(soltag : sandellerfalsk) + beregnkøretid(km : heltal, Hastighed : heltal) : heltal + beregnkøretid(km : heltal) : heltal + hentlevealder() : heltal 16

18 Der er indsat linienumre for at for at gøre det lettere at beskrive kodelinierne efterfølgende. Eksemplet består af 4 klasser; Køretøj, Bil, Motorcykel og MinTest. Klassen MinTest er hovedprogrammet og anvender de 3 andre klasser. 1 klasse Køretøj 2 heltal tophastighed tildeles 0; 3 heltal antalhjul tildeles 0; 4 5 konstruktør 6 skriv "Konstruktør i Køretøj"; 7 slutkonstruktør 8 9 metode hentantalhjul returnerer heltal 10 returner antalhjul; 11 slutmetode metode henttophastighed returnerer heltal 14 returner tophastighed; 15 slutmetode metode hentlevealder returnerer heltal 18 returner 10; 19 slutmetode slutklasse Klasse Køretøj 17

19 1 klasse Motorcykel nedarverfra Køretøj 2 streng nummerplade tildeles ; 3 sandellerfalsk kåbe tildeles falsk; 4 5 konstruktør 6 skriv "Konstruktør i Motorcykel"; 7 antalhjul = 2; 8 tophastighed = 250; 9 slutkonstruktør metode henttype returnerer streng 12 returner Motorcykel ; 13 slutmetode metode hentlevealder returnerer heltal 16 returner 9; 17 slutmetode metode hentnummerplade returnerer streng 20 returner nummerplade; 21 slutmetode metode sætnummerplade modtager streng nynummerplade 24 nummerplade tildeles nynummerplade; 25 slutmetode slutklasse Klasse Motorcykel 18

20 1 klasse Bil nedarverfra Køretøj 2 streng nummerplade tildeles ; 3 sandellerfalsk airbag tildeles falsk; 4 sandellerfalsk soltag tildeles falsk; 5 6 konstruktør 7 skriv "Konstruktør i Bil"; 8 antalhjul = 4; 9 tophastighed = 200; 10 slutkonstruktør metode henttype returnerer streng 13 returner Bil ; 14 slutmetode metode hentnummerplade returnerer streng 17 returner nummerplade; 18 slutmetode metode sætnummerplade modtager streng nynummerplade 21 nummerplade tildeles nynummerplade; 22 slutmetode metode harairbag returnerer sandellerfalsk 25 returner airbag; 26 slutmetode metode sætairbag modtager sandellerfalsk nyairbag 29 airbag tildeles nyairbag; 30 slutmetode metode harsoltag returnerer sandellerfalsk 33 returner soltag; 34 slutmetode metode sætsoltag modtager sandellerfalsk nysoltag 37 soltag tildeles nysoltag; 38 slutmetode metode beregnkøretid modtager heltal km, heltal hastighed returnerer heltal 41 returner km / hastighed; 42 slutmetode metode beregnkøretid modtager heltal km returnerer heltal 45 returner beregnkøretid km, 80; 46 slutmetode metode hentlevealder returnerer heltal 49 returner 16; 50 slutmetode slutklasse Klasse Bil 19

21 1 klasse MinTest 2 3 metode testmetode 4 skriv "Denne metode returnerer og modtager intet."; 5 slutmetode 6 7 start 8 9 skriv "Dette er mit første program, start."; ; Opret instanser af Køretøj, Bil og Motorcykel 12 køretøj instansaf Køretøj; 13 bil instansaf Bil; 14 motorcykel instansaf Motorcykel; ; Udskriv og sæt nogle attributter 17 skriv "Indtast bilens nummerplade: "; 18 streng nummerplade tildeles læs; 19 sætnummerplade i bil nummerplade; 20 sætairbag i bil sand; skriv "Indtast motorcyklens nummerplade: "; 23 nummerplade tildeles læs; 24 sætnummerplade i motorcykel nummerplade; ; Anvendelse af method overloading 27 skriv "Køretid for 100 km ved 80 km/t i gennemsnithastighed: " + 28 beregnkøretid 100 i bil; skriv "Køretid for 100 km ved 100 km/t i gennemsnithastighed: " + 31 beregnkøretid 100, 100 i bil; ; Anvendelse af dynamic method dispath 34 køretøj tildeles bil; 35 skriv "Køretøjs type: + henttype fra køretøj; køretøj tildeles motorcykel; 38 skriv "Køretøjs type: + henttype fra køretøj; ; Anvendelse af method overriding 41 skriv "Bils levealder: + hentlevealder fra bil; ; Anvendelse af hvis-sætning 44 hvis bil harsoltag 45 skriv Bilen har soltag ; 46 ellers 47 skriv Bilen ikke soltag ; 48 sluthvis ; Anvendelse af sålænge-sætning 51 heltal tal tildeles 0; 52 sålænge tal < skriv tal har værdien: + tal; 54 tal tildeles tal + 1; 55 slutsålænge ; Anvendelse af metodekald uden argumenter 20

22 58 kald testmetode; skriv "Dette er mit første program, slut."; slut slutklasse Klasse MinTest Klassen Køretøj er superklasse i vores eksempel. Superklassen indeholder de generelle egenskaber for et køretøj, og klasserne Bil og Motorcykel nedarver fra Køretøj. 21

23 3 Leksikalsk analyse Det første trin i en kompiler er den leksikalske analyse som grupperer de enkelte tegn i tokens. Ved implementering af den leksikalske analyse af et sprog, skal man blot lave en specifikation der beskriver hvilke tokens sproget indeholder. Specifikationen er ofte i regulære udtryk. Vi har anvendt værktøjet JFLex til at generere vores scanner til den leksikalske analyse. JFLex danner en scanner i Java ud fra en specifikation. Nedenstående er vores specifikation. Den genererede scanner er tilgængelig på vores website /* JFlex specifikation */ package sejberg.datalogi.parser; import java_cup.runtime.*; %% %class Lexer %unicode %cup %line %column %{ StringBuffer string = new StringBuffer(); private Symbol symbol(int type) { return new Symbol(type, yyline, yycolumn); private Symbol symbol(int type, Object value) { return new Symbol(type, yyline, yycolumn, value); % LineTerminator = \r \n \r\n InputCharacter = [^\r\n] WhiteSpace = {LineTerminator [ \t\f] /* kommentarer */ Comment = {EndOfLineComment EndOfLineComment = ";" {InputCharacter* {LineTerminator Identifier = [:jletter:] [:jletterdigit:]* DecIntegerLiteral = 0 [1-9][0-9]* StringCharacter = [^\r\n\"\\] %state STRING %% /* keywords */ 22

24 <YYINITIAL> "heltal" { return symbol(sym.heltal); <YYINITIAL> "streng" { return symbol(sym.streng); <YYINITIAL> "sandellerfalsk" { return symbol(sym.sand_eller_falsk); <YYINITIAL> "læs" { return symbol(sym.laes); <YYINITIAL> "skriv" { return symbol(sym.skriv); <YYINITIAL> "hvis" { return symbol(sym.hvis); <YYINITIAL> "ellers" { return symbol(sym.ellers); <YYINITIAL> "sluthvis" { return symbol(sym.slut_hvis); <YYINITIAL> "sålænge" { return symbol(sym.saalaenge); <YYINITIAL> "slutsålænge" { return symbol(sym.slut_saalaenge); <YYINITIAL> "sand" { return symbol(sym.sand); <YYINITIAL> "falsk" { return symbol(sym.falsk); <YYINITIAL> "og" { return symbol(sym.og); <YYINITIAL> "eller" { return symbol(sym.eller); <YYINITIAL> "+" { return symbol(sym.addition); <YYINITIAL> "-" { return symbol(sym.subtraktion); <YYINITIAL> "/" { return symbol(sym.division); <YYINITIAL> "*" { return symbol(sym.multiplikation); <YYINITIAL> "(" { return symbol(sym.venstre_parentes); <YYINITIAL> ")" { return symbol(sym.hoejre_parentes); <YYINITIAL> "tildeles" { return symbol(sym.tildeles); <YYINITIAL> "=" { return symbol(sym.lig_med); <YYINITIAL> "<>" { return symbol(sym.forskellig_fra); <YYINITIAL> "<" { return symbol(sym.mindre_end); <YYINITIAL> ">" { return symbol(sym.stoerre_end); <YYINITIAL> "<=" { return symbol(sym.mindre_end_eller_lig_med); <YYINITIAL> ">=" { return symbol(sym.stoerre_end_eller_lig_med); <YYINITIAL> "klasse" { return symbol(sym.klasse); <YYINITIAL> "slutklasse" { return symbol(sym.slut_klasse); <YYINITIAL> "instansaf" { return symbol(sym.instans_af); <YYINITIAL> "konstruktør" { return symbol(sym.konstruktoer); <YYINITIAL> "slutkonstruktør" { return symbol(sym.slut_konstruktoer); <YYINITIAL> "metode" { return symbol(sym.metode); <YYINITIAL> "slutmetode" { return symbol(sym.slut_metode); <YYINITIAL> "returner" { return symbol(sym.returner); <YYINITIAL> "returnerer" { return symbol(sym.returnerer); <YYINITIAL> "modtager" { return symbol(sym.modtager); <YYINITIAL> "start" { return symbol(sym.start); <YYINITIAL> "slut" { return symbol(sym.slut); <YYINITIAL> "kald" { return symbol(sym.kald); 23

25 <YYINITIAL> "fra" { return symbol(sym.fra); <YYINITIAL> "i" { return symbol(sym.i); <YYINITIAL> ";" { string.setlength(0);return symbol(sym.semikolon); <YYINITIAL> { /* identifiers */ {Identifier { return symbol(sym.identifier, yytext()); /* literals */ {DecIntegerLiteral { string.append( yytext() ); return symbol(sym.integer_literal, yytext()); \" { string.setlength(0); yybegin(string); /* comments */ {Comment { /* ignorer */ /* whitespace */ {WhiteSpace { /* ignorer */ <STRING> { \" { yybegin(yyinitial);return symbol(sym.string_literal, string.tostring()); {StringCharacter+ { string.append( yytext() ); /* escape sequences */ "\\b" { string.append( '\b' ); "\\t" { string.append( '\t' ); "\\n" { string.append( '\n' ); "\\f" { string.append( '\f' ); "\\r" { string.append( '\r' ); "\\\"" { string.append( '\"' ); "\\'" { string.append( '\'' ); "\\\\" { string.append( '\\' ); /* error cases */ \\. { throw new RuntimeException("Ulovlig escape sekvens \"" + yytext()+"\""); {LineTerminator { throw new RuntimeException("Uafsluttet streng"); /* error fallback */. \n { throw new Error("Ulovlig karakter <" + yytext() + ">"); 24

26 4 Syntaktisk analyse Til den syntaktiske analyse anvendes et program der kaldes en parser. Der findes flere værktøjer der kan generere parsere ud fra en specifikation, der primært beskriver sproget grammatik. Vi har genereret vores parser vha. LALR Parser generatoren CUP (Constructor of Useful Parsers), der genererer en parser i Java. LALR (lookahead LR) er en mellemting imellem SLR (simple LR) og canonical LR mht. styrke og omkostninger. LALR kan anvendes til de fleste programmeringssprogs grammatiker, og det er den der anvendes af CUP. Vi nåede ikke at få lavet vores parser færdig. Meningen er at den skal validere et program skrevet i LetOO og samtidig generere Java kildekode der så kan kompileres med Java's kompiler; Javac. Her er den specifikation vi fik lavet. package sejberg.datalogi.parser; /* Import the class java_cup.runtime.* */ import java_cup.runtime.*; import sejberg.datalogi.parser.*; /* Parser code to change the way the parser reports errors (include line and column number of the error). */ parser code {: public Program program = new Program(); /* Change the method report_error so it will display the line and column of where the error occurred in the input as well as the reason for the error which is passed into the method in the String 'message'. */ public void report_error(string message, Object info) { /* Create a StringBuffer called 'm' with the string 'Error' in it. */ StringBuffer m = new StringBuffer("Error"); /* Check if the information passed to the method is the same type as the type java_cup.runtime.symbol. */ if (info instanceof java_cup.runtime.symbol) { /* Declare a java_cup.runtime.symbol object 's' with the information in the object info that is being typecasted as a java_cup.runtime.symbol object. */ java_cup.runtime.symbol s = ((java_cup.runtime.symbol) info); /* Check if the line number in the input is greater or equal to zero. */ if (s.left >= 0) { /* Add to the end of the StringBuffer error message the line number of the error in the input. */ m.append(" in line "+(s.left+1)); /* Check if the column number in the input is greater or equal to zero. */ if (s.right >= 0) /* Add to the end of the StringBuffer error message 25

27 the column number of the error in the input. */ m.append(", column "+(s.right+1)); /* Add to the end of the StringBuffer error message created in this method the message that was passed into this method. */ m.append(" : "+message); /* Print the contents of the StringBuffer 'm', which contains an error message, out on a line. */ System.err.println(m); :; /* Change the method report_fatal_error so when it reports a fatal error it will display the line and column number of where the fatal error occurred in the input as well as the reason for the fatal error which is passed into the method in the object 'message' and then exit.*/ public void report_fatal_error(string message, Object info) { report_error(message, info); System.exit(1); /* Declaration of Terminals and Non Terminals Section */ /* Terminals (tokens returned by the scanner). */ terminal STRENG, HELTAL, SAND_ELLER_FALSK; terminal LAES, SKRIV; terminal HVIS, ELLERS, SLUT_HVIS; terminal SAALAENGE, SLUT_SAALAENGE; terminal SAND, FALSK; terminal OG, ELLER; terminal ADDITION, SUBTRAKTION, DIVISION, MULTIPLIKATION; terminal VENSTRE_PARENTES, HOEJRE_PARENTES; terminal TILDELES, LIG_MED, FORSKELLIG_FRA; terminal MINDRE_END, STOERRE_END; terminal MINDRE_END_ELLER_LIG_MED, STOERRE_END_ELLER_LIG_MED; terminal KLASSE, SLUT_KLASSE; terminal KONSTRUKTOER, SLUT_KONSTRUKTOER; terminal METODE, SLUT_METODE; terminal INSTANS_AF; terminal RETURNERER, MODTAGER; terminal RETURNER; terminal START, SLUT; terminal KALD; terminal FRA, I; terminal SEMIKOLON; terminal java.lang.string STRING_LITERAL; terminal java.lang.string IDENTIFIER; terminal java.lang.string INTEGER_LITERAL; 26

28 /* Non terminals used in the grammar section. Non terminals that have an object value are listed first and then non terminals that have an integer value are listed. An object value means that it can be any type, it isn't set to a specific type. So it could be an Integer or a String or whatever. */ non terminal Object expr_list; non terminal java.lang.string string_expr, id; non terminal standard_funktioner, standard_import; non terminal prog, stm, stmlist, stm_skriv, stm_klasse, stm_laes; non terminal udtryk, regne_udtryk, regne_operator, plusminus_operator,regne_udtryk_input; non terminal felt_definition, type, tildeling, streng_sammensaetning,streng_sammensaetning_input; start with prog; prog ::= standard_import stm_klasse; standard_import ::= {: parser.program.addstatement( "import java.util.*;\n" + "import java.io.*;\n"); :; standard_funktioner ::= {: parser.program.addstatement( "\n\npublic static String getliniefrabruger() {\n" + " String result = \"\";\n" + " BufferedReader inddata = new BufferedReader(new InputStreamReader(System.in));\n" + " try {\n" + " result = inddata.readline();\n" + " catch (Exception e) {\n" + " result = \"Fejl ved læsning af linie fra brugeren.\";\n" + " \n" + " return result;\n" + "\n"); :; stm_skriv ::= SKRIV {: parser.program.addstatement("\t\tsystem.out.println(\""); : udtryk {: parser.program.addstatement("\")"); :; stm_laes ::= LAES {: parser.program.addstatement("getliniefrabruger()"); :; stm_klasse ::= KLASSE {: parser.program.addstatement("class "); : IDENTIFIER:s {: parser.program.addstatement(s + "{"); : standard_funktioner START {: parser.program.addstatement("\n\tpublic static void main(string[] args) {\n "); : stmlist SLUT {: parser.program.addstatement("\t\n"); : 27

29 SLUT_KLASSE {: parser.program.addstatement(""); :; stm ::= stm_skriv stm_laes felt_definition udtryk tildeling; stmlist ::= stm {: parser.program.addstatement(";\n"); : stmlist stm {: parser.program.addstatement(";\n"); :; felt_definition ::= type tildeling; type ::= HELTAL {: parser.program.addstatement("int "); : STRENG {: parser.program.addstatement("string "); : SAND_ELLER_FALSK {: parser.program.addstatement("boolean "); :; tildeling ::= IDENTIFIER:s {: parser.program.addstatement(s); : TILDELES {: parser.program.addstatement("="); : udtryk; udtryk ::= IDENTIFIER:s {: parser.program.addstatement(s); : INTEGER_LITERAL:s {: parser.program.addstatement(s); : STRING_LITERAL:s {: parser.program.addstatement(s); : regne_udtryk streng_sammensaetning; regne_udtryk ::= regne_udtryk_input regne_operator regne_udtryk_input; regne_udtryk_input ::= INTEGER_LITERAL:s {: parser.program.addstatement(s); : IDENTIFIER:s {: parser.program.addstatement(s); :; streng_sammensaetning ::= streng_sammensaetning_input ADDITION streng_sammensaetning_input; 28

30 streng_sammensaetning_input ::= STRING_LITERAL:s {: parser.program.addstatement(s); :; regne_operator ::= plusminus_operator MULTIPLIKATION {: parser.program.addstatement("*"); : DIVISION {: parser.program.addstatement("/"); :; plusminus_operator ::= ADDITION {: parser.program.addstatement("+"); : SUBTRAKTION {: parser.program.addstatement("-"); : ; Vi anvender klassen Program til at gemme den genererede Java kildekode. package sejberg.datalogi.parser; public class Program { private StringBuffer statements; public Program() { statements = new StringBuffer(); public void addstatement(string newstatement) { statements.append(newstatement); public StringBuffer getstatements() { return statements; public void resetstatements() { statements = new StringBuffer(); Endelig har vi har lavet et lille Java program der anvender parser og gemmer den genererede Java kildekode i en fil. package sejberg.datalogi.parser; import java.io.filereader; import java.io.filewriter; import java.text.simpledateformat; import java.util.date; class Main { static private SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd 'kl.' HH:mm:ss.SSS "); static private String getprefix() { 29

31 return format.format(new Date()); static private void consolewrite(string in) { System.out.println(getPrefix() + in); static private void showhelp() { consolewrite("syntaks: datalogi.sejberg.parser.main <filnavn>.letoo"); static public void main(string argv[]) { consolewrite("letoo version 0.3"); if (argv.length!= 1) { showhelp(); return; String filename = argv[0]; if (!filename.endswith(".letoo")) { showhelp(); return; consolewrite("parser..."); try { parser p = new parser(new Lexer(new FileReader(filename))); Object result = p.parse().value; String outfilename = filename.substring(0,filename.lastindexof(".")) + ".java"; FileWriter filewriter = new FileWriter(outFilename); filewriter.write(p.program.getstatements().tostring()); filewriter.close(); consolewrite(filename + " oversat og gemt i " + outfilename); catch (Exception e) { consolewrite("fejl: "); e.printstacktrace(); 30

32 5 Konklusion Vi har udviklet et sprog, som kan anvendes til at introducere en nybegynder til objekt orienteret programmering. Sproget er blevet meget simpelt, men kan efter vores mening godt anvendes til introduktion, da sproget gør det muligt at implementere de generelle objekt orienterede begreber. Da sproget er simpelt har det selvfølgelig nogle begrænsninger som gør at det ikke er anvendeligt til andet end undervisning, men det har heller ikke været vores målsætning. Overgangen fra design til programmering er nemmere da programmøren ikke skal overveje de mange muligheder som fx. Java indeholder. Vi valgte at simplificere LetOO ved at gøre alle metoder public og alle attributter private. Efter en introduktion med dette sprog vil det være nemmere at starte på Java eller C++. Vi valgte at anvende danske termer i sproget, for at gøre det nemmere at anvende sproget. Da vores målgruppe er studerende på korte videregående uddannelser må det forventes at de forstår engelsk, så vi kunne have valgt at anvende engelske termer i stedet for danske. Da LetOO er et introduktionssprog før anvendelse af fx. Java eller C++, som begge er på engelsk, synes vi efterfølgende at valget af danske termer var en fejl. Udover et simplet sprog er det efter vores mening vigtigt med et udviklingsmiljø, med bl.a. en debugger, der er enkelt og hurtigt kan anvendes af nybegyndere i programmering. Det kunne være et værktøj hvor det er muligt at beskrive et program vha. et klassediagram i UML notation, og derefter automatisk kan få genereret et LetOO program ud fra diagrammet. Udviklingsmiljøet kunne også indeholde en mulighed for at generere et klassediagram i UML notation ud fra LetOO kildekode. For at udvikle et godt produkt er det bl.a. vigtigt at inddrage målgruppen, også når det gælder programmeringssprog. Derfor vil det være naturligt at inddrage nogle fra LetOO s målgruppe for at få deres perspektiver og forudsætninger med som en hjælp i udviklingen af sproget. Inddragelsen kunne være i form af brugerinterviews i starten af projektforløbet og løbende brugertests. Dokumentation af kode er en vigtig detalje ved programmering, og derfor kunne LetOO udbygges med et dokumenteringskrav overfor brugeren. I forbindelse med navngivning af klasser vil det også være en god ide at kræve at klassers navne starter med et stort bogstav og at metoders og attributters navne starter med et lille bogstav. Det vil efter vores mening øge læsevenligheden. 31

33 6 Litteraturliste Titel Udgave Forfattere Modern Compiler Implementation in Java 1998 Andrew W. Appel Compilers. Principles, Techniques, and Tools 1988 Alfred V. Aho, Ravi Sethi, Jeffrey D. Ullman Objektorienteret analyse og design 1998 Lars Mathiassen, Andreas Munk-Madsen, Peter Axel Nielsen og Jan Stage UML in a Nutshell 1998 Sinan Si Alhir Link Beskrivelse JFlex, scanner generator JLex, scanner generator CUP, paser generator Java Unicode Eclipse, open source IDE. 32

34 7 Bilag 7.1 Projektetablering Vi vil under projektetableringen finde frem til hvilke ressourcer der er til rådighed, hvilke interessenter der er, og danne rammerne for projektet. Etableringen er foretaget efter en model udarbejdet af Andersen, N. E. et al. (1986). Projektgruppen har 2 semestre til at udarbejde rapporten, der skal afleveres d. 20 december Der vil der blive afholdt eksamen med udgangspunkt i projektet i januar Gruppesammensætning Gruppen består af nedenstående 2 personer: Navn Brian Sejberg Tlf. privat Tlf. arbejde bs@post9.tele.dk Uddannelse Datamatiker uddannet i dec Erhvervserfaring 2 års erfaring med udvikling af intra- og internetapplikationer. I øjeblikket ansat som Java-udvikler hos Unibank/Nordea. Navn Christian Sejberg Tlf. privat Tlf. arbejde christian@sejberg.com Uddannelse Uddannet edb-assistent (2 ½ årig) i feb datamatikerfag. Datanom i januar 2001 med speciale i anvendelse af Java Server Pages og Java Servlets. Erhvervserfaring 8 års erfaring med udvikling af primært bank-, intra- og internetapplikationer Møder Når gruppen er samlet på IT højskolen i København til seminar, anvender gruppen skolen som mødested. Derudover mødes vi også jævnligt efter arbejdstid, da vi arbejder i samme bygning. 33

35 7.1.3 Brugerindflydelse Da vi ikke udvikler til en specifik brugerorganisation, er der ikke nogen brugergruppe der har indflydelse på projektet. Herved er der ikke nogle interesse konflikter i brugerorganisationen der skal tages højde for. Ekspertgruppen består af vores vejleder, som projektgruppen kan rådføre sig med under projektet Arbejdsform Vi vil løbende vælge den arbejdsform der passer bedst til den enkelte aktivitet. Til projektmøderne har hver enkelt forberedt sig ved at have gennemlæst de nyeste dokumenter i projektet og hvad der ellers er aftalt. Vi har oprettet web-stedet som vil indeholde projektets dokumenter, og andre relevante oplysninger for projektet. Backup proceduren foregår ved at det enkelte gruppemedlem gemmer en backup af den nyeste version af rapporten. Dokument standarden er skrifttypen Times New Roman størrelse 12 eller størrelse 10, hvis der ikke er så meget plads i en tabel eller lign. Kildekode vises med skrifttypen Courier New størrelse 10. Opstillingen af rapporten fastlægges løbende. 34