November 26th, 2010

by Ivan St. Ivanov

So, devoxx 2010 is over now. Tweets are tweeted, reports are written (even mine) and everyone is speculating about what happened, what we saw, what we missed and what we want to see next year. In this post I would like to make kind of a retrospection of what I felt about this year’s biggest European Java event.

Some info

The city of Antwerp is mostly known in Bulgaria with its football team (loved by some and hated by others ;-)). But in the Java world everybody connects it with devoxx – Europe’s JavaOne so to say. It is held in a big cinema complex – Metropolis and this year it reached its maximum capacity – 3000 attendees (or Javaholics). There were more than 100 presenters and more than 120 sessions. Among them: Adam Bien, Brian Goetz, Dan Allen, Emmanuel Bernard, Heinz Kabutz, JavaPosse, Joe Darcy, John Smart, Josh Bloch, Juergen Hoeller, Mark Reinhold, Martin Odersky, Romain Guy, Stephen Colebourne, Bill Pugh and many many other great speakers (here is the complete list).

In the cinema’s ground floor there were booths, where different companies presented their products, answered geeks questions, gave away some free stuff (including beer) and organized ballots with fantastic prizes (Kindles, iPods, iPad…). Oracle, JBoss, Spring Framework, JetBrains (most known with InteliJ IDEA), Terracotta, Zero Turnaround (JRebel authors), Adobe, even Microsoft (I surely have missed some). There was even a bookstore, where people could buy their favorite books and even get them signed if the author happened to be on the conference (I saw at least Josh Bloch, Antonio Goncalves and Josh Long there).

Noteworthy things

Last year devoxx was famous for the announcement of closures in Java 7. Well, the closure were postponed for the next Java release, but it got in the tweets anyway. This edition did not bring any breaking news, but it had its headlines worth to mention.

During the conference it was announced that Java SE 7 has already its JSR. It came along with three others – for Java SE 8, for project Coin (small changes in the Java language) and project Lambda (or closures). It is big relief especially for Java 7. Another news was that it was finally stated (semi)officially that Harmony is not going to get the TCK license, so it will never become official Java implementation.

When speaking about OSGi (one of my points of interest in my job) most of the people (including presenters) were just smiling and asking something of the sort: “What is OSGi?”. And in the same time most of the companies (including Oracle) are heavily using it. There was nobody from Eclipse by the way. And Mark Reinhold spent all his energy to tell us how good the modularization in Java SE 8 will be. Well, we’ll wait until 2012 at earliest to find whether he is right. And until then we’ll stick to OSGi.

Android was another hot topic. Most of the audience was claiming it as the future of the mobile Java. From Oracle we got nothing but the good old modularization story and the promise that it will make Java SE suitable for the smart phones.

Something that stayed away from most of the comments about the conference (or maybe I misinterpreted it) is the effort from JBoss to finally merge both worlds – EJB and CDI. These technologies work fine together now in Java EE 6, but who knows whether it will be the same in the future releases.

My focus

I had actually three areas of interest at this year’s devoxx: Java EE, web frameworks and popular people, whose blogs/podcasts/newsletters I follow.

In the web frameworks topic I found particularly interesting the Vaadin talk. It was a great session: introduction to web application development, then to Vaadin, then create an application from scratch and some more details about the framework. On Vaadin’s booth they gave for free the Book of Vaadin. I managed to get one, read part of it on the plain and found it interesting. I’m not sure yet how big is the issue with the fact that it is server side framework and the user session is bigger.

I already shared my speculation about the CDI and EJB merge ideas of JBoss. I also managed to see a fairly interesting comparison between the existing web frameworks (on the JVM and not only). Ease of development is everything today – as short development cycles as possible. ZeroTurnaround and JRebel claim to (and really do)  help developers in that area.

From the people whose session I expected with greatest passion, I would list three: JavaPosse, Adam Bien and Heinz Kabutz. I listen to the JavaPosse podcast for more than two hundred episodes and I finally managed to see and even participate in their show (listen to Episode 330 and you’ll hear me shouting “Bulgaria” at 07:08 :-)). I enjoy Adam Bien’s no-soft-skill style of giving presentations – only a few slides and the rest is interaction with the IDE and the app server. His session this time was even more interesting as he shared some thoughts on Java EE design patters besides just coding. I follow Heinz’s Java specialist newsletter, though I barely have the time to try what he talks about in the various installments. And writing the examples by yourself is necessary for understanding the matter that he is writing about. Well, at devoxx Heinz did that for us in the area was Java reflection.

