Follow Us on Twitter

JFall 2009, een verslag

November 2009 - Op 11 november 2009 heb ik namens Whitehorses JFall 2009 bezocht - een van de twee congressen die ieder jaar door de NLJug worden georganiseerd. Ik was wat later, maar toch kwam ik vanuit station Bussum Zuid nog veel andere javanen tegen. Dat is eigenlijk ook een van de mooiste aspecten van JFall (en JSpring) - mede javaprogrammeurs ontmoeten. In dit Whitebook schrijf ik het verslag van dit congres.

Versnel je applicaties met Java SE 7

De gesponsorde keynote sessie heb ik moeten missen door mijn late aankomst, maar gelukkig was ik op tijd voor Versnel je applicaties met Java SE 7 door Jeroen Borgers. De spreker kwam op het eerste gezicht wat onwennig over, maar het was meteen te merken dat hij zeer veel kennis had van het onderwerp.

In het eerste gedeelte van de presentatie legde hij uit hoe door diverse verbeteringen in de JVM, bestaande applicaties een stuk sneller worden. De JVM van Java 7 – codenaam Dolphin – is volgens benchmarks tot 45% sneller. Daarnaast zijn de core-API's uitgebreid, waar ook een kort overzicht van werd gegeven.

Al sinds Java 6 is er een 64bit variant van de JVM. Het voordeel van 64bit is dat veel meer geheugen gealloceerd kan worden, nadeel is dat pointers 2x zoveel geheugen innemen (8 in plaats van 4 bytes). De JVM van Java 7 lost dit op door pointer compression. Het geheugen wordt hierbij opgedeeld in blokken van 4GB. Hierdoor kunnen objecten maximaal 4GB zijn, terwijl pointers maar 32bit groot hoeven te zijn. Gelukkig is pointer compression gebackport naar de JDK 6u14, waardoor voor deze verbetering niet gewacht hoeft te worden tot Java 7.

Ook kunnen sinds Java 6 op de JVM dynamische talen als JRuby, Groovy, Jython of PHP gebruikt worden. Aangezien deze talen dynamisch zijn, is het type van variabelen pas runtime beschikbaar. De JVM van Java 6 kan hier slecht mee omgaan. Programma’s geschreven in een van deze talen waren hierdoor een stuk trager. Java 7 is aangepast, waardoor de JVM dynamische talen een stuk beter ondersteund, en programma’s in JRuby of Groovy een stuk sneller zijn.

De garbage collector van Java 7 is eveneens verbeterd. De garbage collector is beter geschikt voor multi-core processoromgevingen en grote heaps. Verder kan via een optie de JDK soft realtime gemaakt worden, waarbij de maximumtijd tussen garbage-collects ingesteld kan worden. De exacte pauzetijd van een applicatie gedurende garbage collect kan dus niet opgegeven worden, maar wel hoelang die tijd maximaal is. Voor veel soorten applicaties, zoals multimediaapplicaties, games of aansturingsapplicaties (die machines aansturen op grond van meetgegevens) is dit buitengewoon belangrijke feature. Ook de nieuwe garbage collector optie is gebackport naar Java 6, sinds JDK 6u14.

Java 7 bevat ook verbeteringen die echt nieuw (nog niet gebackport) zijn. Zo detecteert de JVM automatisch overbodige synchronized statements. De JVM doet deze optimalisatie door te kijken of binnen een synchronized blok objecten of variabelen worden aangepast die ook buiten het synchronized blok (door een andere thread) aangepast kunnen worden: escape analysis. Zo niet, dan is het synchronized statement niet nodig en kan het door de JVM weggelaten worden.

