Montag, 10. November 2014

Devoxx 2014 - Day 1

It's that time of year again! Devoxx time!

So here I am in Antwerpen again, for a week of interesting topics, hearing about some cool (new) stuff, even though quite aware that some or most I wont be using that soon. Java 8.
Now, if last time round in 2011, NoSQL and Big Data was the hot topic, this year it seems to be Docker. Apart from the features of Java 8 (and beyond..) that is.

Sonntag, 4. Dezember 2011


It was a cool experience at the Devoxx.
Somebody said, "Devoxx is not so much about learning, but about getting passionate".

It definitely hits the nail on the head. Of course, I did hear a lot. My personal major keywords would be: the Cloud, NoSQL(MongoDB), Android, HTML5!
There were excellent talks presented by fascinating people. The presentations and the many live demos on the interesting themes, really motivates one to test and try out the cool "newbies"!

Fazit: See you next year! :)

Some more reasons to attend Devoxx:

P.S Unfortunately those trees on the main avenue near Centraal Station didn't make it :(

Day 5 - where does time go?

Friday was the last day of the DEVOXX 2011.
Lots of people had already left but there were still enough to fill a few rooms to hear the technical discussion panel.

The talk on the "Evolution of Java: Past, Present and the Future" by Joshua Bloch was of course also very well attended. Joshua Bloch presented his views on basically all the major changes in Java since 1995, from assertions to serialization to Project Coin.

Cool talk :)))

Day 4 - on Cloud nine

So, as you may have noticed, this is a way overdue entry about day 4 at DEVOXX 2011 :)

As I still haddn't gotten enough, I decided to hear another session about the Cloud.

Cloud is such stuff that dream are made on
(Patrick Chanezon, Guillaume Laforge and Ludovic Cahmpenois)

Overview of:
- Saas (Software as a service)
- Iaas (Infrastructure as a service)
- Paas (Platform as a service)
- Cloud Foundry, Google AppEngine, Cloudbees,Microsoft Azure

-- Google AppEngine
- easy to build
- easy to manage
- Admin Console "Appstart"
- secure
- SLA (99% uptime guarantee)
- easy to scale

- lightweight Groovy Toolkit on top of Google App Engine

“Don’t be a Google Bitch, don’t be a Facebook Bitch, and don’t be a Twitter Bitch. Be your own Bitch.”
Fred Wilson

--> Look at open source/open standards aspects of the platforms and services you use


Html5 with Play,Scala Coffeescript and Jade
(Matt Raible)

Matt Raible in a entertaining talk, went about on his adventure on building a app using these technologies.

Check out his slides:
Html5 with Play,Scala Coffeescript and Jade

Cool talk! :))

The jQuery Essentials
(Addy Osmani)

In a completely packed room, this talk presented some jQuery essentials.

Why use jQuery?
- well documented
- well tested
- large community
- it is lightweight

In the top million sites, over 60% use jQuery!

Version 1.7 just released!

Check out his talk here

(Andrew Swan and James Tyrrell)
- Spring Roo is a shell based next-generation rapid application development tool for Java developers

The speakers demonstrated live how to use Spring Roo to very quickly create an application.

_It is useful for rapid prototyping or experimenting with supported technologies.
_even allows DB reverse engineering
_can create repositories, services on demand.

Cool talk, but the shell based aspect, does turn me off :p

Donnerstag, 17. November 2011

Some quotes heard

Some quotes from the speakers' quotes

"What's the difference between Ant and Maven?
The creator of Ant has apologized."

"Give a man a fish; and you have fed him for today. Teach a man to fish; and you will be answering fishing related questions forever."

Mittwoch, 16. November 2011

Day 2: a bit more of Android if you please :)

Building Android Applications for performance usability
(Bruno Oliveira)

4 billion mobile devices!!

- 550000 daily activations!
- 250000 apps!

Bruno's plan
users are our friends!
-making apps faster is the plan (because users are our friends!)

What don't the users know they want?

How do you impress the user? Quality is essential!

2 Kinds of Apps:
- apps that love the user
-apps that hate the user

Apps without users have no bugs.

>>Interface/usability design
-no surprises

easy to learn X easy to use

Who will design your app?
You? Would you trust a designer to program your app?!
Hire a designer to design your app!

- use the action bar!
- use "home" (icon or logo)
- when items are selected show actions available
- use fragments
- make the "hero" screen awesome -> it's the page the user will show his friends
- always worry about compatibility (system version, screen size, keyboard,...)

So use:
_different resource folders
_android manifest file: use
_different layouts for different screen sizes
_"dp"(for images) and "sp"(for text) instead of pixels
_match_parent and wrap_content for flexibility
_never use AbsoluteLayout
_supply bitmaps for different resolutions

UI/UX Tipps
# apps adapted to each platform
# make your app present (or else your users will forget the app)
-intents, content providers,live wallpapers,...
# NOT every device is a phone!
# use the best of every device, let the user configure input
# the user isn't always online
# instead of constantly pinging the server, use C2DM for push notifications
# use broadcast receivers to know about connectivity
# allow te user to configure the app
# Don't mess with the back button!! Really.
# smart users read instruction. NOT true!
# always allow the user to undo an operation
# users change their minds so... always let the user cancel/postpone an operation (and be quick about it!)
# do NOT ignore rotations/flips
# users have infinitely small fingers. Also NOT true! Users have big and imprecise fingers!
# users want simplicity.False! users want clarity

-try to prevent the "sorry screen"
- performance
- don't block the UI thead, use Async Task
- entertain the user (via spinners, process dialog,...)
- allow the user to cancel/postpone

Common causes for slowness:
-heavy math
Do not allow this on the UI Thread!

How to work in the background? -> asyncTask, IntentService

Improving app performance
premature optimization is the root of all evil! (Donald Knuth)
-optimize code in the right place

If you cannot improve performance, fake it! If you have slow apps, you have angry users.
Remember the most important is..:

Super cool session!! One of my favourites so far, and I am not even that into app programming! There is of course much more to say, but this session you HAVE to see on parleys.
Presented in a cool way but definitely to the point :))))

Day 3 HTML 5 rocks!!

Death of the slow: 7 Reasons to love JBoss AS7
(Dan Allen and Andrew Rubinger)

#1 - Speed
#2 - Modular Design
#3 - Exceptionally lightweight
- define servlet-configuration to trim for ex. servlet container
#4 - Domain Management
- keyword: Domain Controller, Server group
#5 - Elegant administration
#6 - First class components
ex.: Ruby on JBoss (TorqueBox for Java and Ruby!)
#7 - Developer productivity
-JBoss Forge

Bleeding Edge HTML5
(Paul Kinlan)

- < details > / < summary > - to expand and collapse content
- < output > - no need for onclick or onchange
- < mark > - for highlights
- speech input - x-webkit-speech

>> Intelligent Web Apps
- smarter animations (browser gets more control, on how often call back functions are called) -> window.requestAnimation
- Page visibility API/Rendering -> detect if user is on the page tab or not
- know when you are connected -> so you can do diferent things accordingly

Some other keywords:
- Web Intents (see android intents)
- Rich Media: full screen API
- Web RTC

Basically from what I saw, I have to agree with the speaker, it is just Craaaazy cool!! I want it too!
Great speaker! :))))

Performance anti-patterns in Hibernate
(Patrycja Wegrzynowicz)

#1 - premature optimization
#2 - lost proxy on owning sid -> prefer field access mappings
#3 - temporary changes -> flush to database
#4 - inadequate collection type on the owning side
one-to-many relationships
- bag semantic :(
- set semantic :)
- list semantic :(
#5 - OneToMany as owning side
-> use ManyToOne as the owning side and OneToMany as the inverse side
#6 - inadequate collection onb the inverse side
#7 - OneByOne processing

Conclusion: read the documentation!

Interesting and scary were some examples she showed about how many updates hibernate does in the background if one uses inadequate types. Eeeeeerie!

Productivity enhancements in Spring 3.1
(Costin Leau)

>> Spring 3.1
> Environment abstraction: Bean Profiles
- group objects by target environment (ex. test,dev,prod,..)
- activate profiles - when beans are not active, they are not validated :)

> Java based App Config (for those who curse XML)
- can use it instead of XML or alongside it
XML JavaConfig
Namespaces @enable*
FactoryBean Builder
GenericXMLContextLoader AnnotationContextLoader

> c: namespace (analogue to p: namespace)

> Cache Abstraction

> @MVC improvements
- was introduced in 2.5 - improvements in 3 for REST

> Consumers and producers

> Refined JPA support

- RC1 out in October
- RC2 next week
- GA soon after

Day 3: Conference Days start

Today marks the beginning of the "conference days". The first 2 days were the so called "Student days". Plus the exhibition started only yesterday. Lots of more people, and I mean A LOT more people.

Stephan Janssen, organizer of the DEVOXX, started with some anouncements and then keynotes by some "java guys from Oracle"(not my words! :))
Henrik Stahl(on Java SE) and Cameron Purdy(on Java EE). I am not going to present the notes here, but here are just some keywords:
Java 7 EE: Cloud, Modularity (jigsaw), HTML5, Elasticity, multi-tenancy,JMS 2.0

Stephan Janssen presented some quite impressive numbers.
Attending the DEVOXX this year are 3350 people from 40 countires!! Wow!

He also revealed a secret... next year 18-20 April there will be a DEVOXX in Paris,France! Cool I thought, .. but 75 percent will be in french :/

Another note, the DEVOXX sessions from 2010 are now available on Parleys FOR FREE!!

My first session of today:
In "Java: the good,the bad,the ugly" Joshua Bloch presented his own very personal view on ALL the packages of Java 1.0!

Day 2: Goodbye to SQL??

There is a new hype out there... a scary one called NoSQL.
I've read a bit about NoSQL and definitely wanted to attend at least one session about this theme.

Building Web Applications with MongoDB
(Brendan McAdams)

- MongoDB is schema-less
- For some problems "SQL sucks" and ORM becomes complicated.
- Joins are great but potencially messy
- instead of a "table", MongoDB has a "collection"
_id - primary key. if you don't specify one, driver will generate an unique ObjectId
- JSON Data
- $set -> update

>> NoSQL
- nonrelational
- horizontal scalibility
- no joins, no transactions
- best use-cases: caching, "scaling out"
- less suited for ad hoc BI, highly transactional applications, problems which require SQL

MongoDB revolves around memory mapped files
- operating swstem maps files on the file system to virtual memory
- 200GB MongoDB files creates 200GB of virtual memory
- when a fault occurs, it goes to the disk, hence slowing it down!
- deployment trick: "prewarm" your DB

>> OS Choice
- For production: use a 64bit OS for a 64bit MongoDB Build!
- 32 bit has a 2GB limit imposed by the OS for memory mapped files

>> Filesystem
-MongoDB is filesystem neutral BUT look out for posix_fallocate() because allocation of 2GB takes tile otherwise!

-BSON encoding
- Extent allocation
- Record allocation: padding because of document growth

>>Modeling Schemas
- think documents not rows
- docs arranged in collections
- favor embedding oer refrencing (FK consistency NOT checked)
- no datasource enforced FK relationships
- documents can be 16Mb

-There is a kind of query language that uses $operators
-Commands: drop, count, copydb, findAndModify
- Cursors
- Indexing and query optimization: you can specify hint to force a specific index

MongoDB and Java
- DBObject (like Map interface)
- ObjectId
- BasicDBList - toString() returns well defined JSON representation

>> ODM - Object Document Mappers
relationship: embed or reference
- in Java: Morphia, Spring Data Document
- in Scala: Lift MongoDB Record; Salat

>> Scaling
- read scaling: add replicas
- write scaling: add shards

- data model affects performance
- embedding vs. linking
- partial vs. full document writes
- partial vs. full document reads
Schema and schema usage critical for scaling and performance

-index common queries
-not over index: more indexes mean less data!

- consistent hashing
- range based partitioning

MongoDB Sharding _ automatic partitioning and management
_ fully consistent
_ convert top sharded system with no downtime
_ automatically balanced

MongoDB Backup: dump; restore; or journaling (snapshot)
Regular expressions can be used in searches, but are limited due to the indexes

Very interesting stuff!! And no, it's not goodbye to SQL :)
NoSQL is interesting and there are places where it fits, but it can never replace SQL.
Cooool session :))))

Dienstag, 15. November 2011

Day 1: Android again

Android Tools in Action
(Tor Norbye and Xavier Ducrohet)

- Half an hour session on some tipps on the Android Tools

Ok, so if you are not yet developing Android apps, not so much you can retain here. And 30 minutes is quite short.

Continuous Code Inspection with Sonar
(Olivier Gaudin)

Sonar basically presents the 7 deadly sins of the developer on a dashboard!
Cool: eclipse plug-in

This session presented Sonar live demo. Very cool to see how much information Sonar gives you.
Liked this session alot :)))

Code Review with Git and Gerrit
(Matthias Sohn)

Git: distribuited revision control system
- no central authority
- easy to branch
- easy offline usage
JGit: Java library implementing the
EGit: Git in eclipse

Code Review is not about fault finding or pointing fingers!
+ 4 eyes catch more bugs
+ learn without breaking
+ helps enforcing coding standards

>> Gerrit Code Review
notion of virtual branch
-code review before changes reachj the code base
-only completed changes reach the project history
-code reviews take time and implies paralel workflow
-every team member should do code review
- BUT it does take weeks or months to learn :(

Well, Gerrit Code Review does seem interesting...a bit. As pointed out by the speaker, it does take a lot of time to get used to. SAP does use Gerrit (about 700 developers). The code review does take some time, so the developer has to wait(!) until code gets reviewed. But each member in the team has to spend 1 hour reviewing someone else's code. Matthias Sohn pointed out, that this time invested is definitely worth it? because it does save time in the long run.
Somehow, I am missing the WOW effect...

Day 1: Spring into the cloud!

The next session I definitely wanted to see was about the cloud...

Spring into the Cloud
(Josh Long, Chris Richardson)

This sessions basically covered Spring and Cloud Foundry and described why they are a match made in heaven.
Concept "rent a cloud" eg. Amazon Web Services(AWS)
cloud computing defines IT as a service and pay per use

>> Layers:
- Saas(Software as a service)
- Paas (Platform as a service)
- Iaas (Infrastructure as a service)

- Clouds are a good option for startups -> scale up and scale down easily

>> Computing Types
- public cloud
- private cloud
- hybrid cloud

There is also the "micro cloud" -> cloud on your own computer
Search for a Framework: early attempts were for example Corba and EJB -> inflexible

Some topics:
- complete application lifecycle management
- cloud controller
- health manager
- router
- Droplet Execution Agents (DEAs)
- possible to use command line: vmc

>> Auto-Reconfiguration
- deploy Spring applicatiosn to the cloud without changing code!
- Cloud Foundry installs a BeanFactoryPostProcessor into your application context during staging
- adds jars to the application
- changes web.xml

- namespace for use in Spring app context
- - Scans all services bound to the application and creates a bean of an appropriate type for each
- - exposes basis info qbout services that can be consumed
with Spring's poperty holder
Spring 3.1
- Profile: beans definitions for a specific environment
- Cloud Foundry installs a custom ApplicationContextInitializer during staging
- Adds “cloud” as an active profile

Relational Databases are great:
- ACID semantics
- well suported(JPA, Hibernate)
- well understood

- complicated to map rich domain model to relational schema
- dificult to handle varying attributes
- schema changes
- poor performance in some cases
- impossible to scale horizontally

>> NoSQL

- higher performance
- high scalibility
- richer datamodel
- it is schemaless
- no transactions

->> Redis
- advanced key-value

- very fast
- optional persistence
Use cases:
- handling tasks that overload a RDBMS
- users:

->> MongoDB
- document oriented
- JSON style documents

- limited transactions
- rich query language
- very fast
Use cases:
- high volume writes (because its async)
- complex data
- users: SourceForge

Other NoSQL Databases: Neo4j, CouchDB,...

>> Spring Data (for NoSQL)
- template classes
- Java <-> NoSQL Mapping
- Cross Store persistence: in a class through annotation, it is possible to use JPA AND Mongo. So in one class; some attributes get saved in RDBMS and other in Mongo!

Cloud Foundry also offers MySQL, Redis, and MongoDB data services, as well as RabbitMQ messaging service.

Very interesting session! :))
Presented well and containing code examples. NoSQL seems cool but I DO like my SQL! :) There will be more on NoSQL..

Montag, 14. November 2011

Day 1: Android and more

There I was in in the cinema theatre, waiting for the session on Android to start when the anouncement came that there would be a ten minute delay because of some scanner problems at the registration. Phew, glad I registered yesterday :))
In the meantime, on the screen in front, you can follow the Devoxx Twitter.
Everybody in the theatre seems to have a laptop or a tablet or some smart phone.
First session today is packed. I mean really packed. People ended up sitting on the stairs!
Why? The first presentation I chose to attend is...:

Android Jumpstart - Introduction to Android App Development
Speaker: Lars Vogel (

This sessions aims to present the basic architecture of Android, and demonstrate the Android Development Tools for Eclipse as well as some basic concepts.
First of all, the latest super duper version of Android is 4.0

- "Almost Open Source"

Android Architecture

The lowest level is basically a Linux Kernel changed a tad. Diferent libraries, e.g power management etc.

Overview of API capabilities
- subset of Java SE
- Android specific API
- rich UI components, full network stack, database functionality
less memory and CPU boundaries -> it is after all a phone!

- Every Android application runs in its own process, with its own instance of the Dalvik virtual machine.
- you program in Java, and tool "dx" converts Java Bytecode into .dex format

Android Development Tools (ADT) for eclipse
- eclipse bqsed tooling
- provides the emulator (which can be SLOW)
- Android manifest file
- contains all components
- contains the minimum SDK version
- Resources Folder - may contain various resources for diferent resolutions
- Activity - is a single focused thing the user can do
- Views - Layouts are XML based

!Android is allowed to kill your app to save memory!!
-> so it is important to understand Lifecycle e.g states of activity.

There are two methods almost all subclasses of Activity will implement:
- onCreate(Bundle) - where you initialize your activity
- onPause() - where you deal with the user leaving your activity...and where you should save the user data

Topics and things to keep in mind:
- Menus: important to use the flag "ifRoom"
- Intents (explicit and implicit)
- Context (Activity extends Context)
- Preferences
- ListView - gets the data from the adapter(adapter defines the data and how
listItem should be presented)
- ListActivity: provides some nice hooks
- use "convertView" -> if the view is NOT null, we can simple re-use the convertView
as the new View -> good for performance
- findViewById -> NOT good for performance
- holder pattern -> good for performance
- when testing your app, remember to "flip" the device!
- Fragments: supports more dynamic and flexible UI Designs on large screens
- for each device define a layout: easily done in the resources folder

>> Services and Receivers
- allows real multitasking and background processing
- decoupled from activity lifecycle
- services run in the background without interactivity with the user (eg.
NotificationService, VibratorService, LocationService)
-> you can define your own services that should be done in background

>> Broadcast Receiver
- registered as a receiver and only valid within the onReceive() method

>> Security
- "application sandbox": every app is run as its own linux user
- access permission to android functionality is definde in android manifest file
- when installing an app, you can see this information and choose wheter to proceed
or not and so prevent malicious apps from being installed

Other features:
- pull/push to device
- live wallpapers
- simple ListHandling
- animations and styling
- (multi-) touch
- NFC (Near Field Communication)

>> Testing
- Robojuice
- Monkey: basically presses all buttons and input fields randomly!

Definitely chose the right session to start my Devoxx experience!
Great speaker and really good introduction to someone not yet familiar with Android :))))

Devoxx - let the games begin!

So there I was, at my first Devoxx with me orange armband:)
Breakfast at the Devoxx basically means a large amount of sugar: croissants and sweet cakes. And coffee, lots of coffee (thank goodness for that!) :) There are also some fridges filled with drinks like coke,juice and water.
I headed into my first session...

Sonntag, 13. November 2011


After arriving at the Antwerpen Centraal Station, which is a monument on its own to visit (simpy magnificent building!), quickly found my way to the hotel.
Checked into the hotel, which seems quite nice. The lady at the reception told me the drinks in the mini-bar are free, and when I looked astounded she quickly added not to expect any champagne or fancy drinks :) Free coffee and tea all day in the lobby and free WIFI. Regarding breakfast, I will be taking my chances at the Devoxx and hope to rely on "Vers Brood en Kaas" ;)
I went to register at 18h, got my Devoxx bag and T-shirt. And my armband. I looked at the guy funny when he put it around my wrist. It looked like mere paper and I am supposed to wear it the whole week (you cannot take it off once it's on)?? The guy told me, it's like a rock festival, I must wear the armband the whole week, yes. Rock festival? Ok, note taken;) But ok, the armband is made of a kind of plastic, and is water proof (tested that already :p)
I strolled around the Central Station afterwards, looking for a place to eat when a lady with a notepad in her hands approached me. Well, to cut the story short, after a few hours of being in Antwerpen, I had already signed a petition so that they wont't cut all the trees(!) on the lane that leads from the station. Apparently the city thinks that the trees refrain people from seeing the station from further away. Or so it was explained to me. Does really seem silly to cut off all the trees (pretty big trees), doesn't it?

Anyhow, tomorrow it gets down to business.

Will keep you posted.

Getting there....

Ok. Call me crazy, but I travelled by train to Antwerpen! Nothing like supporting the DBahn and all ;) And yes; of course there was a delay. Wouldn't be the DBahn if not; now would it. Anyway, my trip took me to Brussels via Köln. Still had time to take a snapshot of the Dom. Then after the delay, I finally continued to Brussels. With a good book and some chocolate chip cookies, the trip isn't THAT long... just about 6 hours ;)
Well, in Brussels the most people speak French, though the names appear in both french and Flemish. But I think never before did I hear so many diferent languages or see so many people of diferent nationalities in such a short period of time!
Naturally I could not refrain myself from also trying moules et pommes frite accompanied with belgian beer. I actually don't appreciate beer, but hey, in a city where they even have a beer museum, I go with the flow :) Seemed like everyone else was eating pommes frites, or standing in a queue to get some!
From Brussels to Antwerpen, it's only about 40 minutes by train. In Antwerpen I have to switch my "Merci" to "Dank u". Most people here speak Flemish, which is fun, because it's not hard to understand.

Devoxx 2011!

Welcome to the Devoxx 2011!
Michelle reporting to you from the city Antwerpen.

Stay tuned :)

Freitag, 19. November 2010


Fast hätte ich's vergessen: Nach meiner ersten kulinarischen Erfahrung (s. Curryworsten) habe ich ja versprochen, mich noch einer anderen belgischen Spezialität zu widmen: Schokolade.

Ich selber bin kein Fan von Pralinen, obwohl genau diese Naschvariante es ist, für die Belgien berühmt sein soll. Also habe ich mich auf Schokolade in der Tafelform beschränkt.

Bei Wein gilt ja die Aussage: Ein Wein ist immer dann ein guter Wein, wenn er einem schmeckt.

Wenn das auch für Schokolade gilt, dann machen die hier sehr gute Schokolade. Aber deswegen nach Belgien fahren? Vielleicht nicht, aber die Vielfalt in den Schaufensterauslagen der zahlreichen Schokolaterien zu sehen, lässt einem doch schon mal das Wasser im Munde zusammenlaufen.

Für "richtige" Nahrung empfehle ich hier aber entweder Pommes oder die internationale Küche Italiens und Argentiniens. Niemals eine Currywurst!! Die sollte man nur im Land der Dichter und Denker zu sich nehmen, und da ist das ein echter Genuss. ;-)

Das war's: Ein kleines Fazit von Jörn

Fünf Tage Devoxx sind zu Ende. Ohne Frage fünf teilweise sehr interessante aber auch anstrengende Tage.

Wir haben erstmals die Teinahme an einer derartigen Veranstaltung mit einem Blog dokumentiert und somit allen "Daheimgebliebenen" mehr oder weniger live Bericht erstattet. Dieser Blog war für uns eine Hilfe, das Gesehene und Gehörte noch mal zu verarbeiten und für alle Leser hoffentlich eine interessante Nachrichtenquelle.

Natürlich gab es (wie immer und überall) positives und negatives festzustellen.

Positiv war definitiv die zumeist hohe Qualität der Vorträge. Dies galt sowohl für das inhaltliche als auch für das rethorische Niveau. Hinzu kam die Besonderheit des Veranstaltungsortes: Wann hat man schon mal die Gelegenheit Vorträge vor einer großen Kinoleinwand präsentiert zu bekommen?

Negativ fällt mal wieder das Essen auf. Wie schon von Teilnehmern vergangener Jahre berichtet, fallen Frühstück und Mittagessen recht mager aus. Abends gibt es eh nichts. Die Räumlichkeiten waren ab Tag 3 an ihre Kapazitätsgrenzen gestoßen (sitzen auf den Treppen war teilweise notwendig). Das wurde zusätzlich bei Raumwechseln zwischen den Vorträgen deutlich (die einen wollen rein, die anderen raus. Gedränge und lange Schlangen; ein Raumwechsel dauerte eine gefühlte Ewigkeit). Aufgrund der zahlreichen Vorträge hatte man nur wenig Zeit, sich mit anderen Teilnehmern zu unterhalten oder die parallel stattfindende Messe mit Ausstellern unterschiedlichster IT-Unternehmen zu besuchen. Die Abstände zwischen den Vorträgen waren manchmal recht eng. Hinzu kam unsere "Selbstverpflichtung" zu bloggen, wofür die sowieso knappen Pausen meist vollständig draufgingen (aber daran sind wir selber "schuld").

Fazit: Grundsätzlich ließe sich diese Veranstaltung uneingeschränkt weiterempfehlen und eine Teilnahme im nächsten Jahr fest einplanen (dann mit zwei anderen Kollegen), wenn ... ja, wenn es nicht eine sehr günstige Alternative gäbe:! Gegen einen vergleichsweise geringen Unkostenbeitrag von 79€/Jahr erhält man in einer sehr guten Flash-Oberfläche Zugang zu sämtlichen Devoxx-Beiträgen des aktuellen Jahres. Viele der älteren Beiträge sind meines Wissen sogar gratis.

Man spart Reisekosten, die Mitarbeiter fallen für's Tagesschäft nicht aus, es ist billiger und alle haben etwas davon. Nur auf einen Blog wie diesen müsste man verzichten. ;-)

Vielleicht wird's ja was.

Tag 5: 11:50 - 12:50 : The roots of Java EE 6: JSR-299 (CDI) and Weld extensions

Contexts and Dependency Injection (CDI) ist eines der zentralen Themen in JEE 6. Dieser Vortrag widmete sich der Referenz-Implementierung Weld.

Sämtliche Eigenschaften von Weld aufzuzählen, ginge an dieser Stelle zu weit; hierzu sei auf die Homepage von Weld verwiesen (s. o.).

Wichtig ist, dass CDI im Allgemeinen das Thema Dependency Injection standardisiert und Weld im Speziellen diesen Standard sowohl für "ausgewachsene" Applikationsserver als auch für Servlet Engines implementiert.

Ergänzt wird Weld durch "Seam Solder", welche als portable lib nützliche Tools bereitstellt, um CDI zu erweitern.

Aus meiner Sicht sollten wir Weld im Auge behalten, auch wenn zurzeit kein konkretes Einsatzgebiet dafür zu existieren mag.

Tag 5: 10:45 - 11:45 - WebSockets meet JavaServer Faces

Von Matthias Wessendorf

Dieser Vortrag schloss die Lücke, die nach dem Vortrag der Kaazing-Leute klaffte. Die offene Frage war: "Was ist auf der Serverseite notwendig?"

Serverside WebSocket Support:
  • Node.js
  • Kaazing Gateway
  • Jetty 7 and 8
  • Glassfish 3.1
  • Resin
Matthias Wessendorf führte in die Grundlagen der Websockets ein. Normalerweise entlarvt das typische Deutsch-Englisch den Sprecher als "Kraut", doch dieser beherrschte die deutsch-akzent-freie Aussprache.

Richtig interessant wurde es, als die Verwendung von Websockets im Zusammenspiel mit JSF2.0 und Atmosphere gezeigt wurde.

Er versprach mir die Codebeispiele noch zu veröffentlichen.


Tag 5: 10:45 - 11:45 : Apache Camel, a powerful open source integration framework

Wenn Apache Camel nur halbwegs das hält, was Titel und Inhalt dieser Veranstaltung versprachen, dann ist dieses Framework definitiv ein "must have"!

Camel ist ein frei verfügbares Business Integration Framework. Es bedient also die Notwendigkeit in vielen Unternehmensanwendungen, andere Komponenten oder Systeme ansteuern und integrieren zu müssen.

Die Muster, nach denen dies geschieht und die nichtfunktionalen Anforderungen, denen man sich bei der Integration konfrontiert sieht, sind über viele Unternehmensanwendungen betrachtet vergleichbar. Und so tritt Camel an, einem diese "Grundlast" auf vereinheitlichte Weise zu nehmen.

Die theoretische Grundlage bilden die sogenannten Enterprise Integration Patterns, wie sie in der einschlägigen Literatur beschrieben sind (das Standardwerk zu diesem Thema findet man hier). Im wesentlichen werden hierbei zur Beschreibung Symbole mit einer bestimmten Semantik eingesetzt und auf diese Weise Rezepte zur Lösung bestimmer (Standard-)Probleme formuliert. Camel bietet die Verwendung dieser Patterns auf unterschiedliche Weise an:
  • Als DSL, programmierbar in XML, Java, Groovy und Scala
  • Über eine GUI, welche diese Symbole zur "Programmierung" anbietet
Jeder darüber beschriebene Integrationsschritt folgt dem EVA-Prinzip: Eingabe - Verarbeitung - Ausgabe. Stark vereinfacht nennt man so eine Verarbeitungskette Route, in der Eingabe und Ausgabe die Endpoints und die Verarbeitung durch Predicates beschrieben werden.

Camel erhebt den Anspruch, auf vielen Gebieten "einfach oder "leicht" zu sein:
  • Im Wesentlichen wird die Laufzeitumgebung durch eine handvoll JARs definiert. Es ist kein Laufzeit-Container notwendig, wenngleich möglich.
  • Es gibt eine große Zahl an Komponenten, die eine Reihe von Anwendungsfällen, Zielsystemen und Konvertern abbilden, welche aber auch durch eigene Lösungen erweitert werden können.
  • Die Konfiguration ist einfach (s. o.).
  • Die transportierten Daten basieren nativ auf Java POJOs. Konvertierungen in ein anderes Datenformat muss nur im Bedarfsfall erfolgen.
  • Camel arbeitet gut mit Spring zusammen.
Hinzu kommt eine umfangreiche online verfügbare Dokumentation, die definitiv Appetit auf mehr macht.

Tag 5: 11:50 - 12:50 - ElasticSearch - You Know, for Search

Von Shay Banon

Der Letzte Talk auf der Devoxx zum Thema ElasticSearch die Suchmaschine für die Cloud.

So nebenbei ... Die Cloud ... hat die irgendwer mal gesehen? Ist das SkyNet? ;-)

Der Vortragende hat einen Vortag im Style einer Consolenausgabe abgeliefert und erklärte die Basics am Beispiel eines Online-Bookstore der Bücher und CDs anbietet.

Das Ganze sah nach einer mächtigen Software aus die mit extrem großen und kaum vorstellbaren Datenmengen (Bereich: terra- bis petabyte) operiert.

Zwei Dinge noch:
  • exposes lucene searches via json
  • version 0.13 BETA - wird jedoch produktiv eingesetzt


Tag 4: 16:40 - 17:40 : Implementing Emergent Design

Übersetzt man emergent und überträgt dies auf das Thema dieses Vortrages, dann könnte der Votrag auch wie folgt überschrieben sein: "Wie man in der Softwreentwicklung ein Design entstehen und wachsen lässt."

Ein Problem in der Softwareentwicklung - vielleicht sogar das Hauptproblem - liegt darin, dass wir zu Beginn eines Softwareprojektes nahezu nichts über die Anwendungsdomäne wissen und sich das notwendige Wissen erst mit der Zeit entwickelt. Idealerweise warten wir also sehr lange (unendlich lange), bis wir genug für die Umsetzung wissen. Dieses Vorgehen ist leider nur bedingt akzeptabel.

Um dieses Thema greifbarer zu machen, zitiert der Vortragende den ehemaligen Chef-Philosophen der US-Regierung Donald Rumsfeld:

"Es gibt bekanntes Wissen. Das sind Sachen, von denen wir wissen, daß wir sie wissen. Es gibt bekanntes Unwissen. Das bedeutet, es gibt Sachen, von denen wir wissen, daß wir sie nicht wissen. Aber es gibt auch unbekanntes Nichtwissen. Das sind Sachen, von denen wir nicht wissen, daß wir sie nicht wissen."

Diese Unwissenheit macht es in der Softwareentwicklung schwer, ein von Anfang an tragfähiges Design zu entwickeln, geschweige denn ein Design, welches sich leicht an den Wissenszuwachs während der Projektlaufzeit anpassen lässt.

Daher zwei weitere seiner Kernaussagen:
  1. Design ist das Zeug, welches man später nur schwer verändern kann.
  2. Architektur ist, sowenig wie möglich von diesem schwer veränderbaren Zeug zu verwenden.
Das heisst nicht, auf Design zu verzichten. Es heisst lediglich, sein Design auf das aktuelle Wissen um die Anwendungsdomäne zu beschränken und daraus eine Gesamtarchitektur zu entwickeln.

In dem Vortrag wurde zwischen essential complexity (also der Anwendungsdomäne natürlicherweise innewohnenden Komplexität) und accidential complexity (also der durch fehlerhafte Designentscheidungen hinzugefügten Komplexität) unterschieden. Beispiele fur letzteres sind
  • Zuviele Anwendungsschichten
  • Zuviel Delegating oder Proxying
weil man sowas vielleicht später mal brauchen könnte. Genau das ist zu vermeiden aber wie kann man den geschilderten Problemen als begegnen?

Die Vorschläge hierzu sind so brilliant wie einfach:
  1. Test driven design: Hier geht es mehr um das Design als um das Testen. Durch den Aufbau von Unit Tests verschafft man sich erstmal ein besseres Verständnis von dem, was der eigentliche Code leisten soll. Man bricht fast automatisch die Zielklassen in kleinere Einheiten herunter und erreicht dadurch eine bessere Abstraktion. Konsequenz: Weniger accidential complexity. Dieses Vorgehen sollte besonders bei neuem Code angewendet werden.
  2. Refactoring: Es gilt das Prinzip von der collective code ownership, d. h. jeder darf den Code des anderen ändern. Durch Refactoring sollten in bestehendem Code frühzeitig veraltete Abstraktionen und grundsätzlich schlechter Code so schnell wie möglich korrigiert werden (Zitat: "fix broken windows whenever you see them"). Andernfalls dienen solche Codebestandteile früher oder später als vermeidlich brauchbare Vorlage für neuen Code (z. B. in heißen Phasen).
  3. APIs und DSLs: APIs Beschreiben die Schnittstellen zu Teilkomponenten, Alleine sich darüber Gedanken machen zu müssen kann schon dazu führen, dass die Fassade eine Teilkomponente für den Aufrufer leichter und eingängiger bedienbar wird und sich die Komponente nur auf das beschränkt,wofür sie gedacht sein soll. Das Ergebnis kann in eine DSL münden, welche die Verwendung der Komponente ausdrucksstärker und (typ-)sicherer macht. Dies geht einher mit Punkt 1.
 Ein Vortrag, der zum Nachdenken anregt und deren Vorschläge einfach nur noch umgesetzt werden müssen. :-)

Tag 4: 15:10 - 16:10 : Hadoop, HBase, and Hive in Production

Früher war der "Feind" Microsoft. Dann hat Google diese Position eingenommen. In letzter Zeit bemüht sich Facebook intensiv im diesen Titel. Mit Erfolg, wie die regelmäßigen Pressemitteilungen über dieses Unternehmen verdeutlichen. ;-)

Diese Session ist von Facebook. Ich bin also für eine Stunde in der Höhle des Löwen und höre mir an, wie die Datenkrake hinter der "Gefällt mir"-Fassade funktioniert.

500 Millionen aktive Nutzer monatlich wollen technisch verwaltet werden. Die damit verbundene Datenmenge übersteigen ein wenig jenes Datenvolumen, mit dem wir in unseren Projekten arbeiten müssen.

Andere Anforderungen an das Mengengerüst verlangen nach anderen Lösungen für den Umgang damit. Klassische Datenbanken mit klassischen Abfragesprachen helfen hier nach Aussage des Vortragenden wenig.

Massive Parallelisierung gepaart mit einem modifizierten Datenspeicherung und entsprechender Datenabfrage-"Sprache" beschreiben abstrakt den gewählten Lösungsansatz. Konkret setzt Facebook dabei auf folgende Werkzeuge:
  • Aggregation von RDBMS-Knoten über Scribe
  • Verteilte Datenspeicherung über Apache Hadoop
  • Verteilte Dateiverwaltung über das Hadoop Distributed File System HDFS
  • Datensuche und -verarbeitung über Hadoop MapReduce
  • DataWarehousing auf Basis von Apache Hive
Für uns ergibt sich der Einsatz (noch) nicht. Ein Blick über den Tellerrand und das Wissen um andere Konzepte rund um Datenhaltung und -verarbeitung machten diesen Vortrag aber wertvoll.

Tag 2: 09:30 - 12:30 - Dive into Android

Der Vortrag wurde von Romain Guy und Chet Haase vorgetragen, wobei Romain „Layouts“ und Chet „Graphics“ vorgetragen hat. Der Vortragstil war eine Mischung aus Präsentations-Slides und Live-Coding-Demos.

Layout und bzw. die View-Beschreibung erfolgt bei Android in XML.
  • Layouts sind wichtig aufgrund der verschiedenen Displaysgrößen
  • Layouts sind nicht pluggable
  • Layout extends ViewGroup
  • Parameter sind Kindelement des Layouts (im XML)
Absolutes/Fixes Layout
Feste Masseinheiten: dip,px etc.

  • match the parent's size
  • Parameter: MATCH_PARENT bedeutet „big as parent“
  • best fit: WRAP_CONTENT
Es stehen darüber hinaus vier Layouts zur Wahl
  • FrameLayout
  • LinearLayout
  • RelativeLayout
  • TableLayout

Die sogenannte Layout-Geometry bzw. das Box-Layout kam mir bekannt vor. Ähnlich wie beim CSS gibt es margin und padding. Die „gravity“, die Position innerhalb der Box, war mir neu.
Romain meinte, das das Liniear Layout das meist genutzte Layout ist. Außerdem solle man nicht zu viele Layouts schachteln.

  • care at Version 1.5

Table Layout
  • no Table-Widget just layout

Hierarchieviewer als Debug-Tool
Stellt die Hierarchie des Layouts dar.
  • nicht in Eclipse integriert
  • Funktioniert nicht für Enduser-Phones
  • Feature: Export als Photoshop-File => COOOL

Part 2 : Graphics and Animations
Custom Views and Containers für Coole Effekte (Spiegel etc.)

How = Paint
What = Canvas
Where = Bitmap, Surface

  • Stroke props- width,color
  • Fill props- gradient
  • Quality - anti-aliasing, dithering, bitmap scaling

Verbunden mit dem Destination

  • images
  • rendering buffer
  • creation
  • drawing to
  • drawing from

Tip: „reuse objects for performance“

Graphical effects
  • rich background
  • alpha ramps
  • 3d light effeccts
  • Gradiend effect

Animation Effects
Help user understand whats happening
  • transition between states
  • indicate actions and consecuences
  • indicates changes in state

Optimize Techs
mobile not desktop
  • slow cpu's
  • less memomory

opt: bitmaps
  • pre-scale
  • cache complex rendering
  • create bitmaps in device depth

  • avoid garbage
  • make background view opague
  • avoid re-creating objects
  • dont over-invalidate
  • avoid costly operations on the UI thread -> AsyncTask is your friend
  • reduce layout nesting
  • avoid costly rendering during animatgionans -> do it fast, max. half sec.

  • traceview for profiling
  • hierarchyviewert container visualization
  • layoutopt - static analysis on xml-files as extra tool



android-developer site:

Donnerstag, 18. November 2010

Tag 3: 15:10 - 16:10 - Testing RESTful Web Services

Von Jan Algermissen

Von diesem Vortrag habe ich mir erhofft mehr zum Thema testen von REST-Services zu erfahren. Die Slides sahen nett aus, aber inhaltlich kam leider nichts praktisches bzw. verwertbares heraus.

Herr Algermissen, der seinen Firmensitz übrigens auch in Hamburg hat, versprach seine Slides, als auch seinen theoretischen Ansatz/Test-Algorithmus, über SlideShare zu veröffentlichen.

Leider konnte ich bisher noch nichts finden.

Blog des Vortragenden:


Tag 4: 13:15 - 13:30 : loadUI : A uniquely cool approach to Interactive Distributed Load Testing

loadUI ist ein Performance-Testing-Tool. Technisch basiert es auf JavaFX und ermöglicht es, über eine interaktive GUI per Drag'n'Drop Last-Tests zu erzeugen und auszuführen.

Die GUI macht einen sehr guten Eindruck: Diverse Komponenten zur Lastteststeuerung (u. a. Anzahl Requests, Latenzzeiten) lassen sich beliebig zusammenstöpseln und deren Ergebnisse protokollieren. Ein loadUI agent erlaubt die Steuerung verteilter Lasttests. Weitere Komponenten lassen sich auf einfache Weise über eine Groovy-DSL ergänzen. Im Unterbau ist soapUI nutzbar

Und all das in Echtzeit, während der Lasttest läuft.

Fazit: Must have!

Tag 4: 12:00 - 13:00 - Android UI Development: Tips, Tricks, and Techniques

Von Chet Haase und Romain Guy

Mein zweiter Vortag zum Thema Android. In diesem Talk ging es eher um "do's and dont's". Es wurden die Themen "Garbage prevention", Tools

Wieder ein paar Zitaten aus dem Talk:

  • "avoid object creation"
  • "recycle bitmaps"
  • "instead of myBitmap=null use myBitmap.recycle()"
  • "dont wait for the finalizer"
  • "be aggressive on deallocating objects"

Tools zum Thema Speichermanagement/-monitoring

  • Tools Allocation Tracking
  • Debug.startAllocationCounting()
  • Heap-Analysis mit "hat" (vom Java Oracle SDK) mit hprof-converter
  • MAT Memory-Analysis-Tool for Eclipse

Tools für Layouting

  • HierarchieViewer
  • LayoutOpt

Verhindern von "Memory Leaks"

  • "careful with context"
  • "care with static fields"
  • "avoid non-stsatic inner classes"
  • "use weak references"
Dont block the UI
  • Single-threaded UI
  • Dont block the UI-thread
  • ANR* after 5 sec - dump on sd-card
  • Handler posts messages in event-queues
  • Use AsyncTask - they are WorkerThread with callbacks

* Application not responding


Tag 4: 12:00 - 13:00 : Grails 1.3 Update

Grails ist eines von vielen Web-Frameworks, die hier auf der Veranstaltung vorgestellt werden. Es basiert auf der Sprache Groovy, welche wiederum auf der JavaVM aufsetzt.

Der Vortrag stellte die Neuerungen vor, die in Version 1.3.x in Grails eingeflossen sind. Eine Zusammenfassung findet man hier.

Tag 4: 16:40 - 17:40 - Defective Java: Mistakes that matter

Von William Pugh

William Pugh ist Professor an der Uni von Maryland und ist bekannt als ein JavaPuzzler. Ein Puzzler-Talk hat er nach dem Talk zusammen mit Joshua Bloch in einem anderen Saal veranstaltet.

William Pugh zeichnet sich als Verantwortlicher für das FindBugs-Projekt. Er erzählte von seiner Arbeit, der Unterstützung bei Google, mit seinem Tool FindBugs und lieferte in diesem Zusammenhang interesannte Zahlen....

An dieser Stelle zähle ich das gesagte Stichwortartig auf:

  • statisic analysis can't find all bugs
  • statisic analysis is limited
  • @Google: 4000 bugs in google-server-code rang 1-12
  • @Google: 8000 reviews by 800 engineers
  • @Google: more than 1000 nullpointer bugs found
  • @Google: presubmit check with find-bugs
  • @Google: when you want to commit a change you need a code review
  • 5-10% find software quality mistakes
  • 80% coverage is a good number
  • find dead code
  • "Google has alot of dead code!"

Die Aussage von William war:

  • "Your code is imperfect!"
  • "It will never be perfect"
  • "fix it when it bites"
  • "a fix is good for you before they bit you"

Ich bin seit langem von FindBugs überzeugt, der Talk heute hat gezeugt, dass viele aus der Java-Szene FindBugs einsetzen und eine breite Akzeptanz vorhanden ist.

Von unserem heutigen Standpunkt aus, sind wir auf dem richtigen Weg. Wir machen Code-Reviews und in den Code-Reviews werden wir zukünftig auch FindBugs einsetzen.


Tag 4: 17:50 - 18:50 - Encryption Boot Camp on the JVM

Von Matthew McCullough

Der Talk handelte, wie der Titel vermuten lässt, von Verschlüsselung mit Java.
Der Stil des Vortragenden war erfrischend und die Slides grafisch ansprechend.

Die Folien kann hier anschauen.


Tag 4: 10:50 - 11:50: Comparing JVM Web Frameworks

Ein Vortragsthema, wie gemacht, um bei allen Zuschauern in Fettnäpfchen zu treten. Denn am Ende erwartet doch jeder die Antwort auf die Frage: "Wer ist das schönste im ganzen Land?"

Wie aber zu erwarten war: Eine eindeutige Antwort darauf gibt es nicht. Der Vortragende gab aber ein klares Statement ab, welches Framework NICHT zu benutzen ist:

"Don't use Struts!"

Das Problem ist aber nicht das einzelne Framework ansich: Es ist die Vielzahl an unterschiedlichsten Web-Frameworks, die eine fundierte Entscheidung zugunsten einer Lösung so schwer macht.

Konsequenz: Es ist ein Leitfaden notwendig, welcher zum einen das Vorgehen und zum anderen die Kriterien zur Auswahl eines Frameworks definieren.

Das vorgeschlagene Vorgehen sollte dabei wie folgt aussehen:
  • Führe eine grobe Vorauswahl von zu untersuchenden Frameworks durch (Bauchentscheidung)
  • Erzeuge auf Basis einer definierten Fachlichkeit je Framework einen Prototypen
  • Dokumentiere die Ergebnisse gemäß Kriterienkatalog (s. u.)
  • Präsentiere die Ergebnisse (anderen Entwicklern, Stakeholdern)
  • Stelle Dokumentation und Präsentation (anderen Entwicklern, Stakeholdern) zur Verfügung und spreche eine Empfehlung aus
 Die zugrundeliegenden Kriterien sollten dabei folgende Themen abdecken:
  • Entwickler-Produktivität
  • Entwickler-Wahrnehmung
  • Lernkurve
  • "Project health"
  • Verfügbarkeit von Entwicklern für die jeweilige Technologie
  • Job Trends (!)
  • Templating
  • Komponenten-Struktur
  • Ajax-Support
  • Plugins / Addons
  • Skalierbarkeit
  • Testing Support
  • i18n, l10n
  • Validation support (Client und Server!)
  • Multi-language support (im Sinne von zusätzlich einsetzbaren (Skript-)Sprachen)
  • Qualität der Dokumentation und der Tutorials
  • Verfügbare Bücher
  • REST Support (Client und Server!)
  • Mobile Support
  • Grad des Risikos für einen Einsatz beim Kunden
Weitere zu beantwortende Fragen beziehen sich auf die Charakteristik der zu bauenden Antwendung:
  • Handelt es sich um eine kunden-zentrierte Anwendung?
  • Muss die Anwendung Desktop-like Funktionalität bieten?
  • Handelt es sich um Multimedia-Anwendungen?
Durch eine andere Brille betrachtet gab der Vortragende folgende Empfehlung aus:
  • Handelt es sich um eine Internet-Anwendung mit hohen Zugriffs- und Benutzerzahlen? Wähle ein Request-basiertes Framework.
  • Handelt es sich um eine Internet-Anwendung hinter einer Firewall mit geringen Zugriffszahlen? Wähle ein Komponenten-basiertes Framework.
  • Handelt es sich um eine Web-Anwendung mit langer Lebensdauer (5-10 Jahre)? Wähle ein Framework mit großer Community und großem Hersteller-Support.
Nun aber wirklich Butter bei die Fische: Wer ist "Web next top framework"? Die Antwort findet man hier. Ein paar Bewertungen zu Frameworks, die auf der Devoxx behandelt, bei uns aber (noch) kein Thema sind:
  • GWT
  • Vorteile: Java-basiert, Javascript wird automatisch optimiert, einfach zu lernen, große Community
  • Nachteile: Langsames Kompilieren, schwer zu testen
  • Grails
  • Vorteile: Von Java-Entwicklern leicht zu lernen, Groovy als Basis, viele Plugins
  • Nachteile: Grauenvolle Stacktraces, Zugrundeliegendes Framework zu sehr weggekapselt
  • Wicket
  • Vorteile: Klasse für Java-Developer, gutes Binding zwischen Seiten und Views, Aktive Community
  • Nachteile: Stateful by default, Keine saubere Trennung zwischen HTML-Templates und Java-Code

Tag 4: 15:10 - 16:10 - JavaPosse Live

JavaPosse Live von Dick Wall, Carl Quinn und Joe Nuxoll

"How the f**k is the JavaPosse?"

Die Java-Posse sind vier Autoren die regelmäßig einen Podcast mit Nachrichten, Diskussionen und Interviews rund um das Java-Ecosystem veröffentlichen. Die Autoren, Tor Norbye (Sun Microsystems), Carl Quinn (Google), Dick Wall (Google) und Joe Nuxoll (Apple Inc.) sind durch ihren Podcast zu echten Stars in der Community geworden. Ihr Erkennungszeichen sind bunte übergroße Cowboy-Hüte. Der Saal war in Kürze überfüllt, die eigentliche Veranstaltung war eine Mischung aus Quatsch-sagen und machen. Wirklich Sinnvoll war der Besuch nicht, immerhin hab ich es jetzt mal live gesehen.

Tag 4: 14:00 - 15:00 - Fractal TDD - Using tests to drive system design
Von Steve Freeman

... sehr abstrakt - nicht greifbar
ideen - nichts konkretes


Tag 4: Zwischenruf: Überall Macs

Es ist kaum zu glauben: MacBook und iPhone sind dieNummer-1-Gadgets der Teilnehmer und Vortragenden. Den Härtefall aber sah ich aber gestern: Ein Besitzer eines Dell-Notebooks wollte sich wohl unbedingt zu den Mac-Jüngern zählen und hat kurzerhand das Dell-Logo mit einem Apple-Sticker überklebt.

Soweit sind Christian und ich allerdings nicht: Wir stehen zu unseren EeePC-Netbooks für 300€. Sind doch auch schön ... heul.

Tag 4: 9:30 - 10:40: The Future Roadmap of Java EE

Auch Tag 4 beginnt mit einer Keynote. Heute geht es um die zukünftigen Themen in Java EE.

Ein zentrales Thema auf der Devoxx 2010 ist Cloud Computing. Dem kann sich JEE nicht verschließen. Dabei sind die vom Java-Ökosystem mitgebrachten Randbedingungen garnicht so schlecht: Es gibt Container, Services, Security-Mechanismen, CLuster-Unterstützung, u. s. w.

Für das "Anwendungsleben in der Wolke" sind aber laut Vortragendem noch einige Herausforderungen zu meistern:
  • Strenge Anforderungen an Resource- und State-Management
  • Bessere Isolation zwischen Applikationen
  • Bereitstellung einer Standard-API für NoSQL-RDBMS, caching, ...
  • Allgemeines Monitoring

Auch die Paketierung der Anwendung muss verbessert werden, denn:
  • Applikationen sind versioniert
  • Mehrere Versionen eine Anwendung können zeitgleich nebeneinander existieren
Es ist also mit allen Aspekten rund um die Versionierung umzugehen (Installation, Upgrading, etc.). Hierzu werden in JEE 6+ entsprechende Standards geschaffen.

Hier noch ein Update zum Thema "Modularität der Javaplattform": Das Konzept dahinter wird nicht vor Java 8 verfügbar sein. Interessant wa in diesem Zusammenhang ein Hinweis, wie man sich bei Sun - äh Oracle - die Lösung des Packaging und Dependency Management vorstellt.

Wenn eine Anwendung Abhängigkeiten zu einer API in der Version 1.1 hat und diese API vom Laufzeit-Container implementiert wird, dann wird die Implementierung des Laufzei-Containers genommen. Wenn nicht, dann wird die von der Anwendung mitgelieferte Implementierung herangezogen. Ist das neu? Nein. Neu daran ist, dass das vordergründig wohl nicht mehr über
den Classpath geregelt wird, sondern auf Basis einer Konfigurationsdatei, die mit der Awnedung deployt wird. Hoffentlich lässt sich dort dann auf einheitliche Weise dieses Defaultverhalten auch wieder übersteuern (heute hat jeder AppServer hier seine eigene Logik).

Natürlich gab es auch einen Ausblick auf JSF 2.2 , welcher natürlich die umfassende Unterstützung von HTML 5 im Fokus hatte.

Und nachdem JMS seine Randnotiz bekam (Specs und API werden aufgeräumt), ging es erneut um JPA, diesmal mit einem Ausblick auf Version 2.1. Neue Möglichkeiten beim Mapping und rund um das Laden von Daten, API-Erweiterungen sowie verbesserte Querying-Möglichkeiten weden als Teil von JEE 7 sowie Standalone zur Verfügung stehen. Erste Pläne für ein JSR wird es im Januar 2011 geben.

Zum wiederholten Male wurde das Thema JAX-RS vorgestellt. Ich möchte an dieser Stelle lediglich die genannten Implementierungen und Frameworks erwähnen, die bei der Entwicklung JAX-RS-fähiger Anwendungen unterstützen.

Implementierungen, u. a.
  • Apache CXF
  • Apache Wink
  • eXo
  • Jersey
  • RESTEasy
  • ...
Frameworks, u. a.:
  • Play
  • SiteBricks
  • Scalate
  • Spring
  • VRaptor
  • ...
Fazit: Da kommt was auf uns zu. Langweilig wird's definitiv nicht, zumal einige Technologien bereits heute verfügbar sind, wenngleich noch nicht mit dem hier genannten Leistungsumfang.

Mittwoch, 17. November 2010

Tag 3: 17:50 - 18:50: HTML5 Websockets: A New World of Limitless, Live, and Wickedly Cool Web Applications

Die Firma Kaazing hatte mal wieder einen Auftritt zum Thema HTML5, genauer HTML5 WebSockets.

Grundidee: HTML bassiert auf HTTP. HTTP auf TCP. Während TCP eine Full-Duplex-Kommunikation erlaubt, gibt es bei HTTP lediglich einen Request, gefolgt von einer Resonse. Das ist bidirektional, aber nicht full duplex.

Manch moderne Web-Anwendungen benötigen für den Datenaustausch das Konzept einer Standleitung, über die Daten quasi in Echtzeit übertragen werden können. Das betrifft zum einen die Datenlieferung vom Client zum Server (mit dem Client als aktiven Part) ABER auch die Datenlieferung vom Server zum Client (mit dem Server als aktivem Part).

Letzteres ist nicht neu: Konzepte, wie "Long poll" haben zumindest den Eindruck einer server-initiierten Datenlieferung vermittelt. Mit allen damit verbundenen Nachteilen, denn es ist nach wie vor HTTP mit dem damit verbundenen Overhead.

WebSocket ist ein Ansatz das Problem zu lösen. Grundidee:
  • Ein Client schickt einen HTTP-Request mit einer Upgrade-Anforderung auf WebRequest
  • Der Server schickt den Return-Code 101 mir dem unterstützten WebSocket-Schema
  • Client und Server kommunizieren ab dann rein über TCP
Hierzu sind auf Client- und Serverseite natürlich Hilfsmittel notwendig:
  • Der Browser muss HTML5 WebSocket unterstützen: Chrome 4.0+, Safari 5.0 & iOS4, Firefox 4 Beta, Opera 11 Alpha leisten dies. (Auf Nachfrage: IE9, eventuell) Auf kann man den eigenen Browser testen.
  • Die Webseite im Browser benötigt Javascript-WebSocket-APIs, wie z. B. Stomp, XMPP, AMQP
  • Auf Serverseite blieben die Vortragenden eine Antwort schuldig. Schade.
Hier zeichnet sich eine interessante Entwicklung ab, die weiterverfolgt werden sollte, obwohl die Browser teilweise noch nicht soweit sind und obwohl uns vielleicht noch die Anwendungsfälle fehlen.

Tag 3: 16:40 - 17:40: Spring 3.1: Themes and Trends

Jürgen Hoeller stellte auf bewährte Weise bekanntes und neues rund um Spring 3 dem zahlreich erschienenen Publikum vor.

Er begann mit einem "Rückblick" auf Spring 3.0 (aus unserer Sicht ist das sowas wie Zurück in die Zukunft). Der große Schwerpunkt: Annotations für alles und nichts.
  • @Value("#{aBean.aProperty}") als Fallback, wenn für annotierte Methode keine externe Konfiguration vorliegt.
  • Standard-Annotations: @ManagedBean, @Inject, @TransactionAttribute
  • REST-Support: @RequestMapping, @PathVariable
  • Portlet 2.0 Support: @Controller, @RequestMapping, @ActionMapping, @EventMapping
  • Declarative model validation (JSR-303): @NotNull, @Past (bei Date!), @Valid
  • Annotation-driven number/date formatting and parsing
  • Scheduling: @Scheduled(cron="0 0 12 * * ?") auf Methode (!), @Async
Hinzu kommen die Unterstützung von JEE 6 (speziell für JPA 2) sowie JavaConfig (für spezielle Konfigurationsaspekte, die nicht über die Standard-Spring-Konfiguration lösbar sind).

Dann kam er Blick nach vorne, auch wenn das meiste noch in Arbeit sei.

Und gleich mit dem ersten Punkt sprach mir Jürgen aus dem Herzen: Environment profiles for beans. Hierhinter verbirgt sich die Möglichkeit Bean-Definitionen zu grupperien und einem bestimmten Profil zuordnen zu können. Mögliche Profile sind

  • Development, Testing, Produktion
  • Unterschiedliche Deployment-Umgebungen
Dies ist sowohl über die Annotation @Profile oder in der XML-Konfiguration <beans profile="..."> möglich. Aktiviert wird ein Profil beispielsweise beim Starten der JVM mittels -DspringProfile=...

Mit @Connfiguration wird Javas-basierte Konfiguration unterstützt. Typische Einsatzgebiete sind

  • AOP-Konfiguration
  • Transaktionen
  • Scheduling
Die Abstraktion des Cachings wird nun mit Leben gefüllt, damit über ein einheitliches Modell auch verteilte Caches angesteuert werden können. Das Caching wird über die Annotationen @Cacheable und @CacheEvict konfiguriert und über <cache:annotation-driven> aktiviert.

Das Session-Management wird ebenfalls renoviert. Hier sollen Lifecycle und Speicheroptionen flexibilisiert werden (Stichwort: Conversation)

Früher oder später werden wir die Version 3.1 auch verwenden. Bis dahin müssen wir uins in Geduld üben, zumal das Datum der Veröffentlichung noch nicht klar scheint.

Tag 3: 15:10 - 16:10: Vaadin - Rich Web Applications in Java without Plug-ins or JavaScript

Vaadin ist yet yet yet another Web framework, welches ein einfaches rein serverseitiges Programmiermodell unter Verwendung von GWT anbietet. Die wesentliche Eigenschaft von Vaadin ist, dass sämtliche Technologien, die den Client oder die Kommunikation zwischen Client und Server betreffen (GWT, JSON, Ajax, ...)  durch Vaadin vor dem Entwickler verborgen werden.

Vaadin bietet eine große Palette von fertig vorkonfektionierten Kompopnenten an, die hinsichtlich ihres Layoutings, aber auch hinsichtlich ihres Verhaltens (z. B. Lazy Loading, Paging) modernen Ansprüchen in der Web-Entwiclung genügen.

Die Entwicklung kann in Eclipse vorgenommen werden. Das Vaadin-Plugin stellt die gängigen Wizards zur Projekt- und Code-Erzeugung bereit. Beeindruckend ist der Visual Editor, obwohl er noch im Experimentierstadium ist.

Als Zieltechnologien werden
  • Servlet Engines
  • Portlet Engines (1.0 und 2.0)
  • Google App Engine

Als guter Startpunkt dient Im Wiki befinden sich auch Informationen zur Verwendung von Spring in Vaadin.

Vaadin ist definitely worth a try. ;-)

Tag 3: 12:00 - 13:00: Java Persistence 2.0

Die Java Persistence API in der Version 2.0 ist Teil von JEE 6, aber auch Standalone einsetzbar. Sie ist Bestandteil von GlassFish v3. Als Referenzimplementierung dient EclipseLink.

Der Vortrag beschreibt die wesentlichen Neuerungen von JPA 2.0. Hier einige Ausszüge.

In Collections der Art Collection<AClass> kann AClass eine Klasse, aber auch ein Elementartyp sein. Durch die Verwendung von @ElementCollection plus @Embeddable wird in der Datenbank zusätzlich eine Mappingtabelle angelegt, welche neben der Id entweder eine Spalte für den Elemntartyp oder Spalten für sämtliche Attribute von AClass enthält. Das genaue Verhalten ist durch weitere Annotations konfigurierbar.

Die Annotation @OrderColumn erzeugt extra Spalte, über die sich eine Sortierung abbilden lässt. Eine Laufzeitsortierung erlaubt @OrderBy.

Die Java Persistence Query Language (JPQL) wird sprachlich erweitert um

  • CASE
  • "Restricted polimorphism"
  • "Collection valued input parameter"
Der Vortrag hat auch bekannte und neue Interfaces der Criteria API vorgestellt, als da wären:
  • CriteriaQuery
  • CriteriaBuilder
  • Root
  • Join, ListJoin, MapJoin
  • Path
  • Subquery
  • Parameter
  • TypedQuery
  • Tuple
  • TupleElement
Neu ist die Metamodel API, welche eine abstrakte "schema-level" Sicht auf die Managed Classes der Persistence Unit ermöglicht. Diese View wird im Hintergrund automatisch generiert (Zugriff via EntityManagerFactory.getMetamodel()), ist aber im Wesentlichen nur für Frameworks sinnvoll.

Zum Locking lässt sich folgendes zusammenfassen.

  • Optimistic locking erfolgt auf Basis von @Version
  •  Insgesamt wurde die Parametrierung des Lockings von der Namensgebung her vereinheitlicht: OPTIMISTIC(READ), OPTIMISTIC_FORCE_INCREMENT(WRITE), PESSIMISTIC_READ, PESSIMISTIC_WRITE, PESSIMISTIC_FORCE_INCREMENT
  • EntityManager: lock, find, refresh
  • Query methods: setLockMode, setHint
  • NamedQuery Annotation: lockMode element
  • PessimisticLockException
  • LockTimeoutException
Die Validierung basiert auf JSR303 und kennt als Lifecycle-Methoden PrePersist, PreUpdate, PreRemove.

Und last but not least wurde auch der 2nd Level Cache modernisiert:

  • APIs und Kontroll-Optionen wurden hinzugefügt/erweitert (aus Portabilitätsgründen)
  • In der API tauchen nun Methoden auf wie evict, evictAll, contains
Früher oder später werden sämtliche Container-Hersteller JPAS 2.0 vollständig unterstützen, spätestens, wenn sie sich JEE 6-konform nennen wollen. Das Persistenzmodell wird auf mächtige Weise vereinheitlicht und relativ leicht bedienbar. Wenn möglich, dann in bestehenden aber auf jeden Fall in neunen Anwendungen einsetzen.

Tag 3: 10:50 - 11:40: The State of the Web

Diese Session lieferte einen globalen Überblick über vermeidliche Trends der Vergangenheit und über aktuelle Trends, mit denen sich die Web-Zukunft gestalten lässt.

Immer wieder wurde vom Potential von HTML 5 geredet, was dieser Standard selber liefert und welche Technologien mit zu deren Ökosystem gehören. Nahrhafte Details kamen aber nicht zum Vorschein.

Was hängen blieb, waren lediglich Informationen zum Nachschlagen:

Tag 3: 10:00 - 10:50: Java SE: The road ahead

 So. Und jetzt Butter bei die Fische! Wo will Oracle mit Java hin?
Unter den Zynikern war vorher klar, dass Oralce solange an Java festhält, wie sie aus dem Rechtsstreit mit Google Geld ziehen können. :-)

Die Botschaft dieser Keynote war aber eine deutlich andere: Oracle hält in jedem Fall an Java fest. Aussagen in der REihenfolge der Gewichtung:
  1.  Für Oracle ist Java die Nummer-1-Technologie. Man arbeite selber sehr viel mit Java und hat eine große Zahl an Entwickler-Know-how im eigenen Hause, welches man durch eine Abkehr von Java nicht verlieren (bzw. vernichten) möchte.
  2. Man hofft durch Java-basierte Plattformen und Frameworks indirekt Profit daraus zu erzeugen.
  3. Man hofft durch Beratungsleistungen direkt Profit aus aktuellen und zukünftigen Entwicklungen rund um Java zu erzielen.
  4. Reduzierung der Entwicklungskosten (siehe auch 1.).
 Darüber hinaus engagiert sich Oracle auf folgenden Sektoren intensiv:
  • JCP
  • openJDK
  • Partner für openJDK (u. a. IBM, Apple)
Technisch besteht das Java-Engagement in der Entwicklung und Planung der Java-Versionen 7, 8 und 9. Inhalte:
  • Neue Sprach-Features zur Verbesserung der Produktivität (Code-Vereinfachungen) und Performance (Unterstützung von Mehrkern-Prozessoren). Hier ist besonders das Lambda-Projekt zu nennen, welches u. a. Closures in die Java-Welt bringt.
  • Immutable Ojects sollen zukünfirg mittels "value class ..." deklariert werden können.
  • Aprospos Sprache: Typ-Informationen aus Java Generics werden aktuell via Type erasure auf Bytecode-Ebene gelöscht. Oracle will dies ändern! Mit einer Technik namens "Type reification" sollen diese Typinformationen zukünfitg erhalten bleiben! Das wird ein tiefer Eingriff in die VM.
  • Die Java-Plattform soll modularer werden. Java-Anwendungen sollen leichter in unterschiedliche Zielsysteme integrierbar sein. Hier spielt das Jigsaw-Projekt eine wichtige Rolle.
  •  Zur besseren Integration von Nicht-Java-Sprachen auf der JVM wird das DaVinci Machine-Projekt voran getrieben.
  • Oracle und Sun sind nun eine Firma mit zwei JVMs. Diese JVMs sollen zukünftig zu einer gemeinsame VM namens Hotspot zusammenwachsen.
Zum Zeitplan: Mit Java 7 ist  am 28.07.2011 (genaues Datum!) zu rechnen. Java 8 wird nicht vor Ende 2012 kommen.

Tag 3: 9:30 - 10:00: Welcome and Intro

Nach den ersten beiden University Days beginnt heute die eigentliche Konferenz.

Die Begrüßung beginnt mit Statistiken und Selbstbeweihräucherung:
  • 3000 Teilnehmer
  • aus 40 Ländern (u. a. sei jedes europäische Land mit mindestens einem Teilnehmer vertreten; wichtig zu wissen)
  • bekommen 127 Tracks
  • von 110 Vortragenden geboten.
Da heisst es für Veranstalter und Teilnehmer den Überblick zu wahren. Hilfreich ist das Conference Portal (CFP Client), welcher auf verschiedenen Plattformen (u. a. iPhone, Android) zur Verfügung steht und in unterschiedlichen Sprachen (u. a. Scala) entwickelt wurden. Sämtliche Clients sind auf der Devoxx-Seite verfügbar.

Wirklich wichtig:, das Portal, worüber die Sessions als Videos abgerufen werden können, ist in Version 4 erschienen. Zu einem Unkostenbeitrag von 79€ im Jahr erhält man Zugriff auf sämtliche Beiträge von diesem Jahr. Die Sessions der vorherigen Jahre sind inzwischen frei verfügbar.

Auch hier stehen mehrere Clients zur Verfügung (gratis), u. a. für Android aus dem Android Market (Suchbegriff: "Parleys"). Hab's ausprobiert: Cool!

Anregung: In Zukunft die Gebühr für Parleys abdrücken und Kosten für Reise und Teilnahme sparen.

Dienstag, 16. November 2010

Tag 1: 17:25 - 17:55 - VisualVM - multiplatform versatile monitoring solution von Jaroslav Bachorik

Der Talk dauerte nur eine halbe Stunde und sollte zeigen wie einfach man das im JDK enthaltene Tool mittles Plugin erweitern kann. Leider ist dem Sprecher, in der Kürze der Zeit, nicht gelungen das Vortragsziel zu vermitteln.
Schade ;-(

Die einzigen Notizen die ich mir zum Vortrag gemacht habe:
  • Visual VM
  • NetBeans 6.9.1
  • Plugin für VisualVM

Tag 1: 16:45 - 17:15 - Beautiful Java EE: URL-rewriting for the next generation web-user von Lincoln Baxter III

Schnell stellte sich heraus das es um PrettyFaces geht, das uns in der Entwicklung schon begegnet ist. Das einzige Neue für mich war, dass PrettyFaces auch ohne JSF sinnvoll eingesetzt werden kann.
Der Talk war kurz und leider ist der Funke nicht über gesprungen.


Tag 1: 09:30 - 12:30 - Productive Programmer von Neal Ford

Neal Ford ist Software Architekt bei ThoughtWorks. ThoughtWorks ist u.a. auch bekannt für die OpenSource-Produkte wie CruiseControl und Selenium. Neal ist Author von sechs IT-Büchern u.a. passend zum heutigen Talk das Buch "The Productive Programmer".

Der Vortrag war in verschiedene Themenschwerpunkt unterteilt:

Hier ging es um die Produktivitätssteigerung durch Erweiterung eingesetzter Software durch Plugins bzw. Addons. Neal meinte sobald ein Entwickler gezwungen wird die Hände von den Tasten zu nehmen (um z.B. die Maus zu benutzen), würde seine Produktivität erheblich sinken.
Das Mantra war: "use short-cuts"
Er empfahl sogar ein Eclipse-Plugin namens Mousefeed, das sich meldet wenn der Entwickler in einem Menü etwas mit der Maus auswählt anstatt es mit einem Short-Cut zu aktivieren. Das Plugin soll den Entwickler "zwingen" die Short-Cuts zu lernen.

Getreu dem DRY-Prinzip empfahl er dem Entwickler "Every time you type things 3 times, do a template". Auch für Emails die sich häufig wiederholen, aber nur wenig Änderungen beinhalten, wie z.B. unsere "Testsystem XX wird in kürze heruntergefahren *EOM*"-Emails sollten "Templatisiert" werden.
Ich habe mir vorgenommen zumindest das Plugin Mousefeed zu installieren, um zu sehen welche Short-Cuts noch nicht angekommen sind. Denn das Short-Cuts erheblich schneller sind, steht für mich außer Frage. Es soll jedoch Kollegen(-innen) geben die sogar ein Copy-To-Clipboard mir der Maus ausführen.
Die o.g. Info-Emails sind dank Olaf auch mit einem Klick erzeugt - danke.

Bei diesem Themenschwerpunkt ging es um den Arbeitsplatz als solches.

Ein anderes Thema war "locus of attention - flow-state" das den Tenor hatte "find a way to make it quiet". Damit waren Meldungen wie die Windows-Ballon-Tips oder Messanger-Meldungen und Email-Notifications gemeint. "Thats why developer uses mac, it shut-up and stay quiet."

Baue kleine Tools für wiederkehrende Aufgaben des Alltags. Suche Tools die dir die Arbeit abnehmen können. Oder wie Du Dein Leben einfacher machen kannst indem du die QS schulst wie Selenium-Tests zur Fehler-Beschreibung einer Webanwendung geschrieben werden können. So das auf beiden Seiten Zeit gespart werden kann.
Manta an dieser Stelle: "Automate what is to automate"

Gern würde ich alles erläutern, daß würde aber den Rahmen dieses Blogs sprengen.

Die andere Themen waren:
  • dont shave yaks!
  • composed-method
  • test-driven-development
  • top-10-code-smells
  • question authority
  • slap
  • polyglott programming
  • every nuance

Ich war von dem Vortrag begeistert und habe beschlossen allen Vorträgen meine subjektive Bewertung zu geben.
Diese Vortrag erhält von mir glatte fünf Sterne (höchst Zahl) und legt die Messlatte für die anderen kommenden Vorträge recht hoch.

Glückwunsch an Neal Ford für den gelungenen Vortrag.

More to come...

Der erste Tag stellte sich als sehr anstrengend heraus, sodass ich noch keine Zeit gefunden habe etwas zu den Vorträgen zu schreiben.

Jörn gibt ein Blog-Tempo vor, das es mir schwer macht mit zu halten. Da ich gestern todmüde ins Bett gefallen bin, hab ich mir vorgenommen wenigstens heute etwas zu berichten (und sei es nur vom Vortag).

Tag 2: 19:00 - 22:00: BoFs (eigentlich)

Grundsätzlich ging es auch heute wieder um interessante Themen:
  • Scala
  • Scalable data structures for Java
  • Dealing with Asynchronicity in Java™ Technology-Based Web Services
Leider ist das Format der BoFs bisher ausschließlich Q&A. Und so kommt es dann, dass die gestellten Fragen sehr spezialisiert sind und bei mir selten zu neuen Erkenntnissen bezüglich des jeweiligen Themas führen. Schade eigentlich.

Daher werde ich an den folgenden Tagen mit hoher Wahrscheinlichkeit an den BoFs nicht mehr teilnehmen. Stattdessen werde ich lieber die Zeit nutzen, das bis dahin in den "normalen" Sessions vermittelte Wissen noch mal aufzubereiten und die Ergebnisse an dieser Stelle zu präsentieren. Ich glaube, davon haben alle mehr. Ich zum Beispiel habe mehr Schlaf. ;-)

Tag 2: 17:25 - 17:55: Scalable and RESTful web applications: at the crossroads of Kauri and Lily

Am Ende der Session habe ich mich gefragt: Musste ich Kauri und Lily vorher kennen? Dann habe ich mich gefragt, ob ich es in Zukunft kennen muss. Ich habe mich bei beiden Fragen für "nein" entschieden.

Damit die Infos trotzdem nicht verloren gehen, hier die Links zu den Produkten
Wer mehr wissen möchte, kann dort nachlesen.

Tag 2: 16:45 - 17:15: Groovy/Grails Development in Eclipse

Ich bin erleuchtet! Bisher nahm ich an, dass IntelliJ IDEA und Netbeans diejenigen IDEs sind, welche die beste Unterstützung für die Entwicklung von GRoovy-/Grails-Applikationen sind. SpringSource hält dagegen und baut deren Tool Suite (STS), welche unter Eclipse läuft massiv aus.

Die zahlreichen Demos zeigten eindrucksvoll das aktuelle Feature Set, welches als Groovy/Grails Extensions über das STS Dashboard in die Eclipse-Umgebung geholt wird. Dabei wurde sehr großer Wert darauf gelegt, dass sich die Groovy-Entwicklung genauso anfühlt, wie die Java-Entwicklung. Aus der IDE heraus scheint nun folgendes "seamless" möglich zu sein:
  • Projekt-Wizard für Groovy/Grails
  • Syntax Highlighting
  • Refactoring
  • Compile, Run, Test und ... Debugging (!) mit guter Anzeige der Variablen-Inhalte
  • Script Shell
  • Auto-Deployment auf Springs eigenen tc Server
  • Hot-Deployment
  • Nahtlose Integration in Java-Code

Aktuell wird Groovy in den Version 1.6 und 1.7 unterstützt. Aus der Ferne war die Unterstützung für Grails 1.3.5 erkennbar.

Jetzt habe ich eine Sorge weniger, wenn es darum geht, Groovy/Grails intensiver in unseren Projekten einzusetzen (intensiver Test vorausgesetzt), denn: Ein Wechsel der IDE scheint nicht mehr notwendig zu sein.

Tag 2: 13:30 - 16:30: What's new in Hibernate

Direkt nach dem Mittagessen kam die dreistündige Hibernate-Druckbetankung. Viel Material zu alten Bekannten und neuen Projekten im Hibernate-Ökosystem.

Das objekt-relationale Mapping (ORM) wird um interessante Eigenschaften erweitert. Beim Mapping von Ids (besonders bei der Abbildung vvon Objektbeziehungen) gibt es jetzt Unterstützung über die Annotation @MapsId. Bei zusammengesetzten Schlüsseln können die Ids der daran beteiligten Attribute auf unterschiedliche Weise generiert werden (partial generation). BEim lesenden und schreibenden Zugriff auf Klassenattribute (Tabellenspalten) kann über die Annotation @ColumnTransformer der Wert verändert werden. Das Thema "Lazy Loading" kann nun zusätzlich mit sogenannten Fetch profiles feingranularer konfiguriert werden.

Die Criteria API versucht seit jeher einen objektorientierten, typsicheren und DB-neutralen Zugriff auf die Datenbasis zu ermöglichen. Hier wurde anhand von Codebeispielen der Umgang mit
  • Lazy Loading (default, übersteuerbar mit fetch())
  • Aliases
  • Joins
  • CriteriaBuilder.createTupleQuery()
  • Subqueries und
  • Views

Ergänzt wurde dies mit Hinweisen zu Änderungen in Hibernate 3.6, u. a.:
  • 2nd Level Cache und die Verwendung von Infinispan
  • CGLIB ist deprecated (stattdessen Verwendung von Javassist)
  • Das Packaging (die Modularisierung) wurde angepasst
  • Kein Support mehr für Java 1.4
Dann folgte die Vorstellung von Hibernate Search. Dieses Projekt erlaubt Anwendungen die Durchführung von Volltextsuchen auf der eigenen Datenbasis (auch und gerade in Datenbanken). Hibernate Search basiert auf Lucene und verwendet die Criteria API (s. o.). Objekte, die über diese Suche gefunden werden sollen, können mit @Indexed, @Fields und @Field annotiert werden.

Ein kleiner Ausflug war Hibernate Spacial. Dieses Projekt hat sich zum Ziel gesetzt, eine auf einfache Weise nutzbare Geo-Suche in Java zu ermöglichen. Auch hier kommt wieder die Criteria-API zum Einsatz.

Mit Hibernate Envers wurde ein Projekt vorgestellt, das sich der Hidstorisierung von Daten widmet. Grundidee: Bestehende Tabellen werden nicht verändert. Je Tabelle wird eine Audit-Tabelle ergänzt, welche die historisierten Daten enthält. Jeder historisierte Datensatz wird dort komplett abgelegt und bekommt eine DB-global eindeutige Versionsnummer (wie in SVN). Damit das funktiuoniert muss Hibernate Envers natürlich in den Classpath, Event Listener müssen ergänzt und die zu versionierenden Entity-Klassen mit @Audited annotiert werden.

Aber wie kommt man an historisierte Daten wieder heran? Heirzu wurden drei Varianten vorgestellt:
  • Gezieltes Finden über Revision number: Hier gibt es eine spezielle find-Methode mit Angabe der Entity-Klasse, seiner Id und der gesuchten Revision number.
  • Query über Revision number: Hier gibt es eine spezielleforEntityAtRevision-Methode mit Angabe der Entity-Klasse und der gesuchten Revision number.
  • Query über Entity history: Hier gibt es eineforRevisionOfEntity -Methode.
Nett: die Audit-Tabellen können individuell erweitert werden.

Mit der Vorstellung von Hibernate Validator ging's weiter. Dies ist die Bean-Validation-Referenz-Implementierung. Ziel: Definition EINER Stelle, an der für sämtliche Anwendungsteile (GUI, BLog) die Validierung von Domain-Objekten erfolgt. Der Fokus des Vortrages lag hier bei den Neuerungen, als da wären:
  • Neue Annotation @ScriptAssert: Ermöglicht auf Klassenebene eine Datenvalidierung mit Hilfe von Skripten.
  • Es gibt eine API, welche die direkte Programmierung der Constraints ermöglicht.
  • Method level validation, im Sinne einer Prüfung von Pre- und Post-Conditions. So ein bisschen, wie AOP-Advices, nur eleganter.
Den Abschluss bildete ein Einblick in Hibernate OGM. Hierbei handelt es sich vereinfacht audsgedrückt um ein Database grid management, welches newben Infinispan auch auf Teiid basiert.

Das war Druckbetankung pur, gab einem aber einen umfassenden Einblick in das, was das Hibernate Ökosystem leistet. In Teilen verwenden wir einzelne Projekte davon ja bereits. Interessant ist Hibernate Envers: Dies könnte den Eigenbau in unseren Produkten ersetzen...