Java, mijn bread-and-butter, is voor mij de basis waarop een groot deel van mijn backend-ervaring is gebouwd. Ik gebruik het voor systemen waar betrouwbaarheid, duidelijke structuur en onderhoudbaarheid belangrijk zijn. Vooral binnen microservices en gedistribueerde systemen komt Java goed tot zijn recht, omdat het volwassen tooling combineert met een sterk ecosysteem.
In de praktijk draait Java voor mij niet om zoveel mogelijk frameworks of abstracties. Het draait om voorspelbare software bouwen die ook over een paar jaar nog te begrijpen en door te ontwikkelen is.
Wat is Java?
Java is een sterk getypeerde programmeertaal die veel wordt gebruikt voor backend-systemen, enterprise software en gedistribueerde applicaties.
Wat Java voor mij interessant maakt is vooral de volwassenheid van het platform. Je hebt een sterk type system, goede tooling, uitgebreide observability mogelijkheden en frameworks zoals Spring en Quarkus waarmee je verschillende soorten backend-systemen kunt bouwen.
Ik gebruik Java daarom vooral wanneer stabiliteit en controle belangrijker zijn dan experimenteren met de nieuwste technologie.
Wat vind ik belangrijk bij Java?
Houd het eenvoudig
Java geeft je veel mogelijkheden om code te abstraheren. Dat betekent niet dat je ze allemaal moet gebruiken.
Ik probeer domeinlogica zo direct mogelijk terug te laten komen in de code. Een goede Java-applicatie hoeft niet indrukwekkend ingewikkeld te zijn. Als een nieuwe developer snel begrijpt waar gedrag vandaan komt, is dat voor mij meestal een goed teken.
Structuur moet een doel hebben
Packages, interfaces, services en domeinmodellen moeten helpen om verantwoordelijkheden duidelijk te maken.
Ik probeer daarom niet automatisch iedere class achter een interface te verstoppen of iedere laag volgens een standaard template op te bouwen. Structuur is waardevol wanneer het complexiteit verlaagt, niet wanneer het alleen extra bestanden oplevert.
Denk verder dan de applicatie
Backend Engineering stopt niet bij het schrijven van Java-code.
Ik kijk ook naar zaken zoals:
Dataconsistentie
Event-driven communicatie
Failure handling
Performance
Monitoring
Deployment
Kosten
Onderhoudbaarheid
Juist de combinatie van code en architectuur bepaalt uiteindelijk hoe duurzaam een systeem wordt.
Hoe gebruik ik Java?
Mijn Java-werk bevindt zich voornamelijk binnen backend- en microservice-architecturen.
Daarbij gebruik ik Java onder andere voor:
REST API's
Microservices
Event-driven systemen
Kafka producers en consumers
Distributed workflows
Immediate en Eventual Consistency
Saga-patterns
Integraties met externe systemen
Cloud-native applicaties
Geautomatiseerde tests en CI/CD
Frameworks zoals Spring Boot en Quarkus gebruik ik daarbij als middel. De keuze voor een framework moet volgen uit wat het systeem nodig heeft en niet andersom.
Mijn achtergrond met Java heeft daarnaast veel invloed op hoe ik Kotlin schrijf. De JVM, concurrency, architectuurprincipes en het ecosysteem blijven grotendeels hetzelfde, ook wanneer de taal verandert.
Waar heb ik Java gebruikt?
Java loopt als rode draad door een groot deel van mijn loopbaan.
Recent heb ik Java en JVM-technologie toegepast bij onder andere ANWB, Port of Amsterdam en Sogeti. Mijn CV beschrijft Java als mijn specialiteit binnen microservice-architecturen en noemt meerdere recente opdrachten waarin Java gecombineerd werd met onder andere Kotlin, Spring, Quarkus, Kafka, MongoDB en Docker.
ANWB
Bij ANWB werk ik binnen het Car Platform aan backend-systemen rondom voertuiginformatie en mobiliteitsdiensten.
Hoewel daar veel Kotlin met Spring wordt gebruikt, is mijn Java-achtergrond nog steeds sterk aanwezig in de architectuur, JVM-kennis, software patterns en keuzes rondom distributed systems. Binnen dit platform heb ik onder andere gewerkt aan de omslag richting een event-driven architectuur, asynchrone verwerking en Redis Streams.
Port of Amsterdam
Bij Port of Amsterdam werkte ik als Senior Lead Java Backend Developer aan verschillende bedrijfskritische applicaties voor havenoperaties.
Daar lag de nadruk niet alleen op nieuwe functionaliteit, maar juist ook op betrouwbaarheid, onderhoudbaarheid en verantwoord doorontwikkelen van bestaande software.
Sogeti
Bij Sogeti heb ik Java 17 en Quarkus gebruikt om verschillende microservice-architecturen te onderzoeken en te implementeren.
Daar heb ik onder andere Immediate Consistency via REST vergeleken met Eventual Consistency via Kafka. Binnen de event-driven variant gebruikte ik het Saga-pattern om transacties over verschillende services te coördineren.
Mijn ervaring met Java
Java is nog steeds een van de technologieën waarin ik mij het meest thuis voel.
Mijn recente werk verschuift steeds meer richting een combinatie van Java en Kotlin, maar de principes die ik vanuit Java heb opgebouwd blijven de basis: sterke domeinmodellen, duidelijke verantwoordelijkheden, gecontroleerde concurrency en systemen ontwerpen die ook bij fouten voorspelbaar blijven functioneren.
Ik probeer daarbij bewust niet alleen naar de code van vandaag te kijken.
Een oplossing moet ook logisch blijven wanneer het team groeit, requirements veranderen, meer services worden toegevoegd of het systeem een veel hogere belasting krijgt.
Dat is voor mij uiteindelijk het verschil tussen Java schrijven en Backend Engineering doen.
Veelgestelde vragen die ik krijg over Java
Waarom gebruik je nog Java als Kotlin bestaat?
Omdat Java nog steeds een ontzettend sterk platform en ecosysteem heeft. Kotlin lost bepaalde tekortkomingen van Java elegant op, maar dat maakt Java niet ineens minder geschikt. Ik kies liever per situatie dan vanuit voorkeur voor één taal.
Spring of Quarkus?
Ik heb met beide uitgebreid gewerkt. Spring is enorm volwassen en heeft een breed ecosysteem. Quarkus vind ik interessant voor compacte cloud-native en microservice-omgevingen. De architectuur en het team wegen voor mij zwaarder dan het framework.
Gebruik je altijd microservices met Java?
Nee. Microservices zijn geen doel op zichzelf. Als een modulair systeem eenvoudiger kan blijven als monoliet, dan is dat soms gewoon de betere keuze.
Is Java niet te verbose?
Soms wel. Dat is ook een van de redenen waarom ik graag met Kotlin werk. Tegelijkertijd kan expliciete code juist waardevol zijn wanneer systemen groter worden. Het probleem is meestal niet Java zelf, maar hoeveel onnodige complexiteit je ermee introduceert.
Waar ligt voor jou de kracht van Java?
Voorspelbaarheid. Java combineert sterke tooling, een volwassen ecosysteem en goede performance met code die jarenlang onderhoudbaar kan blijven. Zeker bij bedrijfskritische backend-systemen vind ik dat belangrijk.