Besides the above trio, I cannot help to mention the great Java Puzzlers show from Josh Bloch and Bill Pugh.

What I missed

Devoxx was a big great conference. All the time there were six sessions running in parallel (well, only the keynotes were privileged to be alone in their time frame). So it was merely impossible to visit everything that one is interested in. As already mentioned, I focused on Java EE, web application development and VIP presenters. However there were some slots, which I had big problem when deciding where to go.

First of all, for various reasons I missed all the test driven development and continuous integration talks. And John Smart was among the speakers in this area. I like very much his work, his newsletter and his Java Power Tools book. His topic was automated build pipelines with Maven, Nexus and Hudson – something where I have professional interest. But Josh Bloch’s Java Puzzlers seemed more attractive at that time. Another interesting session in this area was Steve Freeman’s talk on applying test driven development in all levels of development process.

I also missed everything about Scala (Martin Odersky, Bill Venners and Dick Wall were giving talks this devoxx), NoSQL, cloud and project Lambda (Brian Goetz had talk on the first day). So no fancy functional stuff this year for me. I also skipped Neal Ford’s talk on emergent design – an agile technique that avoids big upfront designs. Wow, again something that I really need in my job. Well, Bill Pugh’s Defective Java was more interesting.

I also didn’t go to a single BOF. I just appeared for 10 minutes at Linda’s one on JPA 2.1. It is very interesting forum for everyone expressing their opinion on the topics of discussions, but this year I did not prepare mine.

My plans for next year

Speaking about opinions on the topics of discussion, this year I missed the greatest opportunity that such events give: the networking. I had not prepared a single question before going to Antwerp. However, devoxx was my biggest chance to address all the important people in the industry. There were long breaks, which I only used for walking around. And just after the conference I remembered that I actually had some very concrete questions to the JBoss team about Arquillian. But it was already too late. So my take away (and advice to all of the readers) is that we should be prepared for such conferences with questions upfront. If you have really big issue with a product or library that you are reluctant to post in a forum, feel free to write it down and show it on the booth of the company that provides this library or product. They will be very happy to help you and will explain you much more than you would get in an ordinary forum.

I think that on next year’s conferences Java SE will be the big topic. Not only Java 7, which hopefully will be shipped then, but also Java 8. So going to sessions about modularization and closures should be a must for next year’s conference attendees. We should try even now Java 7 by downloading the latest NetBeans beta. So that we are prepared for the new features coming there.

I wonder what will be the situation with alternative languages on the JVM and especially with Scala. Will Stephen Colebourne find the next big JVM language until the next devoxx?

I expect something big from Spring and JBoss. Spring are flying in the clouds right now and are cleaning up the XML bloat from their framework. They are also working on caching and enterprise integration. Should we expect revolutionary statements from them the next year? Maybe yes, but not on devoxx. JBoss are trying to make Seam3 the next generation Java EE. We should follow the CDI extension group for the development in this area.

And last, but not least, I expect the JavaPosse, but this time all four of them! 🙂


The greatest news is that there are just 51 weeks to go until the next devoxx (last week there were 52). See you again in Antwerp next year!

November 21st, 2010

by Ivan St. Ivanov

So, devoxx is over now. I am sitting at my desk at home and am thinking about the conference. What was good, what was bad. But before I gather these thoughts into the wrap-up posting, I will draw your attention to the sessions of the third and last conference day. Sure there were already tons of blogs (and hundreds of tons of tweets) about this as I am two days late with this report. But anyway, it’s always worth looking at yet another point of view.

The Future of Java panel

This was supposed to be James Gosling’s State of the Java union talk, but as he had some health problems, he missed this year’s devoxx. Hopefully next year he will be back. The keynote was still very interesting. It was a moderated panel with Joe and Dick from JavaPosse acting as moderators. The participants were:

  • Josh Bloch – Google lead architect, the author of Effective Java and lots more
  • Mark Reinhold – Oracle chief Java architect and project lead of the Java SE specs
  • Stephen Colebourne – member of the Apache Software foundation, author of Joda times and passionate blogger
  • Antonio Goncalves – leader of the Paris JUG, part of the Java EE expert group and author of the best Java EE book on the market
  • Juergen Hoeller – project lead of Spring Framework
  • Bill Venners – owner of and great Scala book author and presenter.

