english English

Documentatie, even belangrijk als je code!

Elke developer weet dat je code duidelijk gedocumenteerd moet zijn. Toch gebeurt dit vaak nog te weinig of gewoon niet op de juiste manier waardoor je documentatie eigenlijk zijn doel mist. In deze blogpost wil ik graag de meest gebruikte smoesjes om het niet te doen oplijsten en nog eens de voordelen benadrukken. Als laatste geef ik nog enkele tips mee over hoe je betere documentatie schrijft.

Smoesjes om het niet te doen

Elke goede developer begrijpt deze code toch?

Dit is volgens mij het meest gebruikte excuus. Zelfs al is je code duidelijk geschreven en is het makkelijk leesbaar, dan betekent het nog steeds niet dat je code ook begrijpbaar is. Duidelijke documentatie zorgt ervoor dat je collega's je minder vaak storen om te vragen wat dat ene stukje code ook al weer deed. Ook kan je op dit moment je code wel goed begrijpen, maar weet je dit over een jaar nog steeds?

Ik geef alles een duidelijke naam. Meer is toch niet nodig?

Het duidelijk benoemen van je variabelen en functies is zeker een meerwaarde voor je code. Maar een naamgeving zal nooit meer zijn dan een omschrijving van je functie in enkele (vaak afgekorte) woorden.

Hier heb ik geen tijd voor!

Ook al heb je weinig tijd om een project tot een goed einde te brengen, tijd maken voor het schrijven van documentatie kan je in de toekomst, wanneer de klant nog snel een aanpassing wilt, veel tijd besparen doordat je niet bij elke regel moet denken: "Waarom heb ik dit zo weer gedaan?" of "Wat deed dit weer?".

Een goed voorbeeld

Onderstaand kan je een voorbeeld terugvinden van duidelijke documentatie.  De documentatie van deze functie laat je weten dat alle voorgaande afzenders uit de lijst worden verwijderd, iets wat niet duidelijk is als je alleen de functienaam had.

/**
 * Sets the recepient of this message, calling this method also clears any
 * previously set recepients in the TO stack.
 * @param string $email
 * @param string $name
 * @return Mailer
 */
public function setTo($email, $name = null)
{
    $this->clearTo();
    $this->addTo($email, $name);
    return $this;
}

Voordelen

Code onafhankelijk van ontwikkelaar

Wanneer je met meerdere ontwikkelaars werkt aan een project is het zeker een plicht je documentatie up-to-date te houden. Maar zelfs wanneer je alleen aan een project werkt moet je er rekening mee houden dat je project wel eens naar een andere ontwikkelaar kan worden doorgeschoven of dat je van job verandert en je er dus niet meer aan zal werken.

Na geruime tijd begrijp je je eigen code niet meer

Wanneer je code gedurende lange tijd onveranderd blijft krijg je vaak schrik om je code nog aan te passen. Je hebt schrik dat je bij elke aanpassing wel ergens anders iets kapot maakt. Goede documentatie geeft je het zelfvertrouwen om je code aan te passen zonder iets kapot te maken.

Auto-complete bij gebruik van IDE

Er wordt op de dag van vandaag veel gebruik gemaakt van IDE-tools die je code hinting geven. Hier zal goed geschreven documentatie jezelf, en de rest van het team, veel tijd besparen. Zo zie je direct een omschrijving van de aan te roepen functie zonder dat je telkens opnieuw dat ene bestand moet zoeken waar die functie staat. Om daarna de code door te nemen om te achterhalen wat het resultaat zal zijn.

Tips

Schrijf je commentaar altijd in dezelfde taal

Het gebruik van eenzelfde taal in je documentatie zorgt voor consistentie. Je gaat variabelen ook niet half in het Nederlands, half in het Engels benoemen? Wanneer je in een team werkt maak je dan ook best afspraken over de taal van je documentatie, al is het aan te raden om je volledig op Engelse documentatie te richten.

Documenatie gaat over wat je code doet

Documentatie heeft niet als doel om je code te verantwoorden of een excuus te geven waarom de code er zo slecht uitziet, maar meer om uit te leggen wat de code juist doet en waar het rekening mee houdt.

Hou het leuk!

Als laatste is het altijd wel eens leuk om een leuke opmerking in je code stoppen waar je zelf, en je collega's, eens mee kunnen lachen. Iedereen kent de regel "stop(); // Hammertime" wel. Een uitgebreide lijst met hilarische documentatie kan je op Stackoverflow terugvinden.

RSS reacties feed

13 reacties tot nu toe

Kevin Van Dyck

Kevin Van Dyck zei 1 jaar geleden:

Ook belangrijk is om niet zozeer te documenteren *wat* een functie doet (tenzij dit niet duidelijk is uit de code zelf), maar eerder *waarom* het dat doet.
Chris Ramakers

Chris Ramakers zei 1 jaar geleden:

Op StackOverflow vind je naast de leuke link van Stijn nog een heleboel andere threads met zeer nuttige info over hoe je code kan optimaliseren met comments. http://bit.ly/d1AWmt

Daarnaast kan ik Stijn alleen maar bijstaan, het belang van documentatie is niet te onderschatten. En iets wat vaak ook vergeten wordt en vaak voor veel frustraties leidt is out-of-date comments of documentatie. Foute documentatie kan vaak meer schade aanrichten dan geen documentatie.

Het is in sommige gevallen ook handig om per project een documentatie verantwoordelijke aan te duiden die de commits in de gaten houdt en controleert of de code juist gedocumenteerd is. Een saaie en vervelende maar vaak erg nuttige job.
Brian Merken

