De snelste route is zelden de fijnste¶

Elke navigatie-app kent maar één doel: zo snel mogelijk van A naar B. Dat doel is diep ingebakken. De hele geschiedenis van routeren draait om de kortste of snelste weg, en de wiskunde eronder is daarop geslepen. Voor een pakketdienst is dat precies goed.

Voor een mens is het vaak de verkeerde optimalisatie. De snelste route loopt langs de grote weg, door het lawaai, tussen de prikkels. Ze stuurt je over de rotonde met vier rijstroken omdat dat twee minuten scheelt. Voor wie gevoelig is voor drukte, of gewoon behoefte heeft aan rust, kosten die twee minuten meer dan ze opleveren. De app weet dat niet, want de app meet alleen tijd.

Rust als kostenfunctie¶

Windstil draait het om. In plaats van tijd weegt hij rust. Stillere straten, minder verkeer, meer groen. Techniek hoeft niet altijd sneller te maken. Ze kan ook kalmer maken, en dat is een even geldig doel om op te optimaliseren.

Het idee is preciezer te maken dan het klinkt. Routeren is een probleem op een graaf. De kruispunten zijn knopen, de straten zijn verbindingen, en elke verbinding heeft een gewicht. Een gewone navigatie-app zet in dat gewicht de reistijd. Windstil zet er een rustkost in. Een straat langs een drukke weg krijgt een hoog gewicht, een stille laan met bomen een laag gewicht. Het algoritme dat de kortste weg zoekt, zoekt daarmee de kalmste weg. De machinerie blijft gelijk, de betekenis van het gewicht verandert.

Hoe je zoiets bouwt¶

Concreet komt het neer op een gewogen kortste-pad-zoektocht. A* of Dijkstra werken hier prima. Het verschil met een gewone router zit in de kostenfunctie per straatsegment. Schematisch:

def rustkost(segment):
    # elke term is genormaliseerd naar 0..1
    verkeer = segment.verkeersdrukte      # meer verkeer = hoger
    lawaai  = segment.geschat_geluid      # meer decibel = hoger
    groen   = segment.groen_aandeel       # meer groen = lager, dus 1 - groen
    lengte  = segment.lengte_m

    kost_per_meter = (
        0.5 * verkeer +
        0.3 * lawaai +
        0.2 * (1 - groen)
    )
    return lengte * kost_per_meter

De wegingen hierboven zijn illustratief, geen gemeten optimum. Ze laten de vorm zien: een straat kost meer naarmate hij drukker, luider en kaler is, en de lengte schaalt dat mee. Wie A voedt met deze kost in plaats van reistijd, krijgt een route die drukte ontwijkt. Een heuristiek voor A kan de hemelsbrede afstand naar het doel blijven, zolang je die schaalt met de laagst mogelijke kost per meter, zodat de heuristiek de echte kost nooit overschat en de route optimaal blijft.

Waar de data vandaan komt¶

De kostenfunctie is zo goed als de data die hem voedt. Straattype, aantal rijstroken en aanwezigheid van bomen staan deels in open kaartdata zoals OpenStreetMap, in de tags per weg. Groen is af te leiden uit landgebruik-tags en parkgrenzen. Verkeersdrukte en geluid zijn lastiger. Voor geluid bestaan gemodelleerde kaarten, en verkeer kun je schatten uit wegtype en tijdstip.

Ik ben eerlijk over het bewijsniveau. Dit deel is ontwerp, geen meting. Ik heb geen gevalideerde rustscore per straat liggen. De aanpak is plausibel en bouwt op bestaande databronnen, en of de uitkomst voelt als rustig moet nog blijken uit gebruik. Dat is precies het punt waar het project staat: de mechaniek is helder, de kalibratie is open werk.

Computer science en psychologie tegelijk¶

Daarom is Windstil twee dingen in één. De vorm is een routeringsprobleem, met een graaf, gewichten en een kortste-pad-algoritme. Dat is computer science, en het is opgelost gereedschap. Het antwoord op de vraag "wat is een goed gewicht" komt uit hoe een mens zich voelt onderweg. Dat is psychologie, en het is open.