The best thing was that even though the participants were allowed not to speak on some topics concerning political matters, in most of the time they did not hide behind this opportunity and answered the questions honestly. And the questions came from all the devoxx attendees. They were gathered during the conference, voted and the best ones got into the panel.

The most interesting question according to the voters was whether the backward compatibility of Java should be broken. Josh’s request was to break this as the efforts to keep Java backward compatible lead to so many puzzlers in the language (which he made a good franchise of ;-)). Mark mentioned that the future modularization coming with project Jigsaw will most probably help in that matter – people who want backward compatible Java will simply take older version of the modules they need, while the others may take the latest.

The next question was whether the role of Oracle as a new Java’s steward is affecting the community and if yes – in what extent. According to Antonio (who acted as JUGs’ representative) Oracle and the community are still trying to know each other. His hopes were that Oracle will use the community just for popularizing Java and not for the rest of its products (e.g. the database). According to Stephen the deal should be the following: Oracle will pay the money to keep Java around and the community will make sure that it is cool.

Next came the question about the flames around the licensing issues between Oracle and Apache about the TCK for Harmony. Josh cited Mark, who a couple of months ago said that Apache is never going to get that license. Stephen was not happy about it. He said that he personally does not like Harmony that much, but rather cares about the free competition and the promises that were once given.

The next interesting discussion (at least for me) was whether the OSGi/Jisgsaw cold war has ended. While Juergen did not see this as a big problem, most of the other participants were not too happy with OSGi. According to Mark (one of the great promoters of Jigsaw), it is too complex and thus not suitable for the usecase of modularizing Java. Next question was about the lag between a Java EE spec release and the release of real implementations and whether JCP is the cause for this lag. Juergen said that this is not a JCP problem, but rather problem of the implementors. Now it’s almost a year after Java EE 6 was released, but the only GA implementation is Glassfish. Maybe the big umbrella specification is the issue. Hopefully for that we have profiles, but even Resin is not globally available yet.

A lot of people are interested now in the next cool thing – functional features in the Java language. Josh who knows best what the integration of generics in Java 5 meant, said that this may be too dangerous if not done in the proper way (breaking backward compatibility maybe?). Stephen doubted that each cool feature should be included as part of the language. Remember XML? It was very cool sometimes ago, everyone wanted it in the language, but now its popularity is going down. Who knows what will happen with functional…

What is the future for Java mobile? Apparently not Java ME! Stephen mentioned Android. Mark gave his favorite modularity answer – once Java SE is modular, people can agree which modules are best suited for mobile app development and include them in the platform. Juergen’s hope here (though expressed a little earlier) was that legal and political stuff must not prevent the progress of mobile Java.

The last interesting topic was about JCP – whether it is broken and how should it be fixed. Josh (supported by others) expressed his opinion that JCP should become an independent organization (now it is not even an organization, but just a committee). Which was actually proposed by Oracle and BEA in 2003. Now they are in power to make it so. The good news is that the overall opinion by almost everyone on the scene was that JCP is not broken at all: there are lots of individual committers, the spec leads are free (and those coming from Oracle – encouraged) to make everything transparent (drafts, mailing lists), etc. Josh felt sorry that the voice of the independence is not heard anymore with Doug Lea quitting the JCP Executive Committee.

My overall opinion about the panel was that it was an informative and sometimes very entertaining discussion. All the people on the stage (especially the moderators) had very good sense of humor. With the risk of repeating myself, I would stress that in most of the occasions the speakers did not take the opportunity to not discuss the topics due to political and legal reasons! Good talk.

No-soft-skill-ing with Adam Bien

Next up was another highly anticipated talk. It was time for Adam Bien and his session on developing web applications with vanilla Java EE 6 and NetBeans. As he doesn’t like too much showing slides, he browsed very quickly through them and then started his favorite IDE. He wanted to show us how the different Java EE 6 technologies work together. As we were in a cinema, the application that he built was about aliens and predators. He was using NetBeans and Glassfish and the technologies that he got in action were EJBs, Servlets, resource injection, CDI, interceptors, events, REST (in conjunction with JAXB) and JSF. He demonstrated the incremental deploy upon save that NetBeans does. This really is what web developers need (as mentioned by Matt Raible the day before) – save and refresh the browser. No more rebuild, redeploy, etc.

The second part of the talk was more on patterns. Today most software architects think that if they produce as many layers as possible, their applications become much more decoupled and easy to extend. However, go and try changing one little thing in such multi-layered app and you will find it horrendous. For just adding a small attribute you will need to touch several classes in most of your beautifully designed layers. So Adam’s advice was that each architect should try to code once in a while, so that they don’t produce any more such architectures.

