Ramnivas Laddad, een bekend gezicht binnen de AspectJ community en schrijver van het boek “AspectJ in Action: Practical aspect-oriented programming” geeft in zijn presentatie een overzicht van de mogelijkheden van AOP. Hij licht deze uitgebreid toe aan de hand van concrete voorbeelden in AspectJ.

De mogelijke toepassingen van AOP nog eens op een rijtje:
transaction management, thread safety, caching, resource pooling, profiling, policy enforcement, monitoring, testing, …

Voor diegenen die nog niet weten wat AOP inhoudt: kortgezegd is AOP een methodologie welke modularisatie van crosscutting concerns faciliteert op een manier die in een conventioneel model niet mogelijk is.
Dit is zinvol omdat in een conventioneel model crosscutting concerns nogal wat ongewenste nadelen hebben, zoals:
- code tangling (spaghetti code): unclear implementation, defocusing (vertroebeling), pool quality code (kleefcode), unintended prioritizing of concerns
- code scattering (niet-modulaire code): duplicate code, inconsistent implementation, difficult evolution

AOP is gebaseerd op het join point model, waarin advices (uit te voeren code) aan geselecteerde join points (identificeerbare aanhechtingspunten) gekoppeld worden, de pointcut genaamd. De combinatie advice/poincut wordt een aspect genoemd.
Het weaving model wordt gebruikt om de aspects daadwerkelijk in de code te integreren.

De syntax van het join point model is er in de volgende smaken:
- language extension (d.m.v. keywords; speciale compiler noodzakelijk)
- meta-data extension (d.m.v. annotation; compileerbaar met gewone compiler)
- xml-based definition

Het weaving model kent de volgende implementaties:
- compile-time
- binary weaving
- loadtime-weaving

Een interessante toepassing van AOP is er in combinatie met Hibernate: detached object management.
De probleemstelling: een close() op een Hibernate session creeert detached objects. Benaderen van deze detached objects in een nieuwe session is problematisch omdat uninitialized collections een exception veroorzaken.
De oplossing: gebruik een aspect om een reattach uit te forceren op de detached objects.

Een andere handige toepassing zijn virtual mocks, ofwel fault injection (testen foutsituaties).
Bijvoorbeeld: throw new Exception(), sleep(duration).

AOP kan ook gebruikt worden om crosscutting concerns te refactoren. Hierover zijn artikelen te lezen hier en hier.

Ramnivas Laddad verwacht de volgende adoption curve voor AOP, in oplopende volgorde: development aspects, refactoring aspects, infrstructure aspects, business logic, AO architecture. Google ook eens op AOP@Work.

Joshua Bloch is de auteur van het bekende boek “Effective Java” en tevens mede-auteur van Java. Deze ochtend had Josh twee lezingen voor ons in pettto.

Effective Java Programming was zijn eerste verhaal en daarin ging hij in op een aantal bekende patterns die ook terug komen in zijn eerder genoemde boek.

De drie belangrijke boodschappen van deze eerste lezing waren achtereenvolgens:
-Hergebruik objecten zoveel mogelijk
-Gebruik Defensive Copying
-Maak classes zo immutable als mogelijk.

Middels het overbekende pattern Singleton introduceerde Josh nog even losjes het woord “monoelvistic” in de Engelse taal…

De tweede lezing van Joshua heette “Good API Design & Why it matters”.
Ogenschijnlijke inkoppers als “When in doubt, leave it out”, “Code should read like proze” en “Document religiously” werden met voorbeelden toegelicht en bleken toch niet zo arbitrair te zijn als ze in eerste instantie leken.

Met deze inspirerende lezing gaf Joshua ons een groot aantal tips en trucs waardoor we beter gebruik kunnen maken van de Java taal, waardoor we beter in staat zijn API’s te ontwerpen en bouwen. Of beter gezegd: hoe we betere Java programmeurs kunnen worden.
Zijn boek “Effective Java” is absoluut meer dan de moeite waard om eens te bestuderen.

