Scala Advanced Developer
Leer in drie intensieve dagen functioneel programmeren in Scala 3 onder de knie te krijgen. De leidende principes zijn daarbij ‘lokaal redeneren’ — het vermogen om elk stukje code te begrijpen zonder de rest van het systeem te kennen — en ‘compositie’ — het bouwen van grotere systemen uit kleine, goed getypeerde onderdelen die op voorspelbare wijze samengaan. Maak een reis van algebraïsche datatypes en het Cats-ecosysteem via concurrente en streamingtoepassingen met Cats Effect en FS2, naar event-sourced systemen met Pekko, waarbij je alles samenbrengt in een productie-klaar afstudeerproject. Gebaseerd op ‘Training from the Back of the Room’ (TBR)-technieken combineert elke sessie interactieve lezingen met REPL-gestuurde live-codering, praktische oefeningen en quizonderdelen. En in het tijdperk van AI zijn dit de vaardigheden waarmee je gegenereerde code met vertrouwen kunt controleren en verifiëren.
Heb je een vraag over de training?
Stel deze aan Melchior! Hij helpt je graag met het vinden van de juiste oplossing voor jou, jouw team of organisatie.
Neem contact opWat ga je leren?
Je leert hoe je op een puur functionele manier kunt denken en ontwerpen met behulp van Scala 3. Beginnend bij algebraïsche datatypes en patroonherkenning bouw je dit op naar geavanceerde typeklassen, monadische compositie en higher-kinded types — waardoor je de tools in handen krijgt om code te schrijven waarin elke functie afzonderlijk begrepen kan worden en zonder verrassingen met andere functies kan worden gecombineerd.
Ontdek hoe Cats Effect de manier waarop u omgaat met bijwerkingen, gelijktijdigheid en het beheer van bronnen verandert. U leert programma’s te schrijven met behulp van de IO-monade, gebruik te maken van op fibers gebaseerde gelijktijdigheid voor grootschalige parallelliteit, en primitieven zoals Ref, Deferred en Queue te gebruiken om gelijktijdige workflows te coördineren — en dat alles zonder de valkuilen van traditionele, op threads gebaseerde programmering. Omdat IO referentieel transparant is, kan elke uitdrukking lokaal worden begrepen — waardoor gelijktijdige code net zo begrijpelijk wordt als sequentiële code.
Je leert de verwerking van streaminggegevens met FS2 en Pekko Streams onder de knie te krijgen en begrijpt wanneer je welke moet gebruiken. Van pull-gebaseerde ‘lazy’ pijplijnen tot reactieve streams met tegendruk: je leert robuuste gegevensverwerkingssystemen te bouwen die werkelijke werklasten aankunnen. Pipes en streamoperatoren kunnen net als functies worden samengesteld, waardoor je complexe verwerkingspijplijnen kunt bouwen uit kleine, testbare en herbruikbare stappen.
De training behandelt event sourcing en CQRS met Pekko Persistence, en leert je hoe je domeinentiteiten kunt modelleren als event-sourced actors, hoe je command- en event-handlers implementeert en hoe je read-side projecties bouwt. Je leert ook hoe je pure domeinlogica kunt scheiden van de infrastructuur — zodat command-handlers klein, lokaal testbaar en combineerbaar blijven naarmate het systeem groeit.
Ten slotte integreer je al deze tools in een gelaagde, productieklaar architectuur — die teststrategieën, configuratiebeheer, dependency injection, observability en implementatie omvat. Tagless final en Resource bieden je samenstelbare applicatielagen waarin elke component afzonderlijk kan worden begrepen. Het afstudeerproject biedt je de kans om alles wat je hebt geleerd toe te passen op een echt probleem. In een tijdperk waarin AI steeds meer code genereert, verschuift de nadruk van het schrijven van code naar het zelfverzekerd beoordelen en verifiëren ervan — lokale redenering en sterke typen zorgen ervoor dat door AI gegenereerde code betrouwbaar is.
Belangrijkste leerdoelen
- Pas twee basisprincipes toe — lokale redenering en compositie — die functionele Scala-code standaard leesbaar, testbaar en onderhoudbaar maken
- Leer het Cats-ecosysteem (Cats, Cats Effect, FS2) grondig kennen voor functioneel Scala van productiekwaliteit
- Ontwikkel gelijktijdige, op fibers gebaseerde applicaties die schaalbaar zijn zonder de complexiteit van threads
- Ontwerp en implementeer event-sourced systemen met CQRS met behulp van Pekko Persistence
- Ontwikkel streaming-datapijplijnen met zowel FS2 als Pekko Streams
- Pas geavanceerde functies van het typesysteem — typeklassen, monaden, types van hogere orde en contextuele abstracties — vol vertrouwen toe
- Rond je opleiding af met een praktijkgericht afstudeerproject waarin de concepten van alle drie de dagen tot uiting komen
Programma
Leg een stevige basis in puur functioneel Scala 3. Je leert alles over algebraïsche gegevenstypen, patroonherkenning en structurele recursie, waarna je verdergaat met functionele foutafhandeling met Option, Either en Validated. Ontdek het typeklassepatroon met behulp van contextuele abstracties in Scala 3, en werk met de belangrijkste Cats-typeklassen: Semigroup, Monoid, Functor, Applicative en Monad. De dag wordt afgesloten met geavanceerde monadische compositie: Reader-, Writer-, State- en Eval-monaden, monad-transformatoren (OptionT, EitherT), Traverse, Sequence en types van hogere orde (F[_]) — hiermee krijg je de tools in handen om code te schrijven waarbij elk onderdeel lokaal kan worden begrepen en zonder verrassingen kan worden samengesteld.
Voor wie is deze training?
Deze training is bedoeld voor elke ontwikkelaar of architect die:
- Scala schrijven dat lokaal gemakkelijk te begrijpen is en zich op een overzichtelijke manier laat samenstellen — van afzonderlijke functies tot een volledige systeemarchitectuur
- ga verder dan de basissyntaxis van Scala en verdiep je in geavanceerde functies van het typesysteem en het Cats-ecosysteem
- leer hoe je gelijktijdige, streaming- en event-based applicaties op functionele wijze bouwt
- de vaardigheden en werkwijzen verwerven die nodig zijn om leiding te geven aan een team dat functionele Scala-systemen ontwikkelt
- afstuderen met een afstudeerproject dat direct in je portfolio kan worden opgenomen en waarin je laat zien hoe functioneel programmeren in de praktijk wordt toegepast
Vereisten
Basiskennis van de Scala-syntaxis en -collecties, of ruime ervaring met een andere JVM-taal, zoals Java of Kotlin
Basisbegrippen van OOP
Bereidheid om tijd te investeren in voorbereidende leesopdrachten en oefeningen na de sessies, inclusief het stapsgewijs werken aan een afsluitend project
Je moet je eigen laptop meenemen.
Waarom zou ik deze training volgen?
Leer code te schrijven waarbij elk onderdeel afzonderlijk kan worden begrepen en op voorspelbare wijze kan worden samengevoegd
Beheers lokaal redeneren en structureren als basisprincipes — van zuivere functies tot volledige systeemarchitectuur — zodat je code standaard leesbaar, testbaar en onderhoudbaar is.
Leer het volledige Cats-ecosysteem en Pekko beheersen in één samenhangend programma
Van typeklassen tot gelijktijdige streaming tot event sourcing — Cats, Cats Effect, FS2 en Pekko worden van begin tot eind behandeld in één gestructureerde training.
Rond je opleiding af met een praktijkgericht afstudeerproject waarmee je je vaardigheden aantoont
Pas alles wat je hebt geleerd toe op een concreet probleem en neem een project mee dat klaar is voor je portfolio en waarin je laat zien dat je functioneel Scala op productieniveau beheerst.
Blijf onmisbaar in het tijdperk van AI
AI verplaatst het knelpunt van het schrijven van code naar het controleren en verifiëren ervan. Lokale redenering, compositie en een krachtig typesysteem zorgen ervoor dat door AI gegenereerde code controleerbaar en veilig is — de compiler vangt op wat een mens zou missen bij het vluchtig doorlezen van de AI-uitvoer.
Pragmatisch en functioneel Scala, geen ivoren-toren-theorie
Ben je bang dat functioneel programmeren te academisch is? Elk concept verdient zijn plaats door een echt probleem op te lossen — geen categorietheorie omwille van de categorietheorie zelf. Je leert net genoeg theorie om deze op een pragmatische manier toe te passen, en past deze vervolgens toe op praktijkgerichte zaken zoals testen, configuratie, observeerbaarheid en implementatie.
Leer van een ervaren professional
De cursus wordt gegeven door een trainer die al meer dan tien jaar ervaring heeft met het bouwen van uitgebreide, productieve JVM-backendsystemen en gecertificeerd is in ‘Training from the Back of the Room’ — je leert beproefde patronen van iemand die ze daadwerkelijk in de praktijk heeft toegepast.
Maak kennis met de trainer
Robert Thurnher
Robert is a seasoned software craftsman with roughly 20 years of experience building web, mobile, and backend systems. Full-stack with a strong backend focus, he brings deep expertise in the JVM ecosy
Wat moet je nog meer weten?
De training bestaat uit drie intensieve dagen waarbij gebruik wordt gemaakt van de ‘Training from the Back of the Room’ (TBR)-technieken. Elke sessie combineert interactieve lezingen met REPL-gestuurde live-codering, praktische oefeningen en quizonderdelen. Elke dag bouwt voort op de vorige, dus het is belangrijk om alle drie de dagen bij te wonen om het maximale uit het programma te halen.
Cursusinformatie
Hoofdleerboek: ‘Functional Programming Strategies in Scala with Cats’. Alle codevoorbeelden, oefeningen en oplossingen zijn beschikbaar in een speciale Git-repository.
Neem je eigen laptop mee waarop Java 21 of hoger en sbt zijn geïnstalleerd. Aanbevolen editors: VS Code met Metals, IntelliJ IDEA met de Scala-plug-in of Neovim.
Elke sessie omvat oefeningen en werk aan een afstudeerproject om de behandelde concepten tussen de lesdagen door te verankeren.
Tijdens de sessies wordt gebruikgemaakt van TBR-technieken: interactieve colleges, REPL-gestuurd live coderen, praktische oefeningen en quizonderdelen om de betrokkenheid en het leerbehoud te maximaliseren.