The two main approaches in this direction according to Adam are domain driven and service driven architectures. In the first case all the business logic is in the domain (the entities) and in the second case it is in the service layer (which is missing in the first architecture). Basically domain driven design is more suitable for REST-like solutions, while service driven design is used in SOA (with SOAP).

Adam’s advice was to delete as much as possible from the big architectures and to decouple only if needed. This looks more like DDD. Basically these and many other patterns can be read in his great book, which I highly recommend.


The last session that I attended this year at devoxx was the one from Dan Allen – JBoss software engineer, one of the authors of Seam, Weld and Arquillian. His presentation titled The Roots of Java EE was very informative in nature. The information that Dan wanted to deliver us was too much for the little time that he had. So it were only slides and no real hacking in the IDE. Probably most of the stuff was shown during the University days in the beginning of the week, but unfortunately I was not able to attend them.

The presentation started with some jokes about Spring framework and a brief introduction to Contexts and dependency injection (and its reference implementation Weld in particular). Besides contexts and dependency injection, CDI is also type safety (no XML), events, interceptors, decorators, unified expression language. This was all embraces by the java community and the Java EE expert group and is now in the specification.

Another thing that took the rest of the talk were the extensibility possibilities of CDI through deployment hooks. Basically our POJO beans can easily get all the infrastructure like transaction, security, etc. in the same way they have it in EJB. The difference is that these are managed by CDI extensions and not by a container. Dan called this Ultra EJB light. He also showed how entity manager can be easily injected. In order for this magic to happen, “you’ll have to write the code for it”. This code is called CDI extensions and hopefully you should not write them all by yourself. There is now a placeholder project for such extensions called SeamSolder. Its well managed repository is located on this URL.

So, in the current Java EE world we have the EJB realm and the CDI realm. They seem to work together, but are really two different domains. From Dan’s talk I got that SeamSolder can bring these worlds together and much more. So, who knows, probably the next big retrofitting of the EJB spec would be in this direction?


That’s it for this year’s devoxx. It was a great conference, so thanks to the organizers, the presenters and to attenders for making it even greater. See you next year!

Stay tuned on this blog, though, for my devoxx review post! 🙂

November 19th, 2010

by Ivan St. Ivanov

I’m writing this while sitting in one of the devoxx conference halls in the Metropolis cinema complex. I’m waiting for the Social network movie to start. Only half an hour ago in the same room I watched the most interesting session so far (sorry JavaPosse!). But, first things first.

The keynote

Today there was just one keynote. It was presented by three Oracle employees talking about the future of Java EE. Jerome Dochez started with outlining the basic aims for the seventh’s edition of the enterprise specification. Everything will be concentrated on bringing the EE application to the cloud. So Java EE seven will make evolutionary steps to enable that. Well, it appears that it needs modularity and versioning from project Jigsaw (moved to Java SE 8). Basically nearly the same thing was presented on Java2Days in Sofia two months ago. What was new to me was what Linda DeMichiel and Paul Sandoz showed. They are both spec leads – Linda of the JPA spec (expected version to enter Java EE7 is JPA 2.1) and Paul – of the JAX-RS spec.

So Linda talked again about the JPA 2.1 new features. It was a very comprehensive list. And as the timeline for 2.1 depends on the timeline of the umbrella Java EE spec, she said that she does not believe that everything will be in and finally they may reduce the scope. However, the JPA 2.0 expert group (the 2.1 group is not yet formed) are open to requests from the community.

The same thing was mentioned by Paul about JAX-RS. Actually what he said is that he was looking for all the good innovations there in the industry in order to standardize it. One of the things that he mentioned that is good is implementing the MVC pattern with JAX-RS (which the folks from Spring already have).  They are also considering breaking compatibility between the new and the old releases if needed.

Web frameworks talks

The next couple of sessions that I attended were about web frameworks on the JVM. First Matt Raible tried to compare a dozen of them, including Spring MVC, Ruby on Rails, Struts 2, Grails, GWT, Wicket, Play, etc. Basically his idea is that you should choose the framework to use by eliminating the ones that will not do the job for you. These days all developers want a very quick and simple working mode – save the changes in the IDE, refresh the browser and see the result. No build, re-deploy and sever restart in the meantime. According to the speaker developer productivity is the first reason when picking up the framework of our choice. Then he showed us a matrix where all the frameworks that he has experience with are compared by 20 different criteria. After drawing the line, top five are Spring MVC, GWT, Ruby on Rails, Grails and Wicket. They all have their pros and cons. Then we could see some charts on framework usage, community and job offerings, where also other language frameworks were included. It seems that PHP is much more popular and ASP.NET is by far the most popular. Generally amusing talk I should say.