In de presentatie Desktop Java in Action van Romain Guy en Richard Bair worden niet alleen spectaculaire grafische Java toepassingen gedemonstreerd (hetgeen soms bijna “over the top” gaat), er worden ook nog enkele nuttige tips gegeven voor diegenen die flitsende grafische applicaties in Java willen bouwen. Met gebruikmaking van de door de sprekers aangeprezen (en mede ontwikkelde) nieuwe SwingX componenten bijvoorbeeld, welke een opwaardering vormen van de bestaande Swing library. De illusionisten goochelen met enkele componenten et voilà, een heuse JukeBox compleet met volledig functionerende synthesizer en visualization.

Deze tips worden gegeven:
- gebruik compatible images (JPEG’s zijn niet noodzakelijk compatibel!)
- maak gebruik van hardware acceleration drivers (dus niet getScaledInstance(), maar drawImage())
- verklein stap voor stap (mitmapping) bij verkleiningen van meer dan een factor 2 (de standaard toegepaste bilinear/bicubic resizing is namelijk niet perfect)

Marc Proctor belicht in zijn spreekbeurt Business Rules Engines theorie en praktijk van expert systems, ofwel rule-based systems. Ik zal enkele keypoints uit het theoretische deel van zijn verhaal kort aanstippen.

Gegeven een probleem en een mogelijke solution hiervoor, dan zoeken we een pad (chain genaamd) die deze met elkaar verbindt. Hiervoor zijn grofweg twee type technieken beschikbaar, te weten forward chaining en backward chaining, waarvan de eerstgenoemde de meest gangbare is. Forward chaining maakt gebruik van een of andere vorm van pattern-matching welke rules/rulesets enerzijds en facts anderzijds combineert en prioriteert.

Voor rule engines zijn er allerlei implementaties ontwikkeld, elk met hun eigen rule language (syntax / grammatica). Er worden verschillende stijlen gehanteerd, zoals LISP style, Java style, etc. Het blijkt dat typische rule-fact problemen herdefinieerd kunnen worden in klassieke SQL concepten als tables (facts) en constraints (rules). Vooral voor diegenen die thuis zijn in Oracle zou dit gesneden kost moeten zijn.
Het geheim van een rule engine blijkt te bestaan uit een agenda waaraan rules worden toegevoegd die vervolgens geevalueerd kunnen worden gegeven de status van bepaalde facts. Sleutelwoorden hierbij vormen priority queueing, composite-conflict-resolving en event-driven model. Het is in feite een vorm van combinatorial pattern matching (by comparing facts) welke zeer krachtig is. Vergeleken daarmee zal het oplossen van een LogiKwiz of een Sudoku puzzel wel een makkie zijn, dunkt me. Een en ander wordt nader toegelicht aan de hand van een voorbeeld van een ruleset die de bekende Fibonacci getallenreeks karakteriseert.

Voor de theoretici onder ons, de bekende algoritmes op basis waarvan een expert system gebouwd kan worden:
(i) rete
(ii) threat
(iii) leaps
(iv) linear/sequential
(v) backward chaining

Elk heeft zijn eigen voordelen en beperkingen. Deze algoritmes worden gekenmerkt door o.a. de mate van ingebouwde intelligentie en de bijbehorende toegankelijkheid (complexiteit). En bijvoorbeeld ook de mate waarin tussentijdse veranderingen in het systeem geaccepteerd worden. Vanuit praktisch perspectief spelen natuurlijk ook hardware requirements een rol.

De sessie Desktop Java in Action van Richard Bair en Romain Guy werd een gigantische trukendoos aan Swing tips, tricks en add-ons opengetrokken. Het vrolijke duo wisselde de slides af met live demo’s van de besproken techniek, en ik moet eerlijk toegeven dat ik weer wat hoop heb gekregen voor Java als client-platform en in het bijzonder voor Swing als GUI toolkit. De demo’s waren best impressive en op de performance was niets af te dingen. De tijd dat Java clients onbruikbaar traag waren (en veelal egaal grijs omdat de renderthread het niet kan bijbenen) lijkt met Java 1.5 en 1.6beta inderdaad voorbij.

