TSSS Day 1 – the search for a power outlet begins

On the first day of the The ServerSide Java Symposium 2005 I didn't come across anything particularly new and/or significant except for:

• Ajax - rich clients based on HTML/JavaScript (http://www.adaptivepath.com/publications/essays/archives/000385.php) 
• REST - an alternative to SOAP (http://www.manageability.org/blog/stuff/soap-is-dead)

Keynote

After a few introductory remarks by Floyd Marinescu, which included some interactive polls using a wireless handheld device, the conference started with a not particularly interesting keynote by Mark Hapner of Sun. The general theme appeared to be that services are more important than software which seems to be a restatement of "The network is the computer". The big idea was that services should consist of service components that communicate using XML messages over something similar to Unix-style pipes. Not sure what was new here…

Apache Beehive - Cliff Schmidt

I had planned to go to Mike Clark's talk on testing but then decided to go the Apache Beehive talk, a framework I knew nothing about. Beehive is an ease of use framework for developing enterprise java applications. It provides three main features:

• Web services - an annotation (JSR-181)-based mechanism for exposing a class as web services. I thought this was the most useful part of Beehive. To create a web service you simply have to annotate a class, run it through a code generator and out pops a web service including WSDL.
• Controls - a framework for writing Java beans that access encapsulate enterprise resources. Out of the box Beehive provides controls for accessing EJBs, JDBC, JMS and Web Services. Controls have to be deployed in a Control Container and Beehive provides JUnit integration. Beehive generates a control bean class that implements your control interface and invokes you control bean. I think Beehive provides some kind of setter injection for wiring beans together but it wasn't clear. I wasn't sold on the idea of controls. I think I will stick with POJOs and the Spring framework.
• NetUI - a web framework that is layered on top of Struts. You write and annotate a page flow controller class. Beehive generates a struts-config.xml from the annotations. There seemed to be an interesting state management mechanism but the details were not clear.

Overall, I am glad I went but I doubt I will be using Apache Beehive anytime soon.

Rich clients with HTML/Javascript - Dion Almaer & Ben Galbraith

I picked this talk because it is likely that I will be using rich client technology in the near future because vanilla HTML pages are inadequate for the kinds of applications that build. This talk was about Ajax (latest trendy buzzword), which is all about implementing client-side logic using HTML/Javascript. Important frameworks and technologies include:

• XmlHttpRequest class- provides access backend services using XML/HTTP
• JSON -  a message format that is easier for Javascript code to parse.
• JavaScript templates - JSP-like templates for generating DHTML
• JsUnit - for writing JavaScript unit tests
• REST - a replacement for SOAP

One benefit of HTML/Javascript is that works with the browser back button - apparently this is a limitation of Flash. My biggest concern is the maintainability of JavaScript-based applications.

Lunch

Unlike last year lunch was buffet-style, which meant standing in a line that was even longer than the United check in line at Heathrow Terminal 3 I was in last year. Fortunately, it went pretty fast. The lunchtime keynote was a repeat of last year's Macromedia Flex presentation. As far as I can remember, the only new feature was the support collaboration. Its very compelling technology and Flash is apparently available on 98% of browsers and easily downloadable.

Why J2EE projects fail - Rod Johnson

I don't think I learned anything from this talk but it was good to hear Rod Johnson talking about why J2EE projects fail since I am sure many of these mistakes are being made to day. A few things to note:

• Big teams produce lots of code even if you don't need it - one re-engineering effort replaced 250KLOC with 28KLOC using the appropriate frameworks and good design
• Use frameworks as much as possible: especially O/R framework or a JDBC framework - don't use JDBC directly
• Design applications to be testable
• Design your application so you can test as much as possible outside of the application server - for me this was one of the biggest benefits of using Spring. Declarative transaction management without EJBs. You can develop and test without regularly running the application server
• Don't trust new technology until you can seen that it works for you - do a proof of concept

Pretty obvious stuff but apparently they are often ignored.

Peer-to-peer clustering - Cameron Purdy 

This presentation was about building J2EE application server clusters. It covered the underlying technologies for clustering such as inter-server communication. It also described how to architect a clusterable application. I must admit that I didn't pay too much attention to the details and instead spent the time writing this blog.

Performance and scalability without the buzzwords - Cameron Purdy & Patrick Linskey

The final talk of the day was about developing applications that are scalable and have good performance. For many applications, scalability and performance are dictated by the database, which is:

• far away
• optimized for bulk operations
• Doesn't scale.

Best practices to improve performance and scalability include:

• testing for performance and scalability as early as possible
• Minimize database roundtrips
• Use coarse-grained transactions

One notable gem was that some applications are running on clusters of 100-200 machines.

links: digg this    del.icio.us    technorati    reddit