NL-JUG University Session: Development Frameworks

Gisteravond was de eerste NL-JUG University Session. Ruim 50 developers hadden zich verzameld in Driebergen waar Martin Percival (BEA Systems) en Alef Arendsen (Interface21) hun licht lieten schijnen over het thema ‘Development Frameworks’. Martin vertelde over Apache Beehive en Alef behandelde het Spring Framework. Zoals we inmiddels gewend zijn van de NL-JUG, was ook dit weer een goed georganiseerd evenement. Enige minpuntje was eigenlijk dat het erg warm was in de ruimte waar de presentaties werden gegeven. Met dit weer is een ruimte met airco eigenlijk wel een vereiste. Zeker als je mensen na een dag hard werken en een maaltijd toe moet spreken moet je toch al alles uit de kast halen om deze ‘graveyard shift’ te volbrengen en dan helpt de warmte zeker niet mee. Desalniettemin was het zeker een informatieve avond. De prijs voor de scherpste opmerking van de avond gaat wat mij betreft naar Martin Percival. Vrij vertaald: “waarom willen jullie (developers) toch altijd frameworks bouwen, misschien is het een goed idee om af en toe ook eens een applicatie te bouwen ofzo…” De spijker op zijn kop.

Wat persoonlijke ‘notes’…

Met Beehive laat BEA weer eens zien dat ze naast eigen innovatie ook standaardisatie en open source belangrijk vinden. De drie onderdelen van het
framework: controls, page flows en web services zijn stuk voor stuk nuttige onderdelen die het bouwen van een applicatie met Weblogic Workshop kunnen veraangenamen en middels Beehive nu ook beschikbaar zijn voor niet-BEA containers zoals bijvoorbeeld Tomcat, of een andere container. Ook ben je niet langer aan Weblogic Workshop gebonden, want via de Pollinate plugin is Beehive ook goed te gebruiken vanuit Eclipse.

Controls zijn een abstractie, waarvoor de gemiddelde ontwikkelaar zelf waarschijnlijk al proxies of een delegate  achtig iets zou hebben gemaakt. Page flows zijn een uitbreiding op Struts, die voorzien in een mogelijke oplossing voor enkele van de beperkingen en scherpe kantjes van Struts. Op het gebied van web services biedt Beehive een set aan annotations waarmee op een gemakkelijke manier web services gegenereerd kunnen worden. Hoewel annotations op zichzelf een nuttige taalfeature zijn, is de manier waarop sommige frameworks deze gebruiken wel enigzins weerzinwekkend en Beehive heeft daar ook een beetje een handje van. Als voorbeeld: een Java interface met boven een methode declaratie een annotation waarin de implementatie (select * from products where id={pid}) van die methode staat, is volgens mij niet waar interfaces voor bedoeld zijn. Was er niet iets met scheiding tussen interface en implementatie? Het gebruik van annotations voor configuratie blijf ik sowieso een slechte zaak vinden. Configuratie hoort niet tussen source code thuis. Hadden we hier geen deployment descriptors, preferences en property files voor uitgevonden?

Beehive is zeker het bekijken waard en wellicht zijn de onderdelen uit het framework of in ieder geval de ideeen  erachter bruikbaar in de eerstvolgende applicatie die je gaat bouwen. Kleine kanttekening is wat mij betreft dat het voor sommige technologie beter zou zijn als men toch het geduld voor de soms trage standaardisatie zou kunnen opbrengen. In de tussentijd is de technologie dan misschien slecht bruikbaar, maar het voorkomt in ieder geval dat de versie 2 producten een stevige rewrite zullen zijn van het versie 1 product.

Spring zat ik persoonlijk al een tijdje tegenaan te hikken. Het geniet weliswaar veel populariteit als je sommige bronnen op het internet moet geloven, maar het had mij tot op heden nog niet weten te imponeren. Ik had het al eens de ’10 minute testdrive’ gegeven, maar nog niet echt de tijd gehad om er stevig mee aan de gang te gaan. De presentatie van Alef en de opmerkingen en vragen uit de zaal hebben me in ieder geval gesterkt in het gevoel dat het framework best aardig in elkaar steekt en dat je er zeker een serieuze applicatie mee zult kunnen bouwen, maar dat het wederom geen silver bullet is. Het is slechts een van de vele aanpakken die je vandaag de dag kunt kiezen. Het geknutsel met XML files en het aan elkaar knopen van stukken applicatie middels Inversion of Control klinkt allemaal simpel en aardig, maar ook hier geldt weer…waar zijn de tools? Wie bewaakt de consistentie tussen XML files en Java code? Een paar halfbakken Eclipse plugins zijn onvoldoende.

Feitelijk het grootste bezwaar dat ik tegen beide frameworks (Beehive en Spring) heb, is dat alles onder het kopje ‘ease of development’ wordt geschoven. Productiviteit verhogen is goed…niets mis mee, maar waarom zou je alles in het werk willen stellen om je developers ‘dom’ te houden? Wat is er mis met de complexiteit van Enterprise JavaBeans? Die dingen zijn ook niet ontworpen om er helloworld dingetjes mee in elkaar te zetten. In business critical enterprise applicaties mogen dingen best complex zijn. Er is helemaal niets mis mee dat je van je developers verlangt dat ze weten waar ze mee bezig zijn. Liever denken in patterns dan denken in XML en annotations wat mij betreft! Misschien was de insteek wat ongelukkig gekozen, maar waarom is een Service Locator, een Factory of een DAO nu ineens ‘evil’ en moeten deze tegen elke prijs uit de applicatie worden weggewerkt? Ook voor Spring geldt…zeker eens bekijken! Positief is hier
naar mijn mening ook nog dat het heel goed mogelijk is om slechts (kleine) onderdelen uit het framework te gebruiken (bijvoorbeeld de JDBC template) zonder dat het framework inbreuk doet op de architectuur van je applicatie.

Overall dus zeker een informatieve avond. Kijk alweer uit naar de volgende University eind september, met als onderwerp ‘Presentation-tier Frameworks’
(o.a. JSF). Voor meer info moet je zeker de NL-JUG site in de gaten houden!