Richard houdt zich bij Swinglabs vanuit Sun bezig met het uitbreiden en verbeteren van de Swing toolkit. JDK 1.6 heeft onder andere een betere native platform integratie voor ons in petto: Java applicaties zullen gebruik kunnen maken van tray icons, balloon-shaped tooltips, de embedded Internet Explorer control en nog zo het een en ander. Ook is er de mogelijkheid geschapen om in een vroeg stadium van de startende JVM een splash screen op het scherm te zetten. Voorheen kon dat alleen als de hele JVM al in de lucht was, en dan heeft het niet zo veel zin meer.

Een van de meest ambitieuze projecten die hij liet zien is een set van Data-Aware Swing controls. De demo deed oude tijden (Borland Delphi) herleven, een database-connected GUI met master/detal elementen was weer het fijne vertrouwde klik’n'sleep in de GUI editor van Netbeans. Die klik-en-sleep editor (het ding is Matisse gedoopt) zag er trouwens ook helemaal niet verkeerd uit.

Een ander initiatief waar Richard ons op wees was JGoodies, een componentset die een aantal interessante features aan Swing toevoegt. Zelf was hij erg onder de indruk van een systeem om aan ieder willekeurig schermelement een drop shadow toe te voegen, persoonlijk zie ik daar dan het nut weer niet zo van.

Romain zou in ieder ander universum waarschijnlijk een Flash animator zijn geweest. Deze fransman was met zichtbaar genot aan het uitleggen hoe hij met Swing en het GlassPane allerlei multimediale effecten wist te bewerkstelligen. Hij was erg in zijn nopjes met zijn eigen “take” op de oneindige progressbar: in plaats van een ordinaire zgn “cylon” legde hij een lichtgrijs waas over het hele JFrame heen waarin een hele grote, in MacOSX-stijl ronddraaiende throbber zijn werk deed (zo’n ding, maar dan groter).

Hoewel ik bij veel van de dingen die Romain liet zien een “lekker belangrijk” ervaring had, zat er toch wel een aantal demo’s bij dat de moeite waard was. Een aantal voorbeelden:

• Photo Collage, met nifty drag’n'drop support. [screenshot] [Java Web Start].
• JDiskReport by JGoodies.com
• Clientjava.com
• Jon Lipsky’s blog
• Java Desktop Community
• Romain’s eigen blog

De dag begonnen met de sessie van Mark Proctor over Business Rules Engines. Mark is een committer bij Drools, een Business Rules Engine voor Java die onlangs van Codehaus naar JBoss is verhuisd.

Een Business Rules Engine is een zeer efficiente pattern matcher die gegeven een “feit” (bijvoorbeeld een order in een webwinkel) een lijst met condities kan langslopen om te kijken aan welke daarvan wordt voldaan. Aan deze condities kunnen dan consequenties worden verbonden. Deze techniek is niet nieuw (de kenners herkennen concepten uit o.a. Prolog, Lisp), het meestgebruikte algoritme is van begin jaren ’80. Het spul ontsnapt echter maar moeilijk uit de academische wereld. Het wordt wel commercieel toegepast voor kennis- en beloningssystemen.

Een veelgebruikt voorbeeld is de regel “ALS order.total > 300 DAN order.total *= .95f“, met andere woorden: als het totaalbedrag van een order groter is dan driehonderd [dollar], dan wordt het totaalbedrag van die order met 5% gereduceerd. Als je vervolgens een feit (order) inschiet, of een lijst met tientallen orders, dan zal het systeem de regel triggeren voor alle orders waarop de conditie slaagt.

Een veel interessanter voorbeeld is de “goede gastvrouw” case. Het gaat hierbij om de organisatie van een groot diner. De gastvrouw is naarstig op zoek naar een tafelindeling waarbij mannen en vrouwen om-en-om aan tafel zitten, en steeds minimaal één gezamelijke hobby hebben. Het is nog behoorlijk lastig om dit in gewone programmacode uit te werken, en wanneer je het voor elkaar hebt is het nog veel lastiger om het systeem te wijzigen of om bijvoorbeeld condities toe te voegen (geen dames met hetzelfde kleur jurkje aan dezelfde tafel, ik noem maar wat). Met een rules engine is dit probleem te reduceren tot een tweetal condities:

