code – nescia/anna

Connecties

Ik was voor een collega een dockerfile aan het maken, dat wil zeggen een rijtje instructies waarmee je snel een soort computer-in-je-computer kan maken waar sommige software al kant en klaar op staat. Omdat ik dat niet zo vaak doe is dat een tamelijk langdurig proces: schrijven, laten draaien, constateren dat het niet werkt, foutmelding googlen of typefout vinden, zelf voor hoofd slaan wegens typefout, corrigeren, laten draaien…

Uiteindelijk wil je dat je rijtje instructies perfect is. De computer voert het uit en komt tot een eindproduct waarvan je kunt voorspellen hoe het werkt. De truc is zorgen dat alle onderdelen met elkaar samenwerken en niets onderling in de war raakt. Daarom maak ik hier ook zo’n bestandje voor: zodat alles bij elkaar staat en mijn collega’s niet elke keer het wiel opnieuw hoeven uit te vinden.

Tijdens het draaien van mijn test-bestandjes moest ik af en toe even wachten tot m’n computer klaar was, en om de boel in mijn hoofd nog enigzins op een rijtje te houden doe ik dan geen ander werk, maar ga ik even breien.

In dit geval met drie kleuren garen tegelijk, die elk volgens een eigen schema gebreid willen worden, terwijl ze netjes proberen samen te werken en niet onderling in de war raken.

Gelukkig heeft iemand een mooi bestandje voor me geschreven en hoef ik niet het wiel uit te vinden.

Groots en meeslepend

Ik kreeg een nieuwe laptop. Hij heeft 64GB ram, wat acht keer zoveel is als mijn oude laptop. Alleen daarom ben ik al tamelijk in mijn nopjes.

Een nieuwe computer is een beetje als verhuizen, in de zin van dat je opnieuw na moet denken over wat je wel en niet gebruikt en nuttig vindt. (De huisgenoot vindt dat we weer eens moeten verhuizen. Ik geloof dat de dubbele rijen in de boekenkast daar iets mee van doen hebben. Maar dan moeten we een huis vinden met een huis ernaast voor de buurvrouw, en krijg dat maar eens voor elkaar in Utrecht.)

Het grote verschil tussen een computer verhuizen en een huis verhuizen is dat je bij het huis fysieke spullen hebt die allemaal door je handen gaan. (Zo vond ik bij de vorige verhuizing het deksel van mijn favoriete pan terug.) Bij een computer moet je dat maar zo’n beetje bedenken. Een groot deel van de dingen die je geinstalleerd hebt zijn ergens netjes buiten het zicht weggestopt. Dat maakt het ook een gelegenheid om alleen terug te zetten wat je ECHT gebruikt, en dingen nu gelijk goed te regelen vanaf een schoon uitgangspunt.

Om mezelf de volgende keer een hint te geven, dit is wat ik nu op mijn computer heb gezet:

Ubuntu LTS
vim, git, curl, wget, alien, …
bitwarden
pycharm
vs code
zsh + oh-my-zsh
slack, teams
firefox
pyenv-virtualenv
docker
tensorflow
cuda
gdal
qgis
gitlab runner

De kenner kan hier al uit afleiden wat mijn werk voornamelijk inhoudt :)

Nieuwe dingen leren voor lichtgevorderden

Vandaag leerde ik iets nieuws over Java, een programmeertaal waar ik vijf jaar in gewerkt heb (al is dat al een tijdje geleden). En kort nadat ik het leerde leerde iedereen in mijn bedrijf iets nieuws over Java, want niemand wist het en ik heb het ze verteld.

Voor de liefhebbers die ook iets nieuws willen leren zal ik het onderaan dit stukje toevoegen, maar wat ik interessanter vond is wat ik over mezelf moest leren om dit te kunnen leren. Want waarom kende niemand in mijn bedrijf vol alleszins capabele softwareontwikkelaars deze eigenschap van Java?

Omdat het alleen relevant is als je slechte code typt.

Dat doen wij niet. Dus voor ons is het niet relevant.

Waarom moet ik het van mijn alleszins capabele docent “Geavanceerd objectgeoriënteerd programmeren” dan alsnog kunnen? Omdat als je dit snapt, je precies snapt in welke volgorde Java bepaalde dingen doet. Ook als je goede code typt.

Tot voor kort liep ik enorm vast op dit soort didactische trucs. Ik ben namelijk afgericht om diep ongelukkig te worden van slechte code. Dan krijg je het bij dit soort cursussen wel moeilijk. Nu vertel ik mezelf periodiek HET IS VOOR HET LEEREFFECT en dan lukt het wel. Tenzij ik het vergeet, dan heb ik een paar mensen klaarstaan die het tegen me roepen als ik bij ze kom klagen.

Op de een of andere manier is dit essentieel voor mij om dingen te leren die niet objectief geweldig zijn (zoals logica en lineaire algebra 😍😍😍). En ik ben erg blij dat ik dit nu geleerd heb, want het maakt nieuwe dingen leren ontzettend veel makkelijker.

(Overigens zou ik het waarderen als ze ook in de cursus zouden zeggen “deze code is superkut, niet gebruiken”. Al staat er gelukkig af en toe wel iets als “De nadruk ligt op het bestendigen van de theorie en niet de toepassingen als zodanig”.)