De koppeling zit in de kostenfunctie. Elke keuze van een weging is een aanname over wat rust is voor wie de route loopt. Weegt lawaai zwaarder dan verkeer? Telt groen echt, of is het schijn? Die vragen zijn niet met een benchmark te beslechten. Ze vragen om te luisteren naar mensen die de route lopen. De techniek levert het skelet, de psychologie levert de gewichten.

Wat ik ermee wil¶

Windstil is mijn tegenvoorbeeld tegen het idee dat techniek er is om alles sneller te maken. Een kaart die je langs de kalmste weg stuurt, weg van drukte en prikkels, optimaliseert voor iets dat telt en dat geen enkele grote app meet. Voor wie gevoelig is voor prikkels is dat verschil groot, en voor de rest is het een fijne optie op een dag dat haast niet nodig is.

Het is bewust klein en lokaal te houden. De route rekent op je eigen toestel op open kaartdata, zonder dat je locatie ergens een veiling in hoeft. Dat past bij hoe ik denk over software die dicht op de mens zit. Kalmte als doel, en privacy als vanzelfsprekendheid eronder.

Kalmte laat zich deels meten¶

De vraag die boven het project hangt, is of rust genoeg vat krijgt om erop te rekenen. Een deel ervan laat zich meten. Verkeersintensiteit is een getal. Wegtype en aantal rijstroken staan in de kaartdata. Nabijheid van groen is af te leiden uit landgebruik. Voor geluid bestaan gemodelleerde kaarten die per gebied een schatting geven. Dat zijn genoeg objectieve haakjes om een straat een score te geven die iets zegt.

Een ander deel ontsnapt aan meting. Of een straat rustig aanvoelt, hangt af van tijdstip, weer, en de persoon die er loopt. Een schoolstraat is stil in de avond en druk om acht uur. Dat is niet met een vaste score te vangen. De eerlijke stand is dat de meetbare kant een goede benadering geeft, en dat de rest kalibratie en persoonlijke instelling vraagt. Ik claim geen gevalideerde rustscore. Ik claim een plausibele benadering met knoppen eraan, en de belofte dat de benadering beter wordt naarmate meer mensen de route lopen en terugkoppelen.

Een echte route weegt zelden maar één ding. Iemand wil rust, en toch niet drie keer zo lang onderweg zijn. Dat is te vangen door de kostenfunctie uit te breiden met een tijdsterm met een klein gewicht. De route zoekt dan de kalmste weg binnen een tijdsmarge, in plaats van de kalmste weg tegen elke prijs.

def totale_kost(segment, voorkeur):
    tijd = segment.reistijd_s
    rust = rustkost(segment)          # uit de vorige sectie
    return voorkeur.w_rust * rust + voorkeur.w_tijd * tijd

Met w_tijd op nul krijg je de zuiver kalmste weg, ook als die veel omloopt. Met w_tijd iets hoger krijg je een route die rust zoekt zolang het niet te veel tijd kost. Zo wordt Windstil bruikbaar op een gewone dag, en niet alleen op de dag dat tijd helemaal niet telt. De gebruiker draait aan één schuif tussen haast en kalmte, en het algoritme regelt de rest.

Wat dit ontwerp aantrekkelijk maakt, is dat de meeste onderdelen al bestaan. Het routeeralgoritme is opgelost werk, al decennia. De kaartdata ligt open. De kortste-pad-zoektocht draait moeiteloos op een telefoon. Het nieuwe zit in één plek: de betekenis die je aan het gewicht geeft. Dat maakt het een klein project met een grote hefboom. Ik verzin geen nieuwe wiskunde, ik hang een andere kostenfunctie aan een bestaande motor. Het risico zit niet in de techniek. Het zit in of de gewichten kloppen met hoe mensen rust ervaren, en dat is te toetsen door de route te lopen en te vragen of hij klopte.

Er is ook een grens aan wat een kaart kan. Windstil kan je langs de stillere weg sturen. Het kan de wereld eromheen niet stiller maken. Op een dichtbebouwde plek is de kalmste route soms nog steeds druk, en dan is het beste dat de app kan doen het minst slechte kiezen. Dat is eerlijk om te zeggen. De belofte is een betere keuze binnen wat er ligt, en geen ontsnapping aan de omgeving zelf.

Zie ook Mandelbrot: oneindige complexiteit uit een regel, Een app kan volledig lokaal, zonder een enkele netwerkcall en Randall Munroe verliet NASA en geeft xkcd gratis weg.