Aangezien je als programmeur beter een overbodige synchronized statement kunt invoegen in je code, dan een noodzakelijke weglaten is dat een erg praktische feature. De snelheidswinst kan gedemonstreerd worden door snelheid van code die gebruikmaakt van StringBuffer te vergelijken met code die StringBuilder gebruikt. Zoals wellicht bekend, is StringBuffer thread-safe, terwijl StringBuilder dit niet is. In vrijwel alle gevallen is het echter niet nodig dat StringBuffer thread-safe is. Onder Java 6 is code die gebruik maakt van StringBuffer hierdoor een stuk trager dan StringBuilder. Onder Java 7 zijn beide classes even snel, zoals het onderstaande resultaat van een benchmark demonstreerde:

Na de technische verbeteringen van de JVM, werd ook over verbeteringen in de taal Java 7 verteld. Automatic resource planning is hier een van: als je een database connectie of b.v. een bestand opent, is een omslachtig try catch finally block niet langer nodig om te garanderen dat de bestand of connectie gesloten wordt. In plaats hiervan kan de volgende code gebruikt worden:

try (BufferedReader b = new BufferedReader(new FileReader(path))) {
  return b.readLine();
}

In bovenstaand voorbeeld worden alle aangemaakte readers automatisch gesloten – aangezien het Closable resources zijn. Een bijzonder mooie toevoeging, aangezien zelfs in de JDK en vele code examples van Sun zelf het sluiten van resources veelvuldig verkeerd ging.

Tot slot biedt Java 7 diverse uitbreidingen op de core-API's, niet in het minst het fork-join framework. Hierover is al eerder een whitebook geschreven, dus hier zal ik er verder niet op ingaan. Ik was aan het einde erg enthousiast over de nieuwe versie van Java, in tegenstelling tot wat vaak over Java 6 werd gezegd, is upgraden naar Java 7 bijzonder zinvol.

Lunch en keynote

Het sessieblok hierna heb ik overgeslagen. Ik kwam een oud collega tegen, waarna ik al snel in gesprek raakte met andere mensen met wie ik ooit op project had gezeten, kennissen met eveneens een java-interesse en veel andere medesoftwareontwikkelaars. De sessies van JFall zijn zeker wel interessant, maar het reunie-aspect is minstens zo belangrijk. Zoals iemand -wat kort door de bocht- zei 'Naar Devoxx ga je voor sessies, naar JFall om mensen te ontmoeten'.

Na de lunch bezocht ik de gesponsorde keynote van Adobe. Uiteraard werd Flex gedemonstreerd. De vlotte en ervaren spreker demonstreerde een gelikte applicatie. Wederom was het zeer indrukwekkend wat je met Flex kan, maar veel nieuws werd er niet verteld.

JSF 2.0, New & Cool of een verloren zaak?

Vervolgens ging ik naar JSF 2.0, New & Cool of een verloren zaak? door Stephan van Hugten. Ik gebruik in mijn huidige werk behoorlijk veel JSF. Ik was erg nieuwsgierig naar wat JSF 2.0 nieuw te bieden had en vooral wat andere mensen ervan vonden. De sessie was redelijk druk bezocht en ging er vanuit dat bezoekers al bekend waren met JSF – de presentatie zou anders niet goed te volgen zijn.

JSF 2.0 omvat meerdere JSR standaarden, zoals in de presentatie schematisch werd weergegeven:

De opvallendste uitbreiding van JSF, is een standaard voor Ajax-API's en de toevoeging van Facelets. JSF 2.0 lijkt erg veel op standaardisatie van ajax4j + facelets. Als je beide frameworks al gebruikt (zoals ik), dan hoor je niet heel veel nieuws, maar wordt je wel blij van de uitbreidingen en het feit dat de gebruikte technieken nu ook een standaard zijn.

Voor wie facelets niet kennen: facelets vervangen jsp-pagina’s door .xhtml documenten. Met facelets zijn zeer eenvoudig templates te maken en herbruikbare componenten te schrijven. Bovendien renderen facelet-pagina’s een stuk sneller dan jsp-pagina’s.

Een facelet component omvat het maken van een interface en implementatie, beide in xhtml:

De interface