1. persoon(n).geslacht != persoon(n+1).geslacht
2. persoon(n).hobbies intersect persoon(n+1).hobbies != lege lijst

Met deze regels vastgesteld wordt er een “working memory” aangemaakt waarin de feiten worden geplaatst.

• feit: Gert is man en houdt van {squash, piano spelen}
• feit: Hermien is vrouw en houdt van {squash, GTST, American Football}
• feit: Kees is man en houdt van {American Football, tafeltennis}
• etcetera, etcetera.

Met de feiten op papier wordt er enkel nog tegen het systeem gezegd “make it so” en indien er een oplossing mogelijk is, zal het systeem die vinden. Er wordt dus gezegd wat er moet worden gerealiseerd (een oplossing waarbij alle feiten aan alle condities voldoen). Een veelgemaakte (beginners)fout is om te willen specificeren hoe het systeem tot de oplossing moet komen (procedureel denken).

De kracht van een rule-based systeem zit hem in de schaalbaarheid en flexibiliteit. Mits de regels met enig verstand worden opgesteld dan kan een systeem schalen en blijven presteren tot en met honderdduizenden regels en feiten (Mark had het in een voorbeeld over gigabytes aan data). Ook is het mogelijk om on-the-fly regels toe te voegen (bijvoorbeeld de kleur van het jurkje), verwijderen, of aan te passen, waarna het systeem alleen die feiten opnieuw evalueert waarvoor de aanpassing gevolg zou kunnen hebben.

Mark benadrukt dat er voor het invoeren van een rule-based oplossing vaak een (forse) investering in effort (en geld) nodig is, en dat het zichzelf voor kleine en/of erg statische projecten niet terugverdient. Voor grote en/of frequent wijzigende projecten is het echter goud waard. Ook is het wat makkelijker dan bij procedurele code om de business mensen te laten (mee)denken, bijvoorbeeld door een beslissingstabel in Excel te bouwen (en die als ze niet kijken te exporteren naar een ruleset).

Op de hamvraag (vanaf wanneer loont het; hoe identificeer je een project waarbij een rules engine zin heeft) kon Mark echter geen antwoord geven.

Martin Marinschek

Apache MyFaces is de eerste gratis open source JavaServer Faces implementatie op de markt. Het is niet alleen volledig compatible met de referentie implementatie van Sun, het voegt ook nog een groot aantal features toe.

Met JSF is het mogelijk om in Java / J2EE prachtige GUI applicaties te maken die doen denken aan de GUI’s die je met bijvoorbeeld Java Swing kunt maken. Het resultaat is een GUI die aanzienlijk rijker is dan de standaard JSP GUI’s die we tegenwoordig gewend lijken te zijn.
JSF zou DE standaard moeten worden als het gaat om het ontwikkelen van GUI’s in Java / J2EE.

Zonder te vertellen wat het doel van JSF is of wat de grote toegevoegde waarde van JSF zou kunnen zijn, gooide Martin, core committer van Apache-MyFaces, ons meteen het diepe in door het gebruikelijke “Hello World” voorbeeld te tonen en de JSF lifecycle te bespreken.
Misschien was het niveau “Intermediate” in plaats van “Beginner” waar ik op gehoopt had?

Enkele opvallende features van Apache MyFaces zijn onder andere dat JavaScript enabled moet zijn in de browser en dat minimaal JDK1.4 nodig is.
Een algemene intro en bijvoorbeeld de relatie tot Struts bleven onbesproken.

Een belangrijke boodschap die Martin ons vandaag mee gaf, was dat MyFaces makkelijk te gebruiken is, maar dat het ook makkelijk is om het te misbruiken. De wijze raad was eerst bekend te geraken met het raamwerk alvorens er om heen te gaan werken.

Het programma beloofde de mogelijkheid tot discussie met de spreker over het gebruik en toegevoegde waarde van JSF. In plaats van deze discussie werd ruimte gemaakt voor Jonas Jacobi en John Fallows van Oracle.
Oracle zal een significante donatie doen aan het MyFaces project door een groot aantal door Oracle gefabriceerde componenten (ADF Faces) te doneren aan de Open Source gemeenschap.
In een wervelende “Can you show me how to…” “Yeah, sure I can” “Wow, that looks cool!”-show gaven de heren een demo van een aantal van deze componenten.