Bijlage voor de liefhebbers: wat is de output van main() (in class B)?
Of, de eigenlijke relevante vraag: wat is de waarde van B.b direct nadat B geïnitialiseerd is?

public class A { 
    protected int a = 5;
      
    public A() {
         System.out.println("constructor A: a = " + a);
         a = 7; 
    } 
 
    public int getA() { 
        return a;
     }
 }

  public class B extends A {
     private int b = a + 10;

      public B() { 
        a = 2;
         System.out.println("constructor B: a = " + a + ", b = " + b); 
    }  

    public int getB() {
         return b;     
    }  

    public static void main(String[] args) { 
        B b = new B();
         System.out.println("main: a = " + b.getA() + ", b = " + b.getB()); 
    }
 }

Update de revolutie

Drie jaar geleden publiceerde ik (op de geheel willekeurige datum 1 april) een scriptje dat biologische metaforen preciezer maakt. Een van mijn collega’s vond dit, constateerde dat het niet meer werkt, en (omdat ik een smerige backender ben die nog geen javascript-update zou herkennen als het rondjes om me heen fietste op een eenwieler) fixte het. Dank je Niels!

Met een plugin als TamperMonkey kun je dit ook draaien in Chrome.

// ==UserScript==
// @name        Stuifmeel
// @namespace   https://nescia.nl/anna
// @description Verander het woord 'zaad' in 'stuifmeel' op plekken waar dat waarschijnlijk passender is.
// @version     1
// @grant       none
// @match        *://*/*
// @exclude     http://*seed*
// @exclude     http://*garden*
// @exclude     http://*tuin*
// @exclude     http://*zaad*
// @exclude     http://*zad*
// ==/UserScript==
var textNodes = document.evaluate('//text()', document, null, XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE, null);
var searchRE_1 = new RegExp('(zijn |mijn |je |uw |hun |donor|mannelijk )zaad', 'gi');
var replace_1 = '$1stuifmeel';
var searchRE_2 = new RegExp('zaad(donor|bal|leider)', 'gi');
var replace_2 = 'stuifmeel$1';
var searchRE_3 = new RegExp('(sperma.+)zaad', 'gi');
var replace_3 = '$1stuifmeel';
var searchRE_3a = new RegExp('zaad(.+sperma)', 'gi');
var replace_3a = 'stuifmeel$1';
var searchRE_4 = new RegExp('(his |my |your |their |donor |male |manly )seed', 'gi');
var replace_4 = '$1 pollen';
var searchRE_5 = new RegExp('(sperm.+)seed', 'gi');
var replace_5 = '$1pollen';
var searchRE_5a = new RegExp('seed(.+sperm)', 'gi');
var replace_5a = 'pollen$1';

for (var i = 0; i < textNodes.snapshotLength; i++) {
  var node = textNodes.snapshotItem(i);
  node.data = node.data.replace(searchRE_1, replace_1);
  node.data = node.data.replace(searchRE_2, replace_2);
  node.data = node.data.replace(searchRE_3, replace_3);
  node.data = node.data.replace(searchRE_3a, replace_3a);
  node.data = node.data.replace(searchRE_4, replace_4);
  node.data = node.data.replace(searchRE_5, replace_5);
  node.data = node.data.replace(searchRE_5a, replace_5a);
}

Artist impression

Software maken is creatief in de letterlijke betekenis van het woord. Je maakt iets wat er eerst nog niet was. (Mocht je vinden dat dingen die alleen op computers bestaan niet echt zijn, dan is deze tekst ook niet echt, en wat ben je nu dan aan het doen? Maar dat terzijde.)

Zelf moet je er ook op z’n minst een beetje creatief voor zijn, want doorgaans maak je iets unieks. Ik zie het wel eens als het schrijven van een verhaaltje: ik heb een aantal karakters, en die kunnen dingen, en ze reageren op elkaar, en ze maken allerlei avonturen mee. Om dat een beetje goed te doen is het zaak duidelijk te krijgen wat de onderdelen van je verhaaltje zijn (dat kunnen concrete dingen zijn zoals stoelen en tafels, maar ook meer abstracte zoals het concept meubels of tijd), en hoe ze zich allemaal tot elkaar kunnen verhouden (een stoel kan onder de tafel tenzij de tafel te laag is, en op de tafel tenzij de stoel te zwaar is…). Nu wordt het al snel ingewikkeld. Daarom noemen we de sjiekere programmeurs ‘architect’.

Er zijn ook mensen die zichzelf ‘code poet’ noemen. Maar aangezien poëzie geloof ik bedoeld is als multi-interpretabel, dat juist iets anders probeert over te brengen dan alleen de woorden waar het uit bestaat, zou ik er liever geen in mijn team hebben.

Omdat ik voor verzekeraars werk beginnen al mijn verhaaltjes eigenlijk met ‘Er was eens een polis…’ Zo heb ik de afgelopen jaren geleerd dat polissen heel wat wilde avonturen mee kunnen maken. Al vraag ik me natuurlijk wel eens af wat voor verhalen ik zou tegenkomen als ik een andere hoofdpersoon had.