Brian Merken zei 1 jaar geleden:

Leuke blogpost @Stijn, lees enkele zaken die zeker een belletje doen rinkelen!
Nicky De Maeyer

Nicky De Maeyer zei 1 jaar geleden:

Ook niet onbelangrijk is niet overdrijven met comments, soms lees je dingen als dit:
_getParam('foo');
//saving parameter
$success = $this->save($param);
if ($success) {
//redirect on success
$this->_redirect('url');
} else {
//throw exception
throw new Exception('failed');
}
?>

Dit is lichtjes overdreven, maar vooraleer je een comment plaatst moet je je toch afvragen:
- is dit niet straight forward? i.e. basic readable code...
hierbij mag je natuurlijk niet vergeten dat je "in het project zit", en of het even readable zou zijn moest je een half jaar later de code zou tegenkomen...
Nicky De Maeyer

Nicky De Maeyer zei 1 jaar geleden:

code hierboven is blijkbaar gefiltered en er mist dus een stuk uit, but u get the point...
Sacha Vandekerckhove

Sacha Vandekerckhove zei 1 jaar geleden:

Over het algemeen ben ik het met je eens (prima artikel ook ;). Maar...,

Op de afbeelding vanboven staat tè veel documentatie (die uiterst linkse toch). Dat maakt je code er niet meer leesbaar/begrijpbaar op. Niet iedere lijn heeft verduidelijking nodig hé :). (Lees net de post van Nick hierboven, die dit beaamt.)

Daarnaast is wat je schrijft zeker waar voor back-end code. Maar front-end code, zowel markup als logica, heeft vrijwel geen commentaar nodig.
Daar komt bij dat semantisch goed opgebouwde code zichzelf documenteert (heel stom voorbeeldje):

// Loop through all posts and check if it is moderated
for ($i = 0; $i status == 1) {
//...
}
}

Is minder duidelijk dan

foreach ($posts as $post) {
if ($post->isApprovedForDisplay()) {
//...
}
}

Als laatste, ook over de afbeeldingen; de code daarin is niet echt consistent. De ene keer staat er geen spatie tussen "if" en "(" (of while en "("), de andere keer wel. Is maar een klein iets, maar wel iets wat de leesbaarheid bevordert.

Mijn 5 centjes :)
Maarten Tibau

Maarten Tibau zei 1 jaar geleden:

Documentatie in code is inderdaad ZEER belangrijk. Ik betrap me er soms zelf nog op dat ik dit vergeet. Een goeie manier (in het begin een beetje irritant) is het installeren van een CodeSniffer. Zo krijg je een goed beeld van hoe goed je code is gedocumenteerd en of je niet ergens iets vergeten bent. Bv. bovenaan elke class, functie etc... documentatie.

CodeSniffer (PEAR)
Jan Peeters

Jan Peeters zei 1 jaar geleden:

Allemaal waar, maar.... Het hangt er ook wel van af in welke ontwikkelomgeving je werkt. OK voor jouw voorbeelden, maar als ik in .NET C# onwikkel is de programmacode zelf reeds zo formeel dat het documenteren van de method zelf wel volstaat, tenzij complexe logica verder moet uitgelegd worden. Een tool als NDOC doet dan de rest wel automatisch. Mijn ervaring is verder dat je best tools gebruikt die je verplichten om te documenteren voor je iets kan inchecken in sourcecontrol. Een laatste tip: laat de teamleden mekaars code reviewen. Dat duurt maar 10 minuten en is niet alleen nuttig als controle, maar ook heel leerzaam!
Santhos Webdesign

Santhos Webdesign zei 1 jaar geleden:

Komt me bekend voor dit. Ik onderschat het iedere keer weer... nu ff niet... snap ik later ook nog wel... snel verder programmeren... maar er komt altijd weer dat moment dat je je eigen code zit te analyseren omdat er geen touw aan vast te knopen is :-)
webdesign webit

webdesign webit zei 1 jaar geleden:

Prima artikel, klopt als een bus.
Code moet doorzichtig zijn voor iedereen.
Raf

Raf zei 1 jaar geleden:

Het is idd heel vervelend als er geen uitleg bij zit soms. Maar op het moment zelf wordt het vaak vergeten omdat het op dat moment allemaal 'logisch' lijkt soms. goed artikel.
Nicolas

Nicolas zei 1 jaar geleden:

Het was nog nooit in me opgekomen om dit te doen maar het lijkt me best wel een aangename meerwaarde. Brengt direct wat meer fun in de soms wat saaie code die we dag in dag uit schrijven.
Dirk Bonhomme

Dirk Bonhomme zei 1 jaar geleden:

Ik riek een beetje sarcasme

Reageer op dit artikel

Toegelaten tags: <a href="" title=""> <code> <em> <strong>

RSS Feed

Bekijk alle tags

Laatste reacties

  • Tom Claus: @Filip Bedankt voor de tip, CouchDB gaan we zeker even mee bekijken. @Fabio Deze...
  • Fabio Maggio: Is die presentatie van Masterizing PHP Data Structure ook nog ergens te bekijken?
  • Tom Hermans: Thx Tom, schone samenvatting en een massa interessante links, ideaal voor mensen die die dag...
  • Filip Stas: Als MongoDb je al boeit zeker ook eens kijken naar couchbase ook zeker de moeite!
  • Dragolin: Wij proberen in 2012 alvast sportief Vlaanderen warm te maken voor sportieve experiences :)