De GUI’s die gemaakt kunnen worden met JSF en Apache MyFaces zijn werkelijk prachtig.
Daar tegenover staat de enorme inspanning die geleverd moet worden om en GUI te bouwen in JSF, de grote hoeveelheid code die nodig is en de geringe tool-support die momenteel bestaat voor JSF.
Met de introductie van drag-and-drop-tools kan JSF zonder meer uitgroeien tot DE standaard op het gebied van Java / J2EE GUI development.
De Eclipse plug-ins zijn in ieder geval nog niet toerijkend. Wellicht dat Sun’s Studio Creator in deze behoefte voorziet? Desgevraagd liet Jonas me even een kleine demo zien van de ondersteuning die JDeveloper biedt op dit gebied. Eerlijk gezegd zag het er best aardig uit… De tijden van weleer, toen we nog in Visual Basic op “kwak-en-plak”, “sleur-en-pleur”-wijze GUI’s konden bouwen, lijken binnen handbereik te liggen!!! En lost JSF eindelijk zijn belofte in..

Deze lezing had een focus op de ontwikkelingen die ons het komende jaar te wachten staan op het gebied van Webservices.
Eigenlijk had de lezing “Axis2 in Action” moeten heten omdat de aandacht vooral uit ging naar Axis2.
Axis2 is de logische opvolger van Axis, het populaire Webservices framework.
Om nieuwe features te kunnen realiseren was een volledige herbouw van het framework nodig, vandaar het hernoemen naar Axis2.
Wanneer een groot ontwikkelaars veel kleine bijdragen leveren en bug-fixes doen zonder dat ze daarbij het totaaloverzicht hebben van het framework, kan de onderhoudbaarheid en uitbreidbaarheid onder druk komen te staan. Om nieuwe features te kunnen inbouwen, kan een volledige herbouw noodzakelijk zijn. Veel Open Source projecten ondergaan dit fenomeeen; zo ook Axis.
De 1.0 versie van Axis2 wordt halverwege 2006 verwacht. Axis2 belooft makkelijker te zijn in gebruik, sneller en minder geheugen te gebruiken dan zijn voorganger.

Door de volledige herbouw zal het makkelijker zijn om het grote aantal nieuwe WS-* standaarden te ondersteunen. Zo maken belangrijke standaarden als WS-Addressing, WS-AtomicTransactions en WS-Security al standaard onderdeel uit van het Axis2 framework.
Andere belangrijke nieuwe features zijn onder andere de toegenomen eenvoud om een webservice te deployen en asynchrone ondersteuning.

Databinding is een ander belangrijk aandachtspunt van Axis2 waar Dennis stil bij stond. XMLBeans (Apache) zijn een belangrijke vorm van databinding geworden. JiBX is een framework dat door Dennis zelf ontwikkeld wordt, net zoals AXIOM (Axis Object Model), dat DOM gebaseerd is.

Gelukkig kwamen er nog een paar nieuwe standaarden voorbij, afkomstig van het W3C voor SOAP-attachments (XOP / MTOM als alternatieven voor SAAJ)
Eenduidigheid op het gebied van standaarden voor Webservices lijkt voorlopig een utopie!

Voordat de productierelease van Axis2 uit gaat komen, lijkt er nog veel werk aan de winkel voor de ontwikkelaars van Axis2.
Het gebruiksgemak van Axis2 laat nog te wensen over, de documentatie van de diverse tools is nog ondermaats en zijn er nog te veel wijzigingen tussen de diverse releases. Dennis geeft met name om de laatste reden aan, nog een paar maanden te wachten met het gebruik van Axis2.

Vandaag start de JavaPolis 2005 met tijdens de eerste 2 dagen de university sessies. De sessies duren ieder 3 uur. Verslagen van de sessies die wij hebben gevolgd worden hier gepost.

University Sessies