a23-curved

In een abstract beeld van de mens zie ik verantwoordelijkheid als datgene wat volwassenen onderscheidt van kinderen. Een kind kan niet de verantwoordelijkheid dragen voor zijn eigen daden; een volwassene wel. Met de kanttekening dat sommige kinderen volwassener zijn dan sommige volwassenen. Het begrip verantwoordelijkheid is trouwens op meerdere manieren te bekijken. Eén invalshoek is: bedoel je verantwoordelijkheid voor jezelf, of voor anderen? Een voorbeeld: ik woon in een (appartementen)huis met meerdere eigenaren; we zijn met zijn allen lid van een VVE, een Vereniging van Eigenaren. Dat is wettelijk verplicht, gelukkig, dus we zijn tot elkaar veroordeeld als het gaat om de verantwoordelijkheid voor ons huis. Het is een gedeelde verantwoordelijkheid. Een paar keer per jaar komen we gezellig samen om te overleggen of te kibbelen, niets menselijks is ons vreemd. De mate waarin we ons verantwoordelijk voelen voor ons huis verschilt per persoon (ook dat is niks bijzonders) en die vrijheid gunnen we elkaar. Mijn persoonlijke conclusie, na bijna 20 jaar VVE, is: gedeelde verantwoordelijkheid is géén verantwoordelijkheid. Het werkt niet. We hebben de neiging om te denken: iemand anders doet het wel. Soms moet er daarom iemand opstaan die zegt: ik beschouw dat of dat als mijn taak, ik voel me er verantwoordelijk voor want anders gebeurt er niets. Een ander neemt weer een andere taak op zich, en zo draait ons gemeenschapje.

Maar ik ben een programmeur, en deze blog gaat over programmeren. Hoe kan ons huis me dan inspireren? Da’s heel simpel: ook in software is er sprake van verantwoordelijkheden. Ik had het al vaak over objecten die elk hun eigen taak hebben. Dat is (voor een programmeur althans) precies hetzelfde. Taken, verantwoordelijkheden die “iemand” (een mens of een object) op zich neemt. Maar er zijn meer voorbeelden, o.a. als je gaat kijken hoe het internet werkt. Het hele internet is één groot voorbeeld van verdeling van werk tussen computers, programma’s en andere apparaten. Daarover zijn al lang geleden afspraken gemaakt die zijn vastgelegd in zgn. protocollen. Netwerkprotocollen. Voor elke soort toepassing is er een ander protocol, of meerdere. Ze hebben klinkende namen als “POP”, of “SMTP”, of “HTTP”, of “TCP/IP”. Je bent ze vast wel eens tegengekomen bij de instellingen van je computer of je mailprogramma.

De gedeelde verantwoordelijkheid van hierboven bestaat ook op het internet. En daar werkt het wel! Het wordt (of werd) toegepast in de Ethernet-protocollen, op het laagste niveau. Ethernet is, kort gezegd, de kabel waarmee je twee computers met elkaar verbindt, of je computer met je modem of router. Zoals veel van wat we vandaag met computers doen is Ethernet lang geleden uitgevonden door Xerox. Er zijn sindsdien wel wijzigingen doorgevoerd; met de invoering van zgn. hubs of switches, bijvoorbeeld, is er toch een soort van centrale verantwoordelijkheid ingevoerd. Maar dat doet niets af aan het principe.

Met de Ethernet-verbindingen tussen de apparaten maken we een netwerk. De apparaten op het netwerk communiceren met elkaar, dat is het doel van het netwerk. Een apparaat praat of luistert, of allebei tegelijk. Het oorspronkelijke principe van Ethernet is: er zijn meerdere apparaten aangesloten op het netwerk, maar niemand is de baas. Dat betekent dat alle apparaten zelf mogen besluiten wanneer ze gaan praten. Dat betekent ook dat de kans groot is dat twee of meer apparaten tegelijkertijd gaan praten. Met als gevolg dat ze elkaar niet verstaan. Zoiets heet een “collission”, een botsing van woorden zou je kunnen zeggen. De woorden komen door elkaar, de zinnen worden zinloos. Dat krijg je ervan als niemand de verantwoordelijkheid heeft om te bepalen: nu mag jij praten, en nu jij.

Maar, zoals gezegd, het werkt toch bij Ethernet. Door een simpele afspraak: als een apparaat gaat praten moet het tegelijkertijd luisteren. Als het dan hoort dat er tegelijkertijd nog een apparaat gaat praten (het herkent een botsing) dan houdt het onmiddellijk weer zijn mond. Na een willekeurige pauze probeert het apparaat het opnieuw. Dat doet het andere apparaat ook, maar juist doordat de pauze willekeurig is, is de kans klein dat beide dezelfde pauze inlassen. En dus is er één eerder. Het andere apparaat wacht dan natuurlijk netjes tot het eerste is uitgesproken. Dit werkt, zolang er niet te veel apparaten zijn die allemaal heel veel willen zeggen. Andere protocollen moeten dan de spraakverwarring oplossen.

Misschien kunnen we in de VVE ook eens het Ethernet-protocol invoeren bij de vergadering. Geen voorzitter, iedereen is de baas. Als je gaat praten luister je tegelijkertijd of je de enige bent die praat. Zo niet, dan houd je even je mond en je begint opnieuw. Toch gedeelde verantwoordelijkheid. Al zal dat luisteren wel een probleem zijn. Mensen hebben namelijk iets wat apparaten missen: emoties, passie. Dat maakt ons menselijk. En lastig in de communicatie. Misschien hebben we toch een hub nodig. Voorzitter?

Advertenties