Session title: Refactoring of Large Software Systems revised
Speakers: Sibylle Peter, Sven Ehrke – Canoo Engineering AG

First observation: This is a very well attended session, which reflects the fact that refactoring, whilst not the most glamorous of tasks, is obviously very important to a lot of developers.

The speakers describe the key lessons learned during a very challenging refactoring undertaking at a major bank. The project essentially involved trying to clean up software, the internal dependencies of which had gone out of control over time.

One of the key lessons learned: Keep it Simple, Stupid.

Options:

• Do a huge refactoring at some point once it has been recognised that costs per features have sky-rocketed. This is obviously not the recommended approach, but it is often the only option available.
• Do refactoring incrementally per release
• Do refactoring constantly

The costs of the project are pretty shocking: 6 persons for around a year. I could imagine this was a pretty sobering message for many members of the audience.

Title: Java SE and JavaFX RoadMap
Speaker: Danny Coward, Chief Architect, Client Software

Danny begins be showing the JavaFX roadmap…

Towards the end of the timeline: “JavaFX.next”
What on Earth could that mean?
In any case: JDK 7 release due early 2010.

Top 5 JDK SE 7 features

1: Modularity
Long overdue, the current JRE is around 14MB and contains a wide range of APIs. The average app only requires a small proportion of these. It also increases startup time.
Danny points out a number of weaknesses in the CLASSPATH concept. This will apparently be addressed by a low-level modularilty system entitled Jigsaw.
http://openjdk.java.net/projects/jigsaw/jcp.prg/en/jsr/detail?id=294
The concept externalizes the package depenencies to a module file… which reminds me of Eiffel’s solution to this issue which is donkeys years old.

2: Broadening the JVM to accelerate runtimes
DaVinci Project should result in a new bytecode model, which enables dynamic invocation, lightweight method handles and a variety of other optimizations.
http://openjdk.java.net/projects/mlvm

3: Java Language Additions
Project coin will result in a few small language enhancements:
http://openjdk.java.net/projects/coin
The switch statement will work with Strings.
Multiple Exception handling
catch (final IOException | ServletException e)

Improved type interence will remove the need to double-declare generics so:
List l = new ArrayList()
Becomes:
List l = new ArrayList ()

Elvis operator eliminates a significant cause of Java’s verbosity:
String s = mayBeNull?.toString() ?: “nothing”;

Integer ival = …
int i = ival ?: -1; // will be set if currently null

Must confess, this is not what I understand by the Elvis operator, but it looks useful nevertheless.

4: Four new I/O APIs
These include: New filesystem API, File notifications, Directory operations, Asynchronous I/O. The latter permits an IO task to be defined using a Future, the Future delivering the result at a later point in time.

5: New GC
New garbage collector “Garbage First” should result in predictably low pauses, few full GCs and good throughput. Can be accessed in Java SE6 update 14 using:
-XX:+UnlockExperimentalVMOptions –XX:+UseG1GC

This will be switched on by default in JDK 7.

Danny notes at this point that numerous other (small) features are also part of JDK 7.

JavaFX 1.2 Top 5
Danny begins by stating that Sun is trying to make up for lost time with JavaFX (as I have blogged in the past).

More platforms
JavaFX 1.2 runs on more platforms i.e. Linux and Solaris in addition to Windows and Mac. LG TV (purchasable in South Korea) incorporates JavaFX1.2. Finally, the HTC developer phone is also mentioned. Danny states that he hopes that phones will be available to consumers on the coming months. Don’t we all!?

New features
New widgets, charts, plus a new look and feel. L&F is possible via CSS, which is obviously a whole load easier than creating an L&F for Swing.
Improved layout management
Layout management: There are three new layout managers, but I know from experience these don’t yet cut it for non-trivial B2B apps.
There follow a series of nice looking demos, which highlight that JavaFx is scenegraph based.

Improved perforamance
Performance up: Realtime streaming for media is now supported, which improves media startup significantly. Various optimizations in generated code and scenegraph. Bytecode footprint is down 30%.

Improved data handling
More and better ways to use data. RSS and Atom feed support. A simple asynchronous framework is also included, plus a simple data storage API.

One final demo is really impressive: Using the bubblemark demo, Danny demos that JavaFX 1.2 performance is significantly better than Silverlight. Now that I would not have expected!

