Structured Programming & Modula-2

Project

Bekijk zeker de bekroonde projecten van de vorige jaren !!!


Topics naar keuze, maar liefst niet iets wat al gemaakt is:

Tijdsschema (2011)

De evaluatie van jullie project zal gebeuren in drie stappen:
  1. Evaluatie/bespreking van jullie voorontwerp:
    Alvorens de lessen Modula in het twee semester aanvangen (14 maart 2011) hebben jullie jezelf in groepjes van 2-3 studenten verdeeld. Elke groep stuurt ons (wesley.mattheyses@vub.ac.be) een voorontwerp van hun project in. Hierop zal feedback worden gegeven inzake de haalbaarheid etc., zodat je zelfs al voor de eerste les in het tweede semester aan je project kan beginnen werken.
  2. Tussentijdse evaluatie van de code:
    Jullie maken met ons een afspraak begin/midden april. Tijdens deze afspraak zullen we de code die je al hebt evalueren en, indien nodig, tips geven over hoe je de (structuur van de) code kan verbeteren. Dit is puur informatief en hier staan dus ook geen punten op. Wij zijn redelijk druk bezet dus maak op tijd een afspraak - niet de dag ervoor maar minimum 1 week op voorhand. Stuur ook jullie voorlopige code minstens 3 dagen voor de afspraak door, anders hebben we niet voldoende tijd alles al eens te bekijken.
  3. Eindevaluatie:
    Op het einde van het semester maken jullie met ons een afspraak voor de evaluatie van het project. Je stuurt ons de finale versie door (deadline 17/05/2011 10u00) en je maakt met ons een afspraak in de week die volgt. Omwille van praktische redenen zullen we aan de klasverantwoordelijke vragen een schema op te stellen waarbij alle projecten achtereenvolgens op dezelfde dag komen.
    Tijdens de evaluatie mogen jullie eerst een demo geven van het spel, waarna we met jullie de code van jullie spel zullen bespreken. We zullen ons richten op de 7 aandachtspunten onder "Opdracht", met een sterke nadruk op de richtlijnen "gestructureerd programmeren". We zullen ook de onderlinge samenwerking binnen een groep nagaan. We vinden het belangrijk dat iedereen een bijdrage levert aan het spel op zich, ipv enkel aan de graphics, het introductiefilmpje of iets dergelijk.

Practicum Organisatie

Het projekt moet af zijn voor de eerste zittijd van het tweede semester.
Per 2 of 3 kies je een eigen topic of kom je er eentje halen. Laat je topic bevestigen door je assistent, vraag ook toestemming als je alleen of met meer wilt werken, dit wordt slechts uitzonderlijk toegestaan en moet goed gemotiveerd worden!
Denk eerst goed na over wat je wil doen en hoe je het gaat aanpakken. Zorg ook voor een tijdschema, wat wanneer moet af zijn en maak tevens een duidelijke takenverdeling. Noteer tijdens het coderen wanneer een bepaalde taak gehaald werd, Dit zal je helpen bij latere projecten. Beschrijf ook welke algoritmes en welke datastructuren je wenst te gebruiken (denk na over de algemene structuur van je programma). Schrijf dit neer in een voorontwerp en stuur dit door naar de assistent vooraleer je begint te coderen. Je voorontwerp dient hetvolgende te bevatten:
In de code zet je steeds boven een procedure wie ze geprogrammeerd heeft (zo weten we aan wie vragen te stellen!) en wat wat ze doet of waarvoor ze dient.
Vergeet dit niet: ik trek punten af als je niet langskomt met je voorontwerp en aangeeft wie wat gedaan heeft!!
Je zet je project op je websites:
    1. printscreen
    2. jullie namen, met links naar de persoonlijke websites
    3. executable en code (zip-file)
    4. korte tekst waarin je je spel aantrekkelijk voorstelt
  • Gebruik de Modula-2 Documentatie

    • Opdracht

    Het projekt wordt geëvalueerd op volgende punten:

    1. Dat het werkt volgens de opdracht, zonder fouten en zonder crashes.
    2. De complexiteit en de grootte: die geven we aan tijdens de bespreking.
    3. Gestructureerd programmeren, lees volgende paragraaf
      • ! GEEN REDUNDANTIE is ZEER belangrijk. Herhaal nooit twee keer hetzelfde => gebruik procedures, constanten, ... !!
    4. Uitbreidbaarheid (flexibiliteit) van het programma: dat je gemakkelijk je scherm groter kan maken, levels kan toevoegen aan je spel, mannekes of vijandjes toevoegen, cheat codes invoeren enzoverder.
      • Dit wordt mogelijk indien je programma mooi gestructureerd is en er geen redundantie in zit. Uitbreidbaarheid krijg je er dan gratis bij!
    5. Gebruiksvriendelijkheid, dwz een gebruiker moet er onmiddellijk mee weg kunnen zijn, op een eenduidige, simpele manier
      • gebruik zo veel mogelijk de standaard toetsen:
        • pijltjestoetsen (zie StandardLib),
        • stoppen met 'q'  (van quit) of de Escape toets
        • gebruik de spatiebalk of Enter voor schieten e.d.
      • voer enkel speciale toetsen in indien nodig, geef dit dan duidelijk aan in de intro en liefst ook tijdens het spel
      • schrijf tekst liefst op het graph scherm (met RawOutText, zie doc)
    6. Duidelijke, begrijpbare code:
      • structureer je code (logisch groeperen van procedures, met bvb libraries).
      • gebruik duidelijke namen voor de variabelen (vooral globale) en procedures.
      • zet commentaar in je code, documenteer vooral niet-triviale dingen.
      • gebruik min-of-meer onze of uw eigen code standaards.
    7. Originaliteit en fun-factor van het spel.
    Maak beter iets kort deftigs dan een groot, log project dat niet af is. Ook beoordelen we niet op flashy intro's of outro's, het is wel leuk, daar niet van...

    Gestructureerd programmeren

    Eenmaal je code, in Modula-2 of in een andere taal, kan schrijven die werkt, kan je daar terecht fier op zijn. Maar je gaat al snel inzien dat de ene code, de andere niet is! Je hebt waarschijnlijk wel gemerkt dat de kortste oplossingen meestal de meest elegante zijn. Maar bekijk je eigen programma's eens terug na enkele maanden, begrijp je ze dan nog? Kan je ze gemakkelijk aanpassen? Of code van anderen, die is meestal helemaal moeilijk te volgen! De enige manier om hier aan tegemoet te komen (en dan nog) is gestructureerd programmeren, iets dat je pas na veel ervaring onder de knie krijgt...
    Hier volgen de belangrijkste regels, een belangrijk doel van het projekt is dat je - na heel wat gebricoleer en gevloek - het nut van deze regels leert inzien... of in twijfel gaat trekken.

    Gestructureerd programmeren heeft tot doel dat je code:

    1. duidelijk & begrijpbaar is
    2. gemakkelijk aanpasbaar is
    3. eenvoudig uitbreidbaar is
    4. zonder fouten is
    5. kort is, zonder redundantie (= dubbele code).
    Gebruik hiervoor alle middelen die Modula-2 biedt:


    Goede Programmastructuur:

    MODULE ...;
    (*    Naam projekt & datum, Korte omschrijving Namen programmeurs, Website, ...
    *)
    <* WOFF + *> <* NOOPTIMIZE + *>   (* na het debuggen mag je deze laatste eruit halen *)
      FROM ... IMPORT ... (* import uit algemene procedures *)
      FROM ... IMPORT ... (* eventuele import uit jou eigen library *)

      CONST  (* je constantes *)
      TYPE   (* je types *)
      VAR    (* je globale variabelen *)

    (******** kleine, algemene hulpprocedures *)
    PROCEDURE PrintObject()
    VAR ... (* lokale variabelen *)
    ...

    (********* procedures niveau 2 *****)
    ...

    (********* procedures niveau 1 *****)
    PROCEDURE Speel1Beurt();
    ...

    VAR ... (* lokale variabelen van hoofdprogramma *)

    BEGIN    (* hoofdprogramma *)
      Intro();
      Initialisatie();

      REPEAT  (* hoofdlus: meerdere spelen *)

        WHILE Levend DO  (* 1 spel *)
           ...
           FOR i := 1 TO aantalSpelers DO
               Speel1Beurt();      (* elke speler doet 1 beurt *)
           END;
        END;

      UNTIL NietMeerWiltSpelen;

      Outro();

    END ...
     

    - Back to the top -