Lessen blind typen
voor programmeurs

Programmeren wordt vaak omschreven als het oplossen van logische problemen, het ontwerpen van systemen of het bouwen van applicaties. Dat klopt allemaal. Maar men vergeet vaak dat programmeren ook de fysieke vaardigheid inhoudt om code in een editor in te voeren. Een programmeur gebruikt een toetsenbord om code in te voeren. Naar toetsen zoeken terwijl je haakjes of een for-lus typt, onderbreekt je werk. Vloeiend typen vermindert zulke pauzes tijdens de invoer. Blind typen in programmeren zorgt ervoor dat je je concentreert op het probleem dat je oplost, niet op de handeling van typen zelf. Snel typen in programmeren betekent niet "120 woorden per minuut", maar juist nauwkeurigheid en vertrouwdheid met de symbolen, sleutelwoorden en patronen waaruit code bestaat.

Anders dan gewone tekst volgt code een vastgelegde structuur en syntaxis. Je kunt er niet op rekenen dat de compiler of interpreter je bedoeling raadt wanneer je een verkeerd teken typt. Een typefout kan een syntaxisfout veroorzaken of de betekenis van het programma veranderen, ook als de code geldig blijft. Oefen snel typen bij het programmeren daarom samen met nauwkeurigheid; snelheid alleen garandeert niet minder correcties. Met blind typen kun je naar de editor blijven kijken en minder aandacht besteden aan het zoeken naar toetsen. De programmalogica controleren en problemen oplossen blijven afzonderlijke taken.

AgileFingers richt zich precies op deze uitdaging: programmeurs lessen aanbieden gebaseerd op echte code, niet op willekeurige syntaxis. Het gaat er niet om dat je een taal vanaf nul leert, maar dat je vertrouwd raakt met het intypen van de syntaxis. De combinatie van kennis van de programmeertaal en blind typen geeft een ontwikkelaar zelfvertrouwen.

Elke taal stelt andere eisen aan je vingers. Vanuit het perspectief van blind typen is het logisch om ze te groeperen naar de toetsenreeksen die je typt, niet naar hun programmeerparadigma. AgileFingers biedt oefenmateriaal voor Java, JavaScript, C++, C#, Go, PHP, SQL, Bash en Python. Zo onderscheiden ze zich:

Haakjes-intensieve talen (Java, JavaScript, C++, C#, Go)
Deze talen gebruiken veel accolades {} en ronde haakjes. In Java, C++ en C# eindigen instructies meestal op een puntkomma; Go voegt de meeste puntkomma's automatisch in, terwijl je ze in JavaScript in veel gevallen kunt weglaten. Deze tekens vormen het skelet van de code. Als je tijdens het typen naar de toetsen moet zoeken, kan dat je gedachtegang onderbreken. Een voorbeeld in Java:

public class Greeter {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("Hallo " + i);
        }
    }
}

Of C# met zijn uitgebreide maar gestructureerde syntaxis:

for (int i = 0; i < 10; i++) {
    Console.WriteLine($"Waarde: {i}");
}

Het snel typen van dergelijke lussen vraagt behendigheid met haakjes en operatoren. C++ voegt pointer-operatoren (*, ->) toe, en Go vereenvoudigt de syntaxis maar gebruikt ook accolades. Door deze toetsenreeksen in AgileFingers te oefenen, kun je ze met meer gemak invoeren.

Script- en querytalen (Bash, PHP, SQL)
Scripttalen gebruiken intensief symbolen. In Bash gebruik je vaak pipes (Ned. "pijpen", Eng. "pipe" - |), redirects en dollartekens $:

for file in *.txt; do
  echo "Verwerken van $file"
done

In PHP schrijf je variabelen met een $ ervoor. Wanneer PHP in HTML is ingebed, wisselen HTML-tags en code met C-achtige syntaxis elkaar in het bestand af. In SQL draait het minder om leestekens en meer om de structuur van sleutelwoorden:

UPDATE users
SET active = 0
WHERE last_login < NOW() - INTERVAL '30 days';

In deze talen betekent blind typen vertrouwd raken met sleutelwoorden en symbolen. Een kleine pauze bij het intypen van een pipe of een ontbrekende puntkomma kan je denklijn onderbreken.

Indentatie-gedreven talen (Python)
Python is bijzonder omdat inspringing deel uitmaakt van de syntaxis. Het ontbreken van een spatie of dubbele punt kan het programma breken. Het typepatroon is duidelijk: if ...:, nieuwe regel, inspringen. Bijvoorbeeld:

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

Blind typen oefenen in Python helpt je vertrouwd te raken met de visuele structuur en de syntaxis op basis van inspringing. Editors voegen vaak automatisch tabs of spaties toe, maar je moet nog steeds herkennen waar elk blok begint en eindigt. Als je de gebruikelijke indeling kent, kun je de code gemakkelijker volgen terwijl je typt en controleert. AgileFingers biedt veel Python-fragmenten om het invoeren van deze constructies te oefenen.

Andere programmeertalen
Talen als Rust, Kotlin, Swift of Haskell hebben elk hun eigenaardigheden. Rust legt de nadruk op geheugenveiligheid met borrowing (&) en lifetimes ('a). Kotlin gebruikt lambda-expressies en pijlen in functietypen. Swift combineert C-achtige syntaxis met moderne expressie. Haskell vraagt zorgvuldige inspringing en heeft veel symbolische operatoren. Wat de taal ook is, blind typen helpt om de lastige onderdelen efficiënt te gebruiken.

Programmeren is prettig als je volledig opgaat in de taak en je ideeën zonder onnodige onderbrekingen in code kunt omzetten. Deze toestand van diepe concentratie wordt vaak "flow" genoemd. Met blind typen hoef je minder naar toetsen te zoeken en telkens van de editor naar het toetsenbord te kijken. Daardoor vraagt het typen zelf minder aandacht terwijl je aan de logica, het ontwerp en de oplossing werkt. Je moet de syntaxis nog steeds kennen en controleren; die kennis doe je op door de taal te leren en te gebruiken. Autocompletion en het kopiëren van code kunnen ook bij deze werkwijze passen, zolang je begrijpt en controleert wat je invoegt.

Autocompletion is nuttig voor lange variabele- of klassenamen, maar ook voor terugkerende lussen en codeblokken. Als je een volledig voorstel overneemt, oefen je niet om het teken voor teken zelf te typen. Leer je de taal nog, lees dan de aangevulde code en controleer of je de structuur begrijpt. Probeer bepaalde constructies ook zelf te schrijven. Autocompletion gebruiken betekent op zichzelf niet dat je de syntaxis vergeet.

AI-assistenten (Eng. "AI assistants") kunnen volledige functies of meerdere codeblokken tegelijk voorstellen. Dat kan typewerk besparen, maar je moet het voorstel nog steeds lezen en aanpassen: kleine details kunnen de werking van het programma veranderen. Een assistent gebruiken maakt je op zichzelf niet tot een passieve codebeoordelaar. Je bepaalt nog steeds welke code je overneemt en hoe die in je project past. Blind typen blijft nuttig bij je eigen wijzigingen, toevoegingen en correcties. In AgileFingers kun je het invoeren van taalconstructies oefenen en vertrouwd raken met hun symbolen en sleutelwoorden.

Een geïntegreerde ontwikkelomgeving (Eng. Integrated Development Environment, IDE) is meer dan een editor. Deze combineert editing, debugging, refactoring, testen en projectbeheer. Voorbeelden zijn IntelliJ IDEA, PyCharm en Rider. Ze bieden sterke autocompletion, foutdetectie en navigatie. Vloeiend typen helpt bij het invoeren en bewerken van code. Via sneltoetsen kun je veel gebruikelijke opdrachten uitvoeren, terwijl de keuze tussen muis en toetsenbord afhangt van de taak en je werkgewoonten.

Autocompletion in een IDE is handig, maar vervangt geen basiskennis van de taal. Je kunt het voor lange identifiers en gebruikelijke constructies gebruiken als je de resulterende code begrijpt. Wil je het invoeren van een for-lus oefenen, schrijf er dan af en toe een zonder sjabloon en controleer de voorwaarde en de inhoud. Blind typen helpt bij het zelf invoeren en aanpassen van code. Aanvulfuncties en typeoefeningen kunnen zo deel uitmaken van dezelfde werkwijze.

Op de grens tussen IDE en editor staat Visual Studio Code. Sommigen noemen het een IDE, maar technisch gezien is het een geavanceerde teksteditor. Met de juiste plugins is het zeer krachtig. Extensies voor Vim-emulatie brengen Vim-sneltoetsen naar VS Code. Git-ondersteuning is ingebouwd in de editor; andere extensies bieden databasefuncties of linting (Eng. "linting"). Blind typen is nuttig bij het invoeren en bewerken van code, maar de waarde van deze tools hangt ook af van hoe je ze voor de betreffende taak gebruikt.

Neovim is ontworpen voor werken met het toetsenbord, maar ondersteunt ook de muis en kan via grafische interfaces worden gebruikt. De commando's maken gerichte bewerkingen mogelijk: dd verwijdert een regel, ciw wijzigt een woord en :%s/foo/bar/g vervangt tekst in het hele bestand. Voor navigatie kun je bijvoorbeeld 42G gebruiken om direct naar regel 42 te gaan. Blind typen helpt bij het invoeren van commando's en code. Je moet de commando's zelf ook leren kennen, door ze voor concrete bewerkingstaken te gebruiken.

Het plugin-ecosysteem (Eng. "plugins") maakt Neovim veelzijdig: telescope.nvim voor zoeken, coc.nvim of nvim-cmp voor completion, fugitive.vim voor Git. Deze plugins voegen zoek-, aanvullings- en versiebeheercommando's toe aan de editor. Als je liever met het toetsenbord werkt, kun je hun sneltoetsen leren naast de bewerkingscommando's van Neovim en blind typen gebruiken voor het invoeren van code.

Na jaren coderen merk je hoe het toetsenbord bij je werkgewoonten past. Mechanische toetsenborden gebruiken afzonderlijke mechanische switches, die afhankelijk van het type anders aanvoelen bij het indrukken van een toets. Wat tijdens een lange sessie comfortabel is, hangt af van het model, de plaatsing en je voorkeuren. Je kunt switchtypen kiezen, vaak aangeduid met kleuren als rood, blauw of bruin. Ze verschillen bijvoorbeeld in de benodigde kracht, voelbare feedback en geluid; de eigenschappen hangen af van het specifieke model. Zo kies je een aanslag die prettig voor je is. Blind typen kun je oefenen op een toetsenbord dat bij je past. Mechanische switches alleen garanderen geen verminderde vermoeidheid, hogere nauwkeurigheid of ontspannen vingers tijdens lange sessies. Ook de positie van je handen en pauzes beïnvloeden het comfort.

AI-tools kunnen codefragmenten, volledige functies en programma's genereren. Hun voorstellen besparen een deel van de handmatige invoer, maar je moet controleren of ze de werkelijke taak oplossen. Code overnemen die je niet begrijpt, maakt het lastig om die later te wijzigen of fouten te vinden. Daarom blijft het belangrijk om de taal te leren en je eigen programma's te schrijven. AI gebruiken betekent op zichzelf niet dat je de syntaxis vergeet of ophoudt met creatief werk. Oplossingen ontwerpen, over wijzigingen beslissen en resultaten controleren blijven deel uitmaken van programmeren.

AI kan nuttig zijn voor herhaalde boilerplate (Eng. "boilerplate") of debug-uitvoer, zoals print en console.log. Ook dan bepaal je wat waar moet worden weergegeven en controleer je de voorgestelde code. Afhankelijk van de taak wissel je tussen code schrijven, aanpassen en voorstellen beoordelen; al deze activiteiten horen bij het werk van een programmeur. Blind typen is nuttig bij handmatige invoer en correcties. AgileFingers biedt oefeningen met sleutelwoorden en symbolen in codevoorbeelden om aan typesnelheid en nauwkeurigheid te werken. Kennis van de taal en het ontwerpen van programma's ontwikkel je door studie en eigen projecten.

Blind typen is een praktische vaardigheid bij het invoeren en bewerken van code. Als je weet waar de toetsen zitten, kun je naar de editor kijken in plaats van telkens naar het toetsenbord. Het zoeken naar een teken onderbreekt dan minder vaak het uitwerken van een idee in code. Typesnelheid en de juistheid van een programma zijn wel verschillende zaken: je moet de logica blijven controleren en het resultaat testen. Zelf code schrijven kun je combineren met automatische aanvulling en AI-suggesties wanneer die bij de taak passen.

AgileFingers biedt programmeerlessen met codefragmenten uit Java, Python, Go en andere talen. Door de toetsaanslagen uit de voorbeelden te herhalen, oefen je typesnelheid en nauwkeurigheid en bouw je spiergeheugen op voor veelgebruikte symbolen en toetsreeksen. Je raakt zo vertrouwd met de schrijfwijze van code, maar om de werking te begrijpen moet je de taal leren en aan eigen projecten werken. Ook als hulpmiddelen code genereren of aanvullen, blijft blind typen handig voor het invoeren van je eigen wijzigingen en correcties.