Blind typen voor programmeurs

Met blind typen schrijf en bewerk je code zonder naar toetsen te zoeken. Je houdt je ogen op het scherm terwijl je een functie, een opdracht of instructies voor een AI-agent schrijft. Oefeningen voor programmeurs moeten naast letters ook cijfers, symbolen en de naamgevingsregels uit code bevatten.

De belangrijkste punten

• Oefen de cijfers, symbolen en naamgevingsregels van je programmeertaal. De gewone AgileFingers-cursus bevat cijfers en speciale tekens.
• Gebruik de programmeerlessen voor code of plak een eigen fragment bij aangepaste teksten.
• Met Vim of de sneltoetsen van je favoriete IDE kun je efficiënt werken.
• Controleer code van een AI-agent en leer die te verbeteren. Je blijft verantwoordelijk, ook als je de code niet zelf typt.

Waarom blind typen helpt bij programmeren

Het principe blijft hetzelfde: typen zonder naar het toetsenbord te kijken. Zo bespaar je tijd en richt je je op de taak in plaats van op het invoeren van tekens.

Voor programmeren moet je meer toetsen kennen dan voor een opstel. Een korte uitdrukking als items[index] += value; combineert letters, vierkante haken, een operator en een puntkomma. Daar komen accolades, ronde haken, aanhalingstekens en cijfers bij. Een typetest met woorden in kleine letters oefent die combinaties niet. Kijk je omlaag om een symbool te zoeken, dan lees je de code niet verder.

Als je een voorwaarde wijzigt, moet je ook de omringende code controleren. Met blind typen kun je die tijdens het invoeren blijven lezen. Na ruim 20 jaar softwareontwikkeling waardeer ik dat nog steeds, bij codewijzigingen, het toevoegen van tests en werk in de terminal.

Oefen de combinaties die je echt gebruikt

Voorwaarden, lussen en functiedeclaraties keren steeds terug. Een JavaScript-luskop zoals for (let i = 0; i < items.length; i++) bevat haakjes, puntkomma's, een vergelijking en een verhoging. Haper je ergens, oefen dan zulke uitdrukkingen. Het helpt als je de syntaxis van je taal vlot kunt typen.

Ook hoofdletters en naamgeving tellen mee. userAccount en user_account vragen andere vingerbewegingen en gewoonten. De Python-stijlgids adviseert kleine letters en underscores tussen woorden voor functies en variabelen: snake_case. Java-variabelen gebruiken meestal camelCase, zoals userAccount. Klassen en constanten hebben eigen regels. Leer die schrijfwijzen allemaal soepel te gebruiken.

Dat vraagt om verschillende oefeningen: in Python-namen komen meer underscores voor, in Java-namen meer hoofdletters midden in een naam. Wil je Python programmeren, kies dan liever Python-oefeningen dan Java-oefeningen.

Probeer tijdens het overtypen te begrijpen wat de code doet en hoe die is opgebouwd. Kijk waar de voorwaarde eindigt en het blok begint. In Python groepeert inspringing de instructies; een wijziging kan het gedrag veranderen. Typ code bewust over, niet gedachteloos.

Cijfers en speciale tekens oefenen

De gewone typcursus van AgileFingers bevat cijfers en speciale tekens. Ga naar die lessen als een cijfer, symbool of combinatie je ophoudt. Beheers je gewone tekst nog niet, begin daarmee voordat je code oefent. Gaan letters al goed, werk dan direct aan de benodigde toetsen. Ook na jaren programmeren moet je sommige combinaties misschien nog zoeken.

De afbeelding toont de Amerikaanse QWERTY-indeling. Daar typ je accolades met Shift en de toetsen voor vierkante haken. Andere indelingen plaatsen symbolen elders en kunnen AltGr gebruiken. Kies voor de oefeningen dezelfde toetsenbordindeling als de actieve indeling van je besturingssysteem: daarvan hangen de beschikbare tekens af. Je kunt dit wijzigen in de instellingen.

Bedien je IDE met het toetsenbord

In JetBrains-IDE's en Visual Studio Code kun je bestanden zoeken, aanroepen volgen en symbolen hernoemen met het toetsenbord. Leer de sneltoetsen van je huidige editor. Wil je zonder muis bewerken, dan biedt een Vim-extensie deze en veel meer mogelijkheden.

Begin met handelingen die je dagelijks herhaalt:

