GWT: Pros & Cons

Pros:

• Very good perceived UI responsiveness. In a perfect case response times will be even better than on desktop (local Google Gears caching is great).
• GWT uses component model for UI, so code reuse is easy. And there are many open-source libraries of GWT components too.
• GWT server-side is stateless. So it is highly scalable "by design". In our case we achieved very good performance per single front-end server instance.
• You can make your UI similar to desktop GUI with associated sweeties (DND, visual effects & etc)
  

Cons:

• GWT is built around Java -> JavaScript compilation. So if you get a big Java codebase, the result js files will be big. So some old browsers will not be able to load and run them
• GWT app loading time may be quite significant for big codebase. Of course, browser caching helps here
• GWT renders page content with JavaScript, so indexing of data represented by the app is problematic
• While there is browser history control inside the library, there are restrictions introduced by HTTP/HTML stack. In general case, you will not be able to reference pages inside GWT app if you use HTTP redirect (for example during authentication)
• HTML Browsers are not too good in visualization of dynamic HTML (IE is the worst, Safari 3 is the best). So you may need some tricks to show big number of items)
• GWT components are not easy to debug/implement. They should be cross-browser. And HTML browsers have their own bugs too. So you may need a JS/DHTML guru in your Java team.

SpringSource Application platform

Lately, several Spring based platforms for application development has arisen. I guess this is a good thing. JEE is a quite rigid and restrictive for modern application development. There are areas were this is good. For example in conservative industries code may live for 10-15 years. So well described standardized platform is a must.

But as I said it has drawback. This is why Spring is the leading framework for application development. It is like LEGO. The framework ties together many different components into a single system and provides unprecedented flexibility in architecture design. In the last two java projects of mine JEE container was just for checkbox. Mostly all functionality is controlled and managed by Spring.

So introduction of the Application Platform by SpringSource is a GREAT EVENT for me! While the platform is on early stages of development yet, it tends to be a great tool!

• All components are physically modularized through OSGI. So version control and dependency resolution is inside container already. These things I was doing manually for ages.
• Logging is fantastic! The platform separates event streams by originating application and allows to configure details level very precisely. The configuration language is much simpler and comfortable than Log4j XML. Moreover, serious app errors are detected and logged (deadlock & etc).
• The platform provides native support for Spring contexts, modules linking through Spring DM. I am happy. :-))))

However, the platform is young still. I did a quick review and got following wishes:

• The platform need a bundle distribution infrastructure. I want not put new bundles into all instances manually. Of course, I can automate this. But it would be better to have the feature inside the AP.
  
• I'd like to have Tanuki software wrapper as native runner instead of custom made shell scripts. The wrapper is broadly used by community and it provides very good capabilities for OS integration (services, remote restart, watchdog & etc)

Anyway, this is a big step forward for server application development. You are on good course Spring!