<composite:interface>
<cc:attribute name="userid" default="guest“ required="true"/>
<cc:attribute name="password“ required="true"/>
<cc:attribute name="loginAction" method-signature="java.lang.String f()“ required="true" />
</composite:interface>

De implementatie

<composite:implementation>
<p><h:inputText id=“#{cc.attrs.userid}" /></p>
<p><h:inputText id=“#{cc.attrs.password}" /></p>
<p><h:commandButton value=“Login” action="#{cc.attrs.loginAction}" /></p>
</composite:implementation>

In de oude versie van facelets was het al makkelijk componenten en templates te schrijven, maar het definiëren van parameters was nog omslachtig. De nieuwe standaard maakt het schrijven van componenten een stuk eenvoudiger.

Een andere opvallende verbetering is de uitbreiding van EL: de taal om javabeans te benaderen in JSF. In jsf-pagina’s ben je nu niet langer beperkt tot bean-properties (get’er en set’er methods), maar kunnen ook algemene java methods aangeroepen worden zoals in het onderstaande voorbeeld:

<h:outputText value="#{bean.registerGuest('Bill')}" />

In JSF 1.2 was het nodig veelvuldige get’er en set’ers te schrijven of te laten genereren door IDE’s als Eclipse. In de nieuwe versie is dat niet meer nodg.

Tot slot een demonstratie hoe in de nieuwe JSF standaard een ajax actie gekoppeld kan worden aan een javascript event:

<h:selectOneMenu value="#{reserveringPB.kamerType}">
<f:selectItems value="#{reserveringPB.kamerTypes}" />
<f:ajax event="change“ listener="#{reserveringPB.checkBeschikbareKamers}" render=“@form" />
</h:selectOneMenu>

Voor gebruikers van de a4j library zal bovenstaande code bekend voorkomen. In bovenstaande voorbeeld wordt de method checkBeschikbareKamers van de bean reserveringPH aangeroepen op het moment dat het javascript event change wordt afgevuurd. Na afloop wordt het complete form opnieuw rerenderd – zonder dat de gebruiker iets merkt van een page-refresh.

Andere uitbreidingen die ik alleen kort wil meedelen zijn:

  • Configuratie via annotation in plaats van via xml files.
  • Stateful urls – JSF is niet langer beperkt tot POSTS alleen – parameters kunnen nu ook via een GET worden doorgegeven.
  • Conversation scopes – wanneer de session scope te lang is en de request scope te kort. Vooral voor wizards en shopping carts erg zinvol.

Na afloop was ik nieuwsgierig wat mensen vonden van JSF –toevallig kwam ik bekenden tegen die zelf ook JSF gebruiken. Zoals bijna iedereen die JSF gebruikt, waren ze niet dolenthousiast over hun JSF ervaringen, maar was JSF 2.0 een stap in de goede richting.

Java en Google App Engine Introductie

Vervolgens heb ik de Java en Google App Engine Introductie bezocht. De spreker, Jettro Coenradi, legde op relaxte wijze uit hoe je met de Google App Engine aan de slag kan. In tegenstelling tot wat ik enigzins dacht, is de Google App Engine niet gebonden aan een webframework als GWT.  Google App Engine lijkt (of eigenlijk is) een applicatieserver waar je speciale war files op kunt deployen.

De App Engine biedt een eenvoudige JDO en JPA implementatie, waarmee je objecten kunt persisteren. Hoewel de  JPA implementatie minder uitgebreid is dan b.v. Toplink of Hibernate (complexe object relaties zijn niet mogelijk) is de persistatielaag voldoende voor eenvoudige toepassingen.

Daarnaast kun je uiteraard veel functionaliteit van Google gebruiken binnen je applicatie, zoals ondermeer authenticatie via Google en mails versturen. Het mooie is dat de meeste van deze functionaliteit via een standaard API van Java aangeboden worden – mails versturen kan simpel weg via de Java mail API (en niet via proprietary Google API), persistentie via JDO of JPA werd al genoemd.

Google App Engine kun je gratis mee beginnen, maar je applicatie is dan begrenst op hoeveelheid geheugen en hits. Voor veel webapplicaties levert dat al snel problemen op - mocht je applicatie over de limiet heen gaan, dan krijgen gebruikers een 500 error voorgeschoteld.

Om te beginnen met ontwikkelen is het het meest praktisch een lokale testomgeving op te zetten, zodat de Google app lokaal getest kan worden – telkens opnieuw deployen is erg tijdrovend. De lokale omgeving is vrijwel identiek aan de omgeving zoals bij Google. Via geleverde ant scripts of een plugin voor IDE’s als Eclipse en IntellJ kun je vervolgens je applicatie builden en deployen. Google biedt ook maven plugins, maar die werken nog minder soepel dan de ant scripts – het automatisch deployen van Google Wave applicaties via maven ging nog niet soepel.

De spreker heeft een kleine applicatie voor het publiek on-the-fly geprogrammeerd (met wat vooraf geprepareerde code). Een effectieve manier om te demonstreren dat programmeren in een bepaalde omgeving echt eenvoudig is, en Jettro slaagde hier goed in. Na programmeren en lokaal testen, werd de applicatie geïnstalleerd via de beheeromgeving van Google. Al snel was een interessante toepassing gemaakt en deployed, die mails kon ontvangen en plaatsen op een message-board en via Google Talk berichten kon versturen.

Ik vond Google App Engine veelbelovend en zodra ik wat tijd over heb wil ik dit zeker uitproberen.

Google Wave: what is it, and how does it work?

Tot slot heb ik de sessie over Google Wave: what is it, and how does it work? bezocht, gegeven door Jos Dirksen. Deze sessie had het minst met Java te maken en was daarom vermoedelijk ook als laatste ingedeeld.

Google Wave lijkt een combinatie van Google Talk en Google Docs. Halverwege de demofilm (beschikbaar op Youtube uiteraard) een google-wave-demonstratie getoond, met de audio van een beroemde scene uit Pulp Fiction (‘Does He Look Like A Bitch?’). Het maakte elk geval dat iedereen goed de aandacht bij de presentatie hield.

Interessant om te zien, maar helemaal overtuigd ben ik niet. Hoewel de afzonderlijke tools op zichzelf erg zinvol zijn, betwijfel ik of de combinatie echt wat toegevoegd.

Google Wave is alleen beschikbaar na uitnodiging, de spreker had nog een behoorlijk aantal invites over, wie hem snel mailde kon een uitnodiging ontvangen.  Inmiddels heb ik een account mogen bemachtigen. Ik ga wat met Google Wave stoeien, wellicht verander ik van mening.

Conclusie

Al met al heb ik een aantal interessante sessies gezien, waarvan ik de sessie over Java 7 het meest interessant vond. De sessie op Google Wave was leuk om te zien, maar voegde niet heel veel toe. Sessies op de NLJug-congressen hoeven zeker niet alleen over Java te gaan, maar Google Wave ligt toch net iets te ver af van softwareontwikkeling en programmeren.

Na afloop was het tijd voor de borrel. Er werd stevig genetwerkt en bijgepraat . Ik heb een biertje gedronken met oud collega's en bekenden. De sfeer was goed, met de economie gaat net nog steeds niet geweldig, maar mensen zijn vooral weer optimistisch. Al met al weer een bijzonder interessante en leuke dag.

Referenties

Waardering:
 

Reacties

door projectdrukte was ik helaas verhinderd om naar de JFall te gaan. Leuk om dan hier een verslag te lezen. Kun jij nou zelf ook weer mensen inviten voor google wave en zou je mij dan willen inviten?

Nieuwe reactie inzenden

De inhoud van dit veld is privé en zal niet openbaar worden gemaakt.

Meer informatie over formaatmogelijkheden

CAPTCHA
Deze vraag is om te testen of u een persoon bent en om spam te voorkomen
Image CAPTCHA
Enter the characters shown in the image.