This post originated from an RSS feed registered with Java Buzz
by Simon Brown.
Original Post: QCon London : day 4
Feed Title: Simon Brown's weblog
Feed URL: http://www.simongbrown.com/blog/feed.xml?flavor=rss20&category=java
Feed Description: My thoughts on Java, software development and technology.
Thursday was another busy day and there were definitely a few sore heads from the social event the night before. Although I missed the opening keynote in person, my name somehow made it onto the big screen along with the other bloggers that are covering the conference. So I was sort of there. ;-)
With my trackhosting duties over, I was free to move around and attended sessions from both the emerging Java technologies and investment banking architectures tracks. Joe Walker's track introductory session presented a look at how Java is evolving and how this is affecting the way that we develop. There's definitely a push towards simplicity and agility, with Groovy, Grails and Seam being examples of emerging Java technologies that are helping us move away from the complexity. On the other hand, it's interesting to see how features like closures, while being very useful, are adding complexity into the core Java platform. One thing that struck me through all of this is how dependency injection has really been the catalyst for making it possible to implement some of these changes around the way that we write software. Spring, Grails, Seam and even EJB 3.0 - they all have ways of magically and automatically injecting stuff into your code. The underlying concept of all these technologies is, "you write the POJOs/POGOs and we'll do the rest".
The first session I attended was Guilluame Laforge's Grails. This was a good presentation and while I remain unconvinced about using something like this in a production app (yet), it's undeniable that what the Groovy and Grails teams have done is cool. I also like the way that Grails seems to hide away the underlying Spring and Hibernate configuration, leaving you to get on with solving your business problems.
Next I went to The move to real time computing - what you need to know with Ben Whittle. I've done quite a bit of work for UBS and was interested in this session because I've not actually worked on/seen/heard about any "real-time" systems within the bank. Sure enough, the start of this talk looked at what "real-time" means. Ben said that in the city, "real-time" tends to imply "straightaway and as fast as possible" and I completely agree. He then went on to say that performance requirements are more often than not irrelevant because stuff just needs to happen as fast as possible. Instead, it's the architectural qualities of a system that can really affect its success, particularly aspects like automatic failover, fault tolerance, etc. I really enjoyed this session and it was quite refreshing to hear somebody from the city talk realistically about the state of the IT industry within the investment banking industry.
Next was Gaving King's Seam talk. Although it wasn't made explicit, and like Grails, Seam could easily be seen as a Java version of Ruby on Rails. Okay, I know that this isn't entirely accurate, but the demos Gavin was (trying) to show illustrated how easy it was to build basic CRUD apps. Seam basically provides a framework on top of JavaServer Faces (JSF) and EJB 3, adding some additional functionality into the mix. One thing I do like is the notion of "conversations", which removes a user's confusion around browser windows and sessions.
Peter Kriens' OSGi, the foundation was a really interesting session for me because I've not looked at OSGi before. It's a true component model with a Java implementation that solves many of the problems you might encounter with reuse in the Java world, such as dependency management, dependency conflicts and runtime deployment/undeployment. Basically, you wrap up some Java code inside an OSGi "bundle" and explicitly expose the interfaces that you need to. You can see OSGI bundles in action with Eclipse - the plugin model is OSGi based. I really want to look into OSGi some more and I think that there are some interesting opportunities for integrating OSGi and JMX. Hmmm ... that's got me thinking.
The final session I went to was Ari Zilka's Clustering enterprise Java applications with Open Terracotta. Terracotta is billed as a way to transparently cluster Java applications using standard Java language features and constructs. What they've done is undoubtedly very clever (e.g. propagating JavaBean state changes and synchronizing locks across the cluster) but something scares me about this. I can't quite put my finger on this, but I think it's just the whole notion of distributed computing being transparent. Just think of the trouble you could get in if you don't consider some of the typical problems associated with the distributed computing model! Kevin wrote his thoughts up at QCon: Open Terracotta and there are some interesting comments already.
Thursday was another excellent day, with a great breadth and depth of topics.
Previous Topic
