Mooie code!

 
13 augustus 2008

Ik spreek vaak over mooie code. De vraag is dan natuurlijk wat maakt code nu eigenlijk mooi. Het is toch een beetje vreemd dat je code überhaupt mooi kunt vinden. De meeste klanten waar ik mee spreek vinden het een beetje nerdie: “code die mooi is… lekker belangrijk, ik wil gewoon werkende software.” Uiteindelijk hebben ze daar natuurlijk gelijk in, het draait allemaal om het eindresultaat. Daar ligt dan ook wel de kern waarom code mooi moet zijn. Software maken we op projectbasis. Na een intensief ontwikkelproces nemen we het in gebruik. Dan gaan we er mee werken. Dat is het moment dat er iets moois gebeurt. We gebruiken de software die we dachten nodig te hebben. Maar dan blijkt in eens dat het op een andere manier toch handiger kan werken. Hadden we dat niet eerder kunnen bedenken: NEE! Je kunt vaak pas tijdens het werken met de software echt ervaren wat beter of slimmer kan.

Natuurlijk gebruiken we technieken als storyboarding om deze ervaringen al vroeg boven tafel te krijgen. De moeilijkheid blijft vaak dat de gebruikers ook nog niet precies weten wat ze willen, omdat ze niet instaat zijn te anticiperen op de toekomstige eisen en wensen.

Het eindresultaat is daarmee niet alleen de software, maar juist de mate waarin we instaat zijn om deze software aan te passen. Het gaat juist om de evolutie die software door gaat. Dan wordt het toch in eens interessant en cruciaal om mooie code te schrijven. Want code wordt mooi als het helder leesbaar is, er een duidelijke structuur is en een natuurlijke opdeling kent van verantwoordelijkheden. Pas dan is het mogelijk om snel veranderingen in de software aan te kunnen brengen. De overdraagbaarheid van code neemt toe, waardoor verschillende mensen ze kan aanpassen. Als we ons dan ook nog realiseren dat de kosten van software niet zo zeer zitten in de ontwikkeling van de software, maar dat het met name zit in de vele aanpassingen die de software in haar bestaan ondergaat. Dan is het zelfs uit legbaar naar alle afnemers van software dat mooie code veel oplevert. Dus veel plezier en succes met het schrijven van mooie code.


Werken met ?
Kijk dan bij onze mogelijkheden voor zowel starters als ervaren engineers.


Categorieën: Architectuur, Development, Deployment

Tags: ,