• Bestanden en symbolen zoeken: open een bestand of spring naar een functie zonder de mappenboom door te lopen.
• Naar de definitie en terug: volg een aanroep naar de implementatie en keer daarna terug.
• Een symbool hernoemen: gebruik de editorfunctie als die je taal ondersteunt. Controleer de voorvertoning en betrokken verwijzingen.
• Een gerichte test uitvoeren: herhaal de relevante test en ga via het toetsenbord naar de gemelde fout.
• Selecteren en bewerken: leer per woord bewegen, selecties uitbreiden, regels uitcommentariëren en wisselen tussen editor en terminal.

Leer eerst acties zoeken, zodat je opdrachten zonder menu's vindt. In de standaardtoetsindelingen van JetBrains opent tweemaal Shift de functie Search Everywhere. De JetBrains-handleiding voor sneltoetsen behandelt navigatie en toetsinstellingen.

In VS Code open je het opdrachtenpalet gewoonlijk met Ctrl+Shift+P op Windows en Linux, of Cmd+Shift+P op macOS. Met de sneltoetseditor zoek je opdrachten en pas je combinaties aan. Werkt iets anders, controleer dan de actieve indeling. Verander een standaardcombinatie niet te snel: die is meestal zorgvuldig gekozen.

Gebruik aanvulling voor lange namen en snippets voor terugkerende code. VS Code IntelliSense biedt bijvoorbeeld aanvulling en parameterinformatie. In een typoefening voer je het hele fragment zelf in. Gebruik in je project wel de hulp, maar controleer wat de editor invoegt. Herhaal je dezelfde klikken, zoek dan de sneltoets en probeer die bij je volgende taak.

Leer goed werken in de terminal

Ontwikkelaars en systeembeheerders gebruiken terminals voor opdrachten, tests, logboeken, bestandsbeheer en werk op externe systemen. Opdrachten mengen namen, paden, opties, aanhalingstekens, pipes en cijfers. Lees je invoer voordat je die uitvoert. Met blind typen kun je tijdens het invoeren en aanpassen naar de opdracht blijven kijken.

Leer de bewerkingsfuncties van je shell. Bij de standaard Readline-toetsen van Bash in Emacs-stijl gaat Ctrl+A naar het regelbegin en Ctrl+E naar het einde. Ctrl+R zoekt achteruit in de geschiedenis. Tab probeert bijvoorbeeld een opdracht of bestandsnaam aan te vullen. Het Readline-gedeelte van de Bash-handleiding legt dit uit. Andere shells en eigen toetsinstellingen kunnen afwijken.

Geschiedenis en aanvulling besparen opnieuw typen. Is één argument verkeerd, verplaats de cursor ernaartoe en herstel het; de hele opdracht hoeft niet opnieuw. Controleer voor Enter het pad, de opties en de werkmap. Kijk op een extern systeem ook welke shell je gebruikt: de bediening kan anders zijn dan lokaal.

Meet nauwkeurigheid en snelheid

Volg je tempo, maar let ook op fouten. Een symbool dat je steeds herstelt, verdient oefening, ook met een goede totaalscore. De editor herkent misschien een verkeerd gespelde naam, maar geen geldige operator die iets anders doet dan bedoeld. Blijf code controleren en testen.

Begin langzaam genoeg om nauwkeurig te typen. Versnel als je zeker typt, weinig fouten maakt en die meteen opmerkt en herstelt. Vergelijk resultaten met dezelfde oefening, indeling, oefenlimiet en nauwkeurigheidsmethode. Een moeilijker fragment kan de score verlagen terwijl je vooruitgaat. De cursus begint eenvoudig; latere combinaties worden ingewikkelder. Het kan lijken alsof je snelheid verliest, terwijl de oefening alleen moeilijker is geworden.

AgileFingers toont woorden of tekens per minuut. De omrekening rekent vijf tekens als één woord; een lange identifier telt dus niet als slechts één woord. Nauwkeurigheid bij de eerste poging blijft een fout meetellen nadat je die herstelt. Nauwkeurigheid van de definitieve tekst beoordeelt wat in de oefening overblijft. Let bij vergelijken op de gekozen methode, want de uitkomsten kunnen verschillen. Kies wat bij je doel past.

AgileFingers-oefeningen voor programmeurs

De vrolijke kleuren, afbeeldingen en eenvoudige bediening kunnen de indruk wekken dat AgileFingers alleen voor beginners, docenten en leerlingen is. Het werkt goed op scholen, maar is gemaakt door professionele ontwikkelaars met een passie voor informatica. We wilden het ook bruikbaar maken voor zeer ervaren vakmensen. Daarom zijn er literaire teksten om complexe passages te oefenen, naast eenvoudige woorden en abstracte toetscombinaties, en lessen in meerdere programmeertalen. Er zijn ook retrothema's en een donkere kleurstelling. Die zijn rustiger; vind je de lichte interface vermoeiend voor je ogen, probeer dan welke weergave prettiger werkt.

