Uitdagende puzzels en nieuwe Java-features: Leren door te doen

Softwareontwikkeling is een continu leerproces. Nieuwe technologieën volgen elkaar in rap tempo op en het bijhouden van je kennis is essentieel. Maar hoe zorg je ervoor dat je nieuwe features écht onder de knie krijgt? Programmeerpuzzels en code-uitdagingen zijn een slimme manier om te experimenteren met de nieuwste ontwikkelingen. Een bekend voorbeeld is de Advent of Code, een jaarlijkse challenge in december. Maar waarom wachten tot het einde van het jaar? Ook in maart – of welke maand dan ook – kun je je programmeervaardigheden aanscherpen met uitdagende puzzels en nieuwe technologieën verkennen.

Leren door te doen

Advent of Code is een jaarlijks terugkerend evenement, opgezet door Eric Wastl, waarin deelnemers tussen 1 en 25 december elke dag twee nieuwe programmeerpuzzels krijgen. De puzzels worden vaak gepresenteerd in een kerstthema, zoals het helpen van de kerstman met logistieke problemen of het ontcijferen van mysterieuze codes. Hoewel iedereen de uitdagingen individueel kan oplossen, is er ook een competitief element: er zijn leaderboards en ontwikkelaars kunnen lokaal of wereldwijd tegen elkaar strijden.

Voor veel ontwikkelaars zijn programmeerpuzzels meer dan alleen een leuke bezigheid. Ze vormen een kans om nieuwe technieken en programmeertalen te testen in een veilige, speelse omgeving. Zo gebruik ik bijvoorbeeld deze uitdagingen om hands-on ervaring op te doen met de nieuwste features van Java 23 en deze te vergelijken met oudere versies zoals Java 11. Dit leverde waardevolle inzichten op over hoe moderne Java-features code kunnen vereenvoudigen en optimaliseren. In dit artikel deel ik graag de inzichten die ik heb opgedaan.

Deze nieuwe Java features maken het verschil

Tijdens het puzzelen in Advent of Code heb ik de volgende vernieuwingen toegepast:

1. Unnamed Classes and Instance Main Methods – Ideaal voor kleine projectjes of puzzels, omdat er minder “boilerplate” code nodig is. In samenwerking met de mogelijkheid tot het uitvoeren zonder expliciet te compileren, kan Java makkelijker als een scripttaal gebruikt worden.
2. Window Functions en Gatherers – Een nieuwe manier om gegevens in een stroom te verwerken, handig voor bijvoorbeeld padberekeningen in complexe puzzels.
3. Sealed Interfaces – Dit zorgt ervoor dat je precies kunt aangeven welke klassen een bepaalde interface mogen implementeren. Dit voorkomt onverwachte uitbreidingen en maakt codebeheer overzichtelijker. Het stelt je ook in staat sum types te introduceren binnen de objectgeoriënteerde wereld van Java.
4. Pattern Matching in Switch Statements – Dit biedt een elegantere manier om over verschillende objecttypen te switchen zonder expliciete instance of-checks.

Een concreet voorbeeld waar ik één van deze features gebruikte, was een puzzel waarbij een robot een keypad moest bedienen via een tussenliggende afstandsbediening. Met Sliding Windows in Streams kon ik eenvoudig de paden tussen de verschillende tussenstations bepalen, iets wat in oudere versies van Java omslachtiger zou zijn geweest.

Hier is een voorbeeldcode die ik heb gebruikt, waarbij je profiteert van de kortere syntax van Unnamed Classes and Instance Main Methods:

void main() throws IOException {
      
      var lines = Files.lines(Path.of("input.txt")).toList();
      int[] left = new int[10_000];
      int[] right = new int[10_000];
      for(int i = 0; i < lines.size(); i++){
            var strs = lines.get(i).split("\\s+");
            println("strs[0]" + strs[0]);
            println("strs[1]" + strs[1]);
            left[i] = Integer.parseInt(strs[0]);
            right[i] = Integer.parseInt(strs[1]);
      }
 
      Arrays.sort(left);
      Arrays.sort(right);
 
      int total = 0;
      for(int i = 0; i < 10_000; i++){
            total += Math.abs(left[i] - right[i]);
      }
      println(total);
}

En hoe dit er in een oudere Java-versie uit zou zien met meer boilerplate-code:

package p1;
 
import java.util.*;
import java.nio.file.*;
import java.io.*;
 
class Main{
public static void main(String... args) throws IOException {
      
      var lines = Files.lines(Path.of("input.txt")).toList();
      int[] left = new int[10_000];
      int[] right = new int[10_000];
      for(int i = 0; i < lines.size(); i++){
            var strs = lines.get(i).split("\\s+");
            System.out.println("strs[0]" + strs[0]);
            System.out.println("strs[1]" + strs[1]);
            left[i] = Integer.parseInt(strs[0]);
            right[i] = Integer.parseInt(strs[1]);
      }
 
      Arrays.sort(left);
      Arrays.sort(right);
 
      int total = 0;
      for(int i = 0; i < 10_000; i++){
            total += Math.abs(left[i] - right[i]);
      }
      System.out.println(total);
}
}

Meer dan alleen puzzels oplossen

Wat Advent of Code extra leuk maakt, is de sociale interactie. Ik doe het samen met vrienden, waardoor we elkaars aanpak kunnen bespreken en van elkaar kunnen leren. Dit maakt het niet alleen leerzaam, maar ook leuk en interactief. Voor bedrijven of teams biedt dit bovendien de kans om een interne competitie op te zetten, bijvoorbeeld met een leaderboard voor de snelste of meest efficiënte oplossingen.

Programmeerpuzzels als Advent of Code zijn niet alleen geschikt voor individuen, maar kunnen ook als interne challenge worden ingezet. Teams kunnen samenwerken, strategieën delen en nieuwe technologieën verkennen. Bovendien is het een laagdrempelige manier om nieuwe frameworks of programmeertalen te testen. Een competitie met een interne leaderboard kan net dat beetje extra motivatie geven.

Doe jij dit jaar ook mee?

Waarom wachten tot december? Code-uitdagingen zijn het hele jaar door beschikbaar en bieden een leuke manier om nieuwe technologieën te leren. Ik zit in elk geval klaar om Java 24 uit te testen. Dus of je nu als Java-ontwikkelaar aan de slag wilt met de nieuwste features, als team een interne competitie wilt starten, of gewoon een nieuwe uitdaging zoekt; dit is hét moment om in te stappen!