Reacties op: Mooie code!

Door: Mooie code! | Edwin van Dillen

Mooie code! | Edwin van Dillen — Tue, 30 Sep 2008 10:06:00 +0000

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

Door: Sebastiaan

Sebastiaan — Sun, 31 Aug 2008 11:01:20 +0000

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. ;-)

Door: Ype

Ype — Mon, 18 Aug 2008 10:45:29 +0000

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)

Door: Edwin van Dillen

Edwin van Dillen — Sun, 17 Aug 2008 20:25:15 +0000

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.

Door: Andre Boonzaaijer

Andre Boonzaaijer — Sun, 17 Aug 2008 11:53:31 +0000

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?

Door: Rick van der Arend

Rick van der Arend — Thu, 14 Aug 2008 18:45:25 +0000

De laatste zin moet denk ik als volgt worden:

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

Door: Rick van der Arend

Rick van der Arend — Thu, 14 Aug 2008 18:34:26 +0000

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.

Door: Johan Scholten

Johan Scholten — Wed, 13 Aug 2008 09:53:40 +0000

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.

Door: Rob Vens

Rob Vens — Wed, 13 Aug 2008 08:59:57 +0000

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”.