Session: Jsf and Ajax in the Credit Suisse
From: Benjamin Bratkus, Credit Suisse; Micha Kiener, Mimacom AG

It will be interesting to see what CS has been up to with JSF. My last JSF project finished early in 2008. I look back to it with pleasure not primarily because we used JSF but because we really got to use all of the key JEE features under Glassfish – which worked sweetly. JSF (which included facelets), on the other hand…

CS began with JSF in 2004. Corporations begin what they are, this resulted in a pilot (2005). Release 1 of their app took place in 2007. Since then CS claims to have one of the biggest JSF-based component libraries around.

 
Framework must support:

• Realtime data
• Handle huge data sets
• AJAX and JavaScript due to security aspects

…and must achieve acceptance by various architects.

The speakers also used ICEFaces to achieve the required level of interactivity and security. Specifically: Direct-to-DOM rendering (D2D), page level AJAX on existing components, AJAX Push capabilities.

Key to achieving efficient push: Asynchronous server push, which will apparently become standardised in the next version of ICEFaces. This approach frees up threads on the server-side, which is obviously essential for scalability.

Summary: Good talk, competent speakers. I still feel sorry for the average AJAX developer, who despite frameworks like ICEFaces is confronted with myriad non-trivial technical details. Plus, I imagine CS is not confronted with the other big pain for browser-based RIA: Multiple browsers.

Session title: Java Rule Engines (JBoss’ Drools, IBM’s iLog)
From: Raed Haltam, WEGA Informatik

Claim: Rules engines can reduce development time.

Raed makes the valuable clarification that a usable Rules Engine needs to address storage, versions, security etc. and is therefore best described as a Business Rules Management System (BRMS). He also takes care to distinguish the Business Object Model (BOM) from the Execution Object model (XOM).

Both iLog and Drools use the algorithm RETE. All rules follow the format:
when X then Y

Rules can be grouped into packages.

Both iLog and Drools allow higher level business language descriptions of rules.

Business rules can be made secure on various levels down to the statement level. In other words different editing privileges can be assigned to to different roles, which control the parts of a rule which can be edited under a given role.

Both tools support Complex Event Processing, which amounts to responding to patterns of conditions in a predefined way.

Raed presents a convincing sounding car financing case study from (JPMorgen Chase.) Rule deployment takes place at 8pm and are executed from 8am the following day.

Conclusion: Quite a nice, objective short summary (it was a short talk after all) on business rules for those unfamiliar with the technology.

Session title: RIA Security: Broken by Design
From: Joonas Lehtinen, CEO IT Mill

IT Mill is the creator of Vaadin: A 100% Java tool for RIA.

Joonas outlines a spectrum of complexity from Basic site to 3D games examples:
Web Sites (Wikipedia), AJAX Sugar (Facebook), Full RIA

He divides „Full RIA“ divide into client side vs. Server driven. Gives a crash course in GWT.

Vaadin: Apparently 100% Java and server driven, which sounds an awful lot like ULC at this stage… But here’s a difference: It builds on GWT and relies on JavaScript on the client-side.

He goes on to present a bunch of development rules:

Rule #1: Don’t trust the browser
Rule #2: Complexity is a hiding place for bugs
Rule #3: Large surface give more opportunities for attack. This surface has increased with Web 2.0.

Difference between GWT and Vaadin architectures is that GWT relies on the client invoking a server-side Web Service API, whereas Vaadin renders the client’s view on the server.

Erm… he then offers the cures for the problems (Rules above)… which I miss because the explanation is compressed into around 5s.

I’m starting to dislike this presentation at this point. Because here comes another artificial security issue scenario… which guess which product solves. And I thought product placement in Hollywood movies was irritating.

The issues he raises are legitimate, but the lack of objectivity is obscuring the message. And as I write the presenter is debugging JavaScript which depends on analysing the DOM on the client side – I’m not sure if he’s now analysing the problem or trying to fix it!?

I am formally declaring myself lost at this stage. At least I hope the other attendees are getting something out of this presentation, which has lost focus IMO.

He continues with a discussion about attacking at the transport level, inserting new data on the fly. But come on: A secure transaction in this technical setting will operate under HTTPS, which in most instances will deal with this kind of attack. Unless, of course, that’s something else I missed.

I think I need a coffee!!!