Meeraj Kunnumpurath's Blog

Community Archives

TSS Symposium Europe - Day 2

The first session I attended was by Ted Neward on the importance of message-based architecture. I was quite impressed with Ted's presentation and delivery style. Though, I thought Ted was trying to over-emphasise the superiority of message-based model over an RPC-based model. All I would say is messaging can improve scalability and percieved performance, RPC has its use cases as well in terms of QoS and user responsiveness. Also, as soon as you step into the world of transactional and persistent messaging, some of the scalability gain would start suffering badly. Another interesting point was the notion of tight-coupling with an interface-based approach for RPC compared to the percieved loose-coupling with messaging. I am not sure how true this is. As soon as the producer changes the message structure, the consumer should be able to adapt with this. This is often achieved by using a text-based data representation protocol or something like a JMS map message. A counter argument would be that you can achieve the same level of loose coupling by using loosely typed arguments for your RPC calls. Some of these points were clarified further by Ted during the Q&A session. Had an interesting chat with him on XA and recovery after the session. Quite friendly and approachable guy.

I missed the session by Bruce Snyder on JBI & Servicemix due to work commitments. There were also a parallel session by Rikard Oberg on WSRP.

The next session was by the Terraccotta on transparent JVM clustering. Imagine the piece of code below,

public class MyCache {

  private Map cache = new HashMap();
  
  public synchronized Object get(String key) {
    return cache.get(key);
  }
  
  public synchronized void put(String key, Object value) {
    cache.put(key, value);
  }
  
}

A mundane thread-safe cache. Now imagine you can take this class and transparently apply the native Java syntax and semantics for threading across multiple JVMs on a replicated instance of this class. This is what Terracotta provides. I have seen this is implemented in a few payment switches I have come across. However it is nice to have a product that allows you to transparently cluster any application. There are a lot of use cases I can use this in the applications I am working on, including cluster-wide singletons, keeping track of cluster-wide running totals etc.

The next talk was on JPA by Mike Keith. The talk was more API and spec focused. The talk before by Patrick Linskey on a more subjective view of JPA would have been more interesting. I don't want to over-elaborate on JPA itself as more than enough has already been written on the topic. However, I would say Hibernate style criteria objects would have been great. An interesting thing was pluggable persistence providers and Spring 2.0 offering a JPA provider. I think this concept started out in EJB 2.0 and disappeared from the final version. I am a bit skeptical about the portability aspect, I am sure the vendors will be tempting developers with proprietary annotations. Do you want a good example, Spec has left to the providers on how to perform eager fetching. So the provders can say, hey, you can use sub-select fetch or join fetch using our proprietary annotations. I have similar apprehensions about the whole concept of bulk updates and the grey area around how the current attached objects are kept in sync with the underlying datastore.

The last session for the day was by Nati Shalom from Gigaspaces and Rod. They showed a neat example on how Spring can hide the transport intricacies of accessing a clustered space. I think a lot of people are doing the same kind of things with spaces, with Mule providing similar support. I have been playing around with writing a spaces binding for the SCA implementation Tuscany. It was quite interesting when Nati said we didn't need relational databases anymore (or did I get him wrong?). It may be true for greenfield projects with the rubustness provided by spaces implementation like Gigaspaces (how about durable storage?). However, with terrabytes of corporate data residing in enterprise relational databases and systems being built around existing information set, databases are here to say. The key is finding the right synergy between using existing information stores with space-based grid paradigm. Anyway, the demo was quite impressive. I am sure I will be going back to Nati on more info on how this fits into stuff I have been doing. On a side note it was quite nice to catch up with Rod after a while.

TSS Symposium Europe - Day 1

The symposium kicked of with a keynote session by John Davies, the CTO of C24. John’s address mainly covered the choice of technology stack in the investment-banking sector. It was heartening to hear finally Jini and JavaSpaces are being adopted as a mainstream technology for realising enterprise middleware. John also mentioned the increasing acceptance of open source software like Maven, Spring and Hibernate in the banking arena. Maven is increasingly becoming the build tool of choice, despite the criticisms by most who have never had the good fortune of using it and just want to jump on the bandwagon on whining about how complex Maven is. It was also interesting to hear how big investment banks are shying away from full-stack J2EE containers and instead using Tomcat along the lightweight persistent frameworks. We will have to wait and see whether this trend would be reversed with the adoption of JEE 5.0 and EJB 3.0. Another interesting point was that Java 5 is being adopted for the performance gains more than the new language and API features.

The next session I attended was by Geert Bevin on flow and continuations. Geert did a good job explaining continuations at a conceptual level. It is a quite powerful concept and quite affective for complex control logic that is difficult to solve with primitive control constructs available in modern programming languages. Geert , then showed how continuations were implemented in the RIFE web application framework. It was interesting how RIFE implemented pause and continuation by byte-code amendment and taking a snapshot of the stack frame. I am not sure how efficient this is. It would also be interesting to see whether a future version of Java language would have language level support for continuations.

Next session was something I was eagerly waiting for, Gavin King’s session on Seam. I was a bit disappointed with the session as a whole, as Gavin spent half of the session on how flawed was the whole concept of stateless architecture and criticising dependency injection and some of the popular DI frameworks. Al though, some of Gavin’s arguments were valid and interesting, the point on HTTP session replication and the Servlet specification mandating a call to setAttribute to enable session replication was factually incorrect. Though, I have always had the same opinion on developers being concerned about using stateful session beans, because of state replication overheads in a cluster, however having no inhibitions in dumping everything and the kitchen sink into the HTTP session. All in all, Seam appeared to be an interesting framework for integrating JSF and EJB component models with a heavy emphasis on stateful session beans.

Mike Keith presented a session on EJB 3.0. It was more on the component model rather than JPA. I am not sure I quite like this concept of being able to inject only certain kind of references into only managed components like EJBs, Servlets etc. This will encourage the developers to write everything as an EJB or a Servlet. I am looking forward to Mike’s session on JPA tomorrow.

I was really in two minds about whether to go for Gregor Hohpe’s session on SOA or Ross Mason’s session on Mule. Finally, ended up at Ross’s session because of the recent work I have been doing with Mule. The session was pretty basic, didn’t get to know much more than what I already knew. However, had an interesting chat with Ross on roadmap for Mule.

Last session for the day was by Cedric Beust on TestNG. Junit has revolutionized the way we test in the last five years or so. It has been a wonderful framework. However, it has also shaped our psychology and mindset on jow we do testing. This is more of the fault of us using JUnit for something it was not intended for. Junit is a unit-testing framework and by design has an extremely stateless paradigm for testing. This doesn’t really fit into the more complex requirements of functional, component-level and system testing. To test a complex piece of functionality you often need to execute a set of tests in a stateful context, and this is what TestNG offers. Cedric’s session was the best of the day. It was quiet relieving that TestNG annotations can use either Java 5 or Javadoc tags for JDK 1.4.

This work is licensed under a Creative Commons License.