My highlights of JavaPolis 2005

0

A few weeks ago I visited the second and third conference day of JavaPolis in Antwerpen. I haven’t been to JavaPolis before, and I was excited to see how many people were attending. The location (a movietheater) was great, with large rooms and very comfortable chairs. Although some presentations were so popular that it was hard to get in and out of the rooms, once in, there was plenty of space.

Many presentations are already covered by my colleague’s at this blog, so I’ll give a short overview of my personal highlights.

....

Spring 2.0 – Rod Johnson

Although my knowlegde about Spring is definitely not big enough, I really liked this presentation. Apart from the fact that it’s always nice to listen to ‘the man himself’, this presentation was a good overview of what to expect from Spring 2.0.

The keywords are ‘simplify’ and ‘more powerful’. To do this, they made good use of Aspect Oriented Programming with AspectJ. This delivers a solid model and is highly extensible. Apart from this, a few of the new features of Spring 2.0 are message-driven POJOs, definition of new and own XML tags, easier XML configurations and the introduction of SimpleJdbcTemplate.

 

Declarative caching with the Spring framework – Alex Ruiz and Steven Devijver

This presentation gave a good overview of why and how to use caching. If you want to use caching, you should only use it for data which is expensive to fetch and which doesn’t change too often.

What is great about caching in Spring 2.0, is that the cache-Id is defined by the method and it’s arguments, which makes the return value the cached value. And this is configurable per method, so you can even cache the complicated or expensive getters and setters, like lists of countries that (obviously) don’t change that often.

Apart from this, when using AOP, it’s possible to even make the flushing configurable.

 

Maven 2.0 – Vincent Massol

The main goal of Maven is to make your builds boring, because it’s a waist of time to spent a substantial amount of your project time on builds. Apart from a build tool, Maven is also a dependency management tool and a documentation tool. But it’s really a process of applying patterns to a build infrastructure in order to provide a coherent view of software projects. And Maven 2.0 does make this process a lot easier.

Where Maven 1.0 was powerfull but hard to learn, in the new version this is made easier by (among other things) the introduction of the pom.xml (Project Object Model). This file can be created in each directory and contains the metadata about the project, like location of directories and dependencies, but also JDK versions and plugins. The pom.xml makes it possible to have multi-module builds and the declaration of child projects in parents.

 

Serving Java Server Faces applications to Telnet Clients – Varouj Chitilian

Although telnet clients are used less nowedays, there are still many environments using it. This presentation showed us that they can also be build using JSF, since Oracle’s Industrial Telnet Server and JSF Telnet Render Kit are part of Oracle ADF.

We were shown that there is a render kit for ADF faces components, which support a subset of 35 components suitable for telnet and which is fully integrated with the JDeveloper design time environment. The components are placed on your client by drag-and-drop, like when you create a webclient.

Because of this, ITS/ADFT is the solution to migrate from telnet to J2EE. And it also showed us that JSF is extensible enough to support non-HTML clients.

 

Agile Model Driven Development – Scott Ambler

We all know that requirements change during the project, because people aren’t good at identifying what they need, they change their minds in time and the business environment change during the project. A good way to deal with this is using Agile during your project.

This means you don’t plan what you want to build in a certain period of time, but you decide how much time you have to spent and you treat requirements like a stack, making sure the ones with the highest priority will be build first.

The users of your new build have to be around during the project to decide at any time how it has to be build and which requirement is the next most important. This sounds strange, not to know what you’ll get when the project starts, but it makes sense if you realise that 45% of your code is never used. Using Agile, you know for sure that the most important things for the user will always be build.

When listening to this presentation, I tried to visualize how my recent projects would have evolved when we would’ve used Agile, and I do believe that this could have made a huge difference.

 

And after all the techtalk and the ending of JavaPolis, we decided to pay Antwerpen a quick visit. We visited the cathedral and saw many enourmous Rubens-paintings. And while it was only a few days before Christmas, we enjoyed the Christmas market with smells of hot soup and rich alcoholic drinks. All and all 2 great days.

Share.

About Author

Comments are closed.