Van Java naar Python,

Meer dan enkel puntkomma's.

Recentelijk heb ik een kleine sprong in het diepe genomen, en een redelijke grote aanpassing gedaan in mijn leven. Als 100% Java ontwikkelaar heb ik de overstap gemaakt naar Python. Enerzijds omdat Python een taal is die toch wel veel tractie heeft gekregen, anderzijds omdat er een leuke werkaanbieding aan vast hing (je mag één keer raden waar). Nu ga ik niet ontkennen dat ik ooit al wel eens met Python gespeeld heb. Uiteraard heeft bijna elke developer zo wel eens een momentje dat ze het onbekende willen ontdekken, zeker na er zoveel lof over te horen. “Go is een taal speciaal gemaakt door google developers om sneller te kunnen programmeren”, “Kotlin is gewoon Java, maar verbeterd en 100% compatible” en dan de bekendste “AI is zo widespread aan het worden, iedereen kan m.b.v. Python er mee beginnen”. Die laatste zin, was de zin die mij uiteindelijk aansprak en ervoor zorgde dat ik begonnen ben met Python en AI. Uiteindelijk na het uitvoerig volgen van een online gids, heb ik een Python neural net kunnen trainen om macaroni te herkennen.Niet direct de meest nuttige toepassing van AI, maar het is wel direct een tastbaar resultaat en viel mee qua complexiteit dankzij de hulp van Tensorflow. Maar dit is volledig terzijde van de Python code die ik vandaag de dag schrijf. Nu is het volledig in het Django framework. Django is waarschijnlijk wel het populairste web framework uit de lijst, alhoewel Flask ook enorme populariteit kent. Omdat mijn ervaring binnen Java nu toevallig ook “webapplicaties maken m.b.v. een framework” is, dacht ik dat de overstap redelijk simpel zou zijn. Al bij al is het inderdaad geen grote overstap qua mindset, het zijn tevens beide OO-talen. Toch zijn er enkele verschillen.

Ondergedompeld in de wereld van Django

De eerste indruk die ik had van Django was direct wel leuk. In plaats van zelf scriptjes in Liquibase te voorzien, werden alle aanpassingen aan de entiteiten omgezet in gegenereerde scripts. Versiebeheer van de database was een eitje. En het was een opluchting om aan multiple inheritance te kunnen doen. Al vaak gehad dat we een abstract klasse bij moesten maken om multiple inheritance na te bootsen. Ook niet meer dat je voor elke entiteit een interface maakt. Interfaces zijn niet meer nodig, hoera! Dat was uiteraard slechts de eerste indruk.. Al snel merkte ik dat ik vele reflexes uit de Java wereld niet direct kon toepassen in mijn Django project. De “app” layout die Django toepast, was niet iets dat ik gewend was.

De entiteiten werden samen gezet in 1 gezamelijke models file. In Java is mijn eerste reflex om zoveel mogelijk dingen op te splitsen in verschillende bestanden. Het hebben van die duidelijke opsplitsing van alles leidde dikwijls tot good practices toe te passen qua ordelijkheid. Bij mezelf merk ik ook dat het één van de factoren is dat het principe van “high cohesion” en “low coupling” makkelijker maakte. Het is natuurlijk ook mogelijk om sterker op te splitsen binnen Django, maar ik voel toch aan dat dit niet direct de eerste reflex is.

Nu is het uiteraard vanzelfsprekend dat je nadenkt voor je programmeert. Zo denk je vaak na over wat je entiteiten moeten hebben van gegevens, welke dingen je kan samen gooien onder eenzelfde parent en rekening houden met mogelijke veranderingen.

Achteraf gezien was dat nadenken héél makkelijk in Java: Maak een interface die semantisch klopt met welke “echt” object je wil, en zorg ervoor dat de gepaste entiteiten die implementeren.

Het feit dat ik die interfaces niet direct had binnen Python, zorgde ervoor dat ik toch wel soms wat foute keuzes heb gemaakt in mijn data model. Niet gedacht dat ik het ging zeggen, maar ik mis Interfaces.

Import all the things

Natuurlijk is er voor alles een oplossing. In Python begint die oplossing meestal met “from … import …”. Er is een overvloed aan packages beschikbaar om alle problemen op te lossen. Zo had ik het  probleem dat polymorfisme niet werkte zoals ik had gehoopt. Als ik vraag om alle Dier objecten op te halen, haal ik inderdaad zowel mijn Kat objecten als mijn Hond objecten op. Maar op de moment dat ik vraag “maak geluid” hoor ik geen meow of blaf, enkel het Dier geluid.

Dit was héél simpel op te lossen, door django-polymorphic te importeren.  Boem, klaar, probleem opgelost. Ik mis interfaces? Er is iemand die interfaces beschikbaar heeft gemaakt in python. PIP is net zo makkelijk te gebruiken als Maven of Gradle, om niet te zeggen makkelijker. 

Uiteindelijk blijft het een beetje aanpassen, maar de grootste uitdaging blijft meestal toch bij het oplossen van de vraag “Hoe wil ik dat dit werkt?”. Onafhankelijk van welke taal je gebruikt, blijft dat de grootste tegenstander van elke developer.