Reacties (8)

  • Sebastiaan schreef:

    Mooie code heeft niks met nerdigheid te maken. Leesbaarheid van code heeft veel te maken met de mate waarin de schrijver van die code zich kan uitdrukken. Iemand die zich goed kan uitdrukken wordt doorgaans niet bestempeld als nerd. Een goede structuur maakt de code herbruikbaar en overzichtelijk. Om een component herbruikbaar te maken is veel inzicht nodig in visie, missie en doelstellingen van het bedrijf; dit is ook de reden dat de service georienteerde architectuur in een korte tijd zo mateloos populair is geworden. Nerds houden zich veelal niet bezig met de bedrijfsdoelstellingen, wat overigens een groot probleem is in ICT in het algemeen (de business/IT gap). In defence of the nerds: managers houden zich ook te weinig bezig met problemen in de ICT.

    Dus: iemand die mooie code kan schrijven zou het eigenlijk ook goed moeten kunnen verkopen aan zijn baas. ;-)

    Geplaatst op 31 augustus 2008 om 13:01 Permalink

  • Ype schreef:

    Ik heb het vaak over elegante code. Nu heb ik niet ervaring met heel veel programmeertalen, maar het begrip elegante code is wel ontstaan bij het werken in Smalltalk (wat ik helaas voor mijn werk niet meer doe). Vergeleken daarmee heb ik het idee dat je in Java niet echt mooie/elegante code kan schrijven. Taalfeatures als block closures en symbols in Smalltalk helpen naar mijn mening erg bij het schrijven van elegante code. Daarbij helpt refactoring bij mij heel erg om tot elegante code te komen.
    Het maken van elegante code geeft een goed gevoel, maar meestal merk ik aan het goede gevoel, dat ik (denk ik) elegante code aan het schrijven ben.
    Dat gevoel heb ik met Java helaas niet meer zo vaak… (of ben ik nu werk een zeurpiet)

    Geplaatst op 18 augustus 2008 om 12:45 Permalink

  • Zeker interessant vraagstuk. Bij code wordt al gauw gedacht aan de resultaten van de programmeertaal waarmee we werken. Even achterwegen gelaten dat UML ook als programmeertaal beschouwd kan worden, heb ik het toch al snel over een derde generatie programmeertaal als Java/C#/Ruby. Dat kan een valkuil zijn.
    Zelf heb ik in het verleden meerdere applicaties mogen ontwikkelen in een modelleeromgeving (case-tool): Cool:gen. Daar heb ik aan de lijven mogen ondervinden dat het zeker belangrijk is wat voor code gegenereerd wordt. Natuurlijk is het zo dat je de gegenereerde code niet meer aan hoort te raken. Maar helaas liet de praktijk toen toch zien dat de gegenereerde code niet altijd optimaal was. Onder de motorkap af en toe fine-tunen was (nog) nodig. Dan wil je wel dat de code wel mooi is (wat het zeker niet altijd was ).
    Hierbij geldt wel dat je invloed kunt uitoefenen op de code die gegenereerd wordt. Op zichzelf simpele dingen als bijvoorbeeld consistentie in naamgeving is toch iets dat je zelf in hand hebt, of je nu aan het modelleren bent in een hogere taal of het rechtstreeks schrijft in een derde generatie taal. Het achterliggende metamodel en het begrip daarvan bij de ontwikkelaars/modelleurs hebben een grote invloed op de gegenereerde code. Zo zag je in Cool:gen dat het bij complexere queries moeilijker was te voorspellen hoe deze gegenereerd zouden worden. Daarmee weet je dus niet wat, in dit geval, voor SQL gegenereerd wordt. Zelf ben ik daarom wel fan geworden van de modelleeromgevingen waarin gewerkt wordt met generatie templates die open zijn. Daarmee kun je tenminste nog invloed uitoefen op het eind resultaat.
    Ik heb nog niet nagedacht over de eisen die je zou moeten stellen op een lagere abstractie. Het zou natuurlijk mooi zijn als je mooie assembly code overhoud. Zeker interessant in situaties waar met reversengineering gewerkt moet worden.

    Geplaatst op 17 augustus 2008 om 22:25 Permalink

  • Voedsel voor discussie dan maar:
    – Kan assembly code ook ‘mooi’ zijn? In feite is assembly een tweede abstractie van executeerbare code (2 GL taal). Ik denk dat de meesten zullen instemmen dat er wel degelijk ‘mooie assemblycode’ te maken is.

    Echter één brug verder: Kan machine code ook mooi zijn? Bijvoorbeeld:
    10110101 doet hetzelfde als 111000. (geen idee of dit zo is, maar we gaan er maar even vanuit). Denk eraan dat dit net zo goed code is, als in een bepaalde abstractie/instructies die nog worden vertaald naar stroompjes richting flip-flops e.d. in processoren.

    Waar ik naartoe wil? Kunnen we eigenlijk wel spreken van ‘mooie code’ of meer van ‘mooie modellen’ of ‘mooie abstracties’. Is gegenereerde Java of C# code eigenlijk wel te kwalificeren als mooi of niet mooi, moeten we niet meer naar de bovenliggende handgemaakte modellen kijken?

    Geplaatst op 17 augustus 2008 om 13:53 Permalink

  • Rick van der Arend schreef:

    De laatste zin moet denk ik als volgt worden:

    En zorg er ook voor dat je die onderliggende waarden op de pijnbank blijft leggen.

    Geplaatst op 14 augustus 2008 om 20:45 Permalink

  • Rick van der Arend schreef:

    Een mooie post, Edwin. Ik heb er nog een toevoeging op, die het wel enigszins nuanceert.

    Ik denk dat spreken over ‘mooie’ en/of ‘stinkende’ code een mooie metafoor is, maar ook een gevaar in zich heeft. Iedereen kan iets mooi vinden en iemand anders kan iets anders heel mooi vinden. In de praktijk blijkt ook dat de smaak van persoon tot persoon verschilt (toegegeven, ook weer niet zo heel veel: zie IKEA).

    Echter, het ‘mooi’ waar jij op doelt heeft vaak ook de onderliggende aanname dat experts in hetzelfde domein dezelfde dingen mooi zullen vinden (gegeven dezelfde randvoorwaarden). Het lijkt dan eigenlijk weer meer op het rechtvaardigheidsgevoel. Maar natuurlijk zitten daarin ook verschillen van mens tot mens.

    Waar komen deze verschillen vandaan? Mijns inziens komen ze van verschillende waarden. Als je ‘genericiteit’ veel belangrijker vind dan ‘zo eenvoudig mogelijk’, dan vind je andere software mooi. En als beginnend programmeur zijn je waarden waarschijnlijk nog niet zo getraind en helder en heb je dus nog geen gevoel voor wat mooi én productief is. Je kunt die waarden trainen door in projecten te werken met een goede feedback van de resultaten (b.v. in een klein team of goede evaluaties). Je krijgt ze volgens mij helder door er met andere programmeurs over te discussiëren of erover te schrijven en te lezen. Door ze te moeten verwoorden, maak je je standpunt voor je jezelf vaak ook veel helderder..

    Kortom: helemaal met je eens: gebruik je gevoel bij programmeren en spreek gerust over mooie code. Maar zorg er dan wel voor dat je die onderliggende waarden op de pijnbank blijft leggen.

    Geplaatst op 14 augustus 2008 om 20:34 Permalink

  • Mooie code kan zijn: Begrijpbaar, simpel, logisch, kort, inventief…

    En dan is de code onderhoudbaar/wijzigbaar/uitbreidbaar (bij inventief en kort hoeft dat niet te gelden geloof ik), wat weer gunstig is.

    Volgens mij ga je beschrijvende woorden gebruiken om een bepaald gevoel bij mensen op te wekken, een associatie met iets dat deels dezelfde eigenschappen heeft, ook al is dat niet helemaal objectief.
    Voor mij bijvoorbeeld:
    mooi: goed, waardering, persoonlijke mening;
    stinkt: slecht, idee dat iets z’n tijd gehad heeft of slecht samengesteld is, iets dat gemeden moet worden.

    Zulke woorden moet je zeker gebruiken zolang mensen snappen wat je bedoelt.. Maar tegen iemand die niet zo thuis is in het onderwerp (in dit geval klant) is het misschien beter het gevoel iets te vertalen of uit te leggen.

    Geplaatst op 13 augustus 2008 om 11:53 Permalink

  • Rob Vens schreef:

    Een sterk onderschat zintuig, ons esthetische zintuig. Officieel is het zelfs geen zintuig, maar het is voor mij het zesde zintuig. Leer er op te vertrouwen. Een uitspraak van Kent Beck is beroemd geworden: “code smells”, wat een ander aspect is van schoonheid. Proeven, ruiken, voelen: alle zintuigen leveren naarmate je meer ervaren wordt steeds meer een “gevoel” op of iets klopt, of het goed is. Meesterschap staat gelijk aan feilloos “aanvoelen”.

    Geplaatst op 13 augustus 2008 om 10:59 Permalink

Trackback & Pingback (1)

  1. Van Mooie code! | Edwin van Dillen op 30 september 2008 at 12:06

    […] Lees de rest hier: http://www.software-innovators.nl/2008/08/13/mooie-code/ Doorzoek de site […]