Next in the same hall I watched Graeme Rocher talking about the Grails roadmap. So, in release 1.3 everything is about performance improvements. We also have a new clever ivy-like Groovy domain specific language for expressing build dependencies. We have also some GORM enhancements like reusable (named) queries created with a criteria API, some global constraints and mapping that are valid for all the entities in the application, etc. He finally did a demo, where he developed from scratch a simple Grails application (with a farmer and plants in his farm). He demoed the integration between Grails (GORM) and NoSQL data stores. The sample was using Redis, but there is the same support for MongoDB as well. And more are still to come. Unfortunately I was not taking notes on the features in 1.4 and 2.0, but these will be released end of March 2011 and end of 2011 respectively.

JPA Criteria API

This talk was by Linda DeMichiel (remember, the JPA spec lead) and she presented one of the biggest new things in JPA 2.0 – the criteria API. It solves one of the biggest problems, which is that JPQL statements are written as simple strings. Thus the compiler does not check their validity and if you screw them up, you will understand about that in runtime. I must admit that somewhere in the middle I lost it, so this was not one of the most valuable presentations for me. I must admit that I went to it just for the sake to have a better starting point for the next session in the same hall – the JavaPosse 🙂

Java Java Jing Jing Jing

I was expecting this talk for quite a long time. I can’t hide that the JavaPosse is my favorite podcast and I listen it for quite a long time. As always on such conferences, this was not an ordinary session, but looked more like a TV show. It were only Dick, Carl and Joe on the scene, while Tor was in the US. He was present as well, but over Skype We all sang the Java Java Jing Jing Jing song in the beginning, then we went on with the marketing stuff. It appeared that I am the only Bulgarian in the hall (which was full). The marketing part was about checking how many users there are of all programming languages on the JVM (and not just), then platforms, mobile, etc. After that the guys did their regular quick news reviews (no, no whip sounds this time). Finally it was time for questions. The most interesting for me was whether they are thinking about putting a roundup in Europe. And the answer was: ‘Why not, only somebody should take the responsibility for organizing all the stuff.’

Java defects and puzzlers

The last two sessions that I attended were very amusing (especially the last one). First was in a full hall by Bill Pugh from the University of Maryland. Being the author of the findbugs static code checker, his talk was on the defects in our Java programs. He started with a review of a run of findbugs on JDK 1.7 code, Eclipse 3.5 code and Google codebases. And it appears that a lot of defects were detected there (4000+ high prio mistakes in Google codebase). He even showed something like:

if (adapters == null && adapters.size() == 0) {

The next thing that was discussed was whether we should fix all our mistakes. Apparently not, so after findbugs is run it comes to the human factor. BTW Google is running automatically static code checker on each submit. We have the same thing in our nightly build and I can state that it is a good practice as long as you react to the reults and don’t try to abuse it.

Bill jumped to the next room for the final session of the day. He and Josh Bloch showed us brand new six Java puzzlers. The hall was full, I was sitting on the floor in front of the scene. The first couple of puzzlers were caused by badly defined interfaces and some general issues in the platform. It appeared  that they were introduced by Josh himself while he was working for Sun. The funniest thing was that he was looking at Mark Reinhold (the project lead of Java SE and chief Java architect at Sun/Oracle) each time he said that they should be fixed. BTW Marked happened to sit next to me (not on the floor of course :-)). The puzzlers were very interesting, but more interesting were the morals after each one of them. So either go and by the Java puzzlers book or at least go to, wait for this session to be published and watch it. I promise that it was fun.

The afterparty

No, I did not go to the devoxx party. I rather went to see the Social network movie which was broadcasted for free for the conference attendees. Nice movie, I had not watched it before. What was interested to me was how they show subtitles in a bilingual country like Belgium. You always have two lines – the first in French and another in Dutch.

Then in the pizza restaurant near my hotel I met some guys from JBoss (Lincoln Baxter amongst them), Caucho and a small German company that is writing adapters for the software developed by the company that I work for. Finally did some networking and geeking. 🙂