De programmeerlessen bevatten Python, JavaScript, Java en andere talen. Kies een taal en typ de getoonde code. Het toetsenbord en de vingerhulpen laten zien welke toetsen je nodig hebt. Na elke oefening krijg je je snelheid en nauwkeurigheid te zien.

Oefen met je eigen code

Je kunt eigen code gebruiken bij aangepaste teksten in AgileFingers. Plak een kort fragment dat je wilt oefenen, geef het een titel en sla het op. Kies het daarna uit je eigen catalogus. Denk aan een functie met geneste voorwaarden, een SQL-query met joins of een Bash-argumentparser. Neem code die je begrijpt, zodat je je op het typen kunt richten.

Heb je moeite met underscores en cijfers, kies dan namen waarin die voorkomen. Maak je fouten met aanhalingstekens en haakjes, neem een fragment met veel van die tekens. Controleer de weergave vooraf, vooral bij tabs of tekens buiten je indeling. Je kunt ook technische uitleg en instructies voor een AI-agent oefenen.

AI-agenten hebben duidelijke instructies en controle nodig

Een agent kan code genereren, controles uitvoeren en zijn werk aanpassen. Jij moet uitleggen wat je wilt en de wijzigingen nakijken. De GitHub-richtlijnen voor programmeeragenten adviseren duidelijke taken, menselijke beoordeling en tests van gegenereerde code.

Ook als je weinig code typt, beschrijf je eisen, geef je voorbeelden, meld je fouten en bespreek je resultaten. "Maak het formulier beter" laat een agent raden. Vertel welke invoer faalt, wat de gebruiker moet zien en wat moet blijven werken. Pas instructies aan als eisen veranderen of de agent ze verkeerd begrijpt. Bruikbare details vergroten de kans op een passende oplossing. Misschien typ je met agenten zelfs meer dan wanneer je zelf programmeert. In code denk je over elk teken na en houd je het beknopt, leesbaar en onderhoudbaar. In instructies probeer je alles duidelijk uit te leggen, zonder zo op woorden te besparen. Het is ergens grappig: als AI code schrijft, kan blind typen nog nuttiger worden.

Sommigen denken dat typen bijna voorbij is, omdat je instructies kunt dicteren. Dicteren helpt bij een eerste versie, maar bewerken kost nog werk: een pad herstellen, een variabelenaam aanpassen of één voorwaarde uit een lange instructie halen. Werkt dicteren prettig, gebruik het dan. Zelf zou ik met het toetsenbord blijven oefenen om kleine wijzigingen zelf te kunnen doen. Je wilt ook niet de hele werkdag tegen een microfoon praten. Zelfs een uitgesproken extravert persoon die met alles en iedereen praat, inclusief computers, moet de stem rust gunnen. Soms wil je stil werken. Daar is je vertrouwde toetsenbord voor.

Ik zou geen prettig gevoel hebben bij een product waarvan ik het gedrag niet kan uitleggen. Een zelfverzekerd antwoord bewijst niet dat een machtigingscontrole klopt of dat randgevallen zijn afgedekt. Als het jouw product is, ben jij verantwoordelijk voor die beslissingen. Leer genoeg om problemen te herkennen en de oplossing uit te leggen. Een taal leren vraagt veel eigen code. Wil je alleen de syntaxis beter begrijpen zonder zelf programma's te bouwen, dan kunnen de AgileFingers-lessen helpen.

Wil je een uitstekende programmeur worden, blijf dan code lezen en zelf aanpassen. Agenten mogen helpen, maar beoordeel hun werk zorgvuldig en denk kritisch over hun voorstellen. De programmeerlessen van AgileFingers helpen met de tekens en patronen die je moeilijk vindt.

Eenvoudig bewerken in Vim en Neovim

Vim is een teksteditor met toetsenbordopdrachten om door bestanden te bewegen en met enkele aanslagen zonder muis wijzigingen te maken. Neovim bouwt daarop voort en behoudt hetzelfde bewerkingsmodel. Beide hebben aparte modi voor invoer en bewerking. In normale modus verwijdert dd de huidige regel; ciw wijzigt het woord onder de cursor en opent invoegmodus om een vervanging te typen. De officiële Neovim-documentatie behandelt bewegen, bewerken en meer.

Leer de opdrachten in de editor, waar je het effect ziet. In sommige Neovim-distributies open je met Escape, :Tutor en Enter de interactieve handleiding. Is die uitgeschakeld, start dan nvim --clean in de terminal en probeer opnieuw. Dit laadt de standaardconfiguratie van Neovim. Volg voor Vim de vimtutor-instructies voor je systeem.

Doorloop een klein deel en herhaal het zonder instructies. Open daarna een kopie van een bekend bestand en vervang met dezelfde opdrachten een naam of verwijder een regel. Leer eerst enkele veelgebruikte bewerkingen voordat je lange lijsten uit je hoofd leert.

IDE-functies in Neovim

Neovim ondersteunt plugins voor zoeken, navigatie, aanvulling, diagnostiek en opmaak. Configureer ze zelf of gebruik een distributie met voorbereide instellingen en plugins. LazyVim is zo'n pakket. Het biedt veel vertrouwde IDE-functies, maar je hebt nog de passende hulpmiddelen voor je taal nodig. De sneltoetsgids en het which-key-venster helpen opdrachten te vinden.

Je kunt ook een Vim-plugin in je huidige IDE gebruiken. Controleer welke sneltoetsen door de plugin en welke door de IDE worden afgehandeld, vooral bij onverwacht gedrag. Begin met enkele vaak gebruikte opdrachten.

Een kort oefenplan

Kies iets dat je vandaag ophield: een gezocht symbool, een steeds verkeerd getypte naam of een onvindbare editoropdracht. Begin daarmee bij je volgende oefening:

1. Kies een cursusles voor het cijfer of speciale teken dat je wilt oefenen.
2. Typ een programmeerles of eigen tekst waarin het teken in code voorkomt.
3. Controleer het resultaat en herhaal de foutieve passage langzaam genoeg om het goed te doen.
4. Ga terug naar je editor of shell in de terminal en gebruik het geleerde in echte code of een opdracht.

Oefen ook gewone tekst. Commentaar, documentatie en AI-instructies zijn onderdeel van het werk. Gebruik literatuur uit de AgileFingers-teksten of schrijf je eigen technische aantekeningen over. Wil je ontspannen en toch leren, probeer dan de typespellen.

Vragen van programmeurs

Deze vragen komen terug in Reddit-discussies over blind typen tijdens IT-werk.

Waarom typ ik woorden snel, maar code langzaam?

Misschien ken je de letters goed, maar haper je bij haakjes, aanhalingstekens, cijfers of hoofdletters. Onbekende syntaxis vertraagt ook. Kies korte code die je begrijpt en oefen de lastige combinaties. Vergelijk pogingen met hetzelfde fragment. De programmeerlessen van AgileFingers helpen zo aan vertrouwdheid met code typen.

Moet ik eerst blind leren typen en dan programmeren?

Je kunt beide tegelijk leren. Blijf programma's bouwen en oefen tussendoor de toetsen die je nog zoekt. Voor een eerste project heb je geen hoge typesnelheid nodig. Werk je al als programmeur, pas dezelfde oefening dan in je gewone werkdag in.

Moet ik van toetsenbordindeling wisselen voor code?

Begin met de indeling op je werk, zeker als je die ook voor je eigen taal nodig hebt. Oefen symbolen voordat je wisselt. Een andere indeling kan prettig zijn, maar houd rekening met thuis en werk. Wisselen is lastig als je thuis een sterk aangepast programmeertoetsenbord gebruikt en op kantoor een standaardmodel met andere toewijzingen.

Kies toewijzingen die bij je passen en controleer of je ze op beide computers kunt gebruiken. Houd veelgebruikte letters, symbolen en sneltoetsen waar mogelijk gelijk, zodat je ze niet steeds opnieuw leert. Kan je werkplek niet aansluiten op thuis, behoud dan ook de vaardigheid met de standaardindeling. Leer nieuwe posities voordat je er op een drukke dag afhankelijk van bent.

Probeer het bij je volgende programmeersessie

Let bij het bewerken van code of invoeren van een opdracht op de toetsen waarvoor je nog stopt en omlaag kijkt. Oefen ze in de programmeerlessen of voeg een fragment toe aan je eigen teksten. Blijf editor en AI gebruiken, maar lees, controleer en verbeter hun uitvoer. Ook als de huidige IT-sector en recente veranderingen je tegenstaan, kun je veel daarvan nauwelijks beïnvloeden. Als ervaren ontwikkelaar raad ik aan sommige veranderingen voor je eigen welzijn te aanvaarden en je aan te passen. Laat daarom niet alles aan AI over. Schrijf ten minste een deel zelf, zodat je in een taal kunt blijven creëren en die niet alleen leest. Gebruik je toetsenbord: het is een fysiek, tastbaar communicatiemiddel. Tussen digitale producten blijft het iets echts. We hebben dingen nodig die we kunnen aanraken en gebruiken en die ons met de tastbare wereld verbonden houden.