Today’s keynote was all about toys. The guys from the Netbeans team showed some new features such as a JavaScript editor (which contains code completion), Sentilla showed there small sensor thingies, which you can program to gather information, such as acceleration, temperature etc.., LiveScribe showed there very cool pen and lots more.

Today’s topic included:

• User Experience
• SOA
• Semantic Web

Mischa and Erik Jan on The Layperson’s Guide to Building a Better User Experience

Burk Hufnagel showed in his presentation how to leverage the skills you already have and build experiences that delight your users.

The term “User Experience” describes how people feel about using something. This is very important, because if the experience isn’t satisfying,

• The ability to get things done is slow.
• The software will be replaced by software that does have a satisfying experience.

The Layperson’s guide is a guide for non-experts, on how to develop the best “User Experience” for the target group.

So what affects the user’s experience?

• Interaction Design
• How the users thinks it works.
• How the system is actually built.
• How the system presents itself to the user

Doing Test Driven Design has a couple of benefits like

• Writing tests first makes it easier to you create the right interfaces and behaviors later.
• Writing tests first can reduce the chances of the implementation model leaking into the representation model.

So how do you start? Well identifying the Key users is a good start.
They are te ones that must be satisfied for the product to succeed in the market.
Next you need to develop Persona’s, figure out there behavior, motivation and goals. It may take some time to get to the
bottom of this, but it is better then to guess what they want. Try to limit the amount of persona’s, because you need to create
an interface for all of them, to be able to get the best User Experience for all Key Users.

Developing like this may take a little more time on startup, but will gain a lot in the end.

Jeroen on the Semantic Web
Today I had another talk on the Semantic Web, this time a real Technical Session by one of the same guys who talked in yesterday’s discussion panel, Dean Allemang from TopQuadruant. His talk was similarly titled as his book: Semantic Web for the Working Ontologist.

One of the best ways to describe the semantic web is probably using the following sentence: From data on the web to a Web of Data. Our current Web mostly consists of data that us humans can interpret as meaningful, but it has no meaning whatsoever to machines. In the Semantic Web, it is all about adding another dimension to data so that both humans and computers can reason about the data.

One of the standards for the Semantic Web is the Resource Description Framework (RDF). RDF is a way of storing data as triples (subject, predicate, object) distributed across a network, using URI’s as identifiers for the data. For instance if I wanted to model the plays Hamlet and Romeo and Juliet written by Shakespeare in RDF I could write down the following:

(1, my:writer, Shakespeare)
(1, my:title, Hamlet)
(2, my:writer, Shakespeare)
(2, my:title, Romeo and Juliet)

However as you can see, my:title could be very different from your:title. Where my:title is the title of the play, your:title could be your degree, like “MSc.”. This means that the first requirement for the Semantic Web is that we need to agree to disagree. Using namespacing we can assign different meanings to the same terms.

The Semantic Web is all about data, and not about how you represent the data. Yo can chose your own representation and map that to someone else’s representation. For example, if I wanted to say that my:writer is the same as a Dubblin Core author, I could write down the following RDF triple:

(my:writer, owl:equivalentProperty, dc:author)

Now anyone knows that if I say writer, I am actually talking about an author. What is nice is that RDF is used for both the data, as well as the schema. Usig these constructions we can build an ontology. An ontology is best described as: A reusable component of a distributed semantic model. A well known example of an ontology is the Dublin Core standard.

This primer into the Semantic Web was pretty good and clear. I hope they’ll give some more talks on this subject.

Marco on his day
Keynote: extreme innovation
This one was about some of the really cool things you can do with Java. The absolute highlight was the Pulse smartpen, a Java-enabled pen that can not only record what you write & what you hear at the same time, but also order a cup of coffee. In Mandarin. Also noteworthy was a car that can drive & park by itself, which will become hugely popular amongst Asian people & women, I hope.

Designing GUI’s 101: From User Needs To Usable GUI’s
Thank heaven this one only lasted for about 30 minutes, as absolutely nothing new was said (“so we first need to ask the users what they want, then create a prototype, and then ask the same users again what they think of it? Brilliant!”).

Using SOA, EAI, and BPM to reengineer Legacy Applications to Java 2 Platform, Enterprise J2EE Platform
A real-life story about how to drag a legacy system kicking & screaming into the 21st century. I really dug this one, with a very energetic speaker talking about how they wanted to save 30 years of business logic stored in the system by putting JNI on top of it, then later taking another step into the future with SOA. One lesson learned: apparently it’s easier to teach Java developers assembly code than vice versa. Which should insult me in some way as I started out doing machine language, but I’m just too tired to care at this point.

Open Source Development Tools fir the Java Platform, Enterprise Edition (Java Platform), Web 2.0 and SOA
The final session I attended and it sure was hot, temperature wise that is. The demo gods still seemed to be angry, resulting in the room telling the presenter what to do, instead of the other way around (rule #61: if there is a stack trace, study it to see what is wrong – it will save time). After a change of subject (JBoss ESB instead of Seam) things got pretty interesting again, too bad it wasn’t possible anymore to get hold of the free development cd.

Epilogue
It was really clear that this was the last day, as both the number of visitors and the energy level of those still present was down. After attending so many sessions (and writing about them to boot) I myself am ‘stuffed’, but all things considered it was a fantastic experience, and I certainly learned a lot. I’m glad I decided to concentrate on one track (SOA), even though it means I missed out on some other great presentations. Then again, my esteemed colleagues saw those, and I’m pretty sure they will blog about it as well somewhere else.

What do you mean, they share this space with me? I’m a star damn it, I deserve my own space! Now go get me some monkeys!

• Mylyn
• Groovy
• Semantic Web
• SOA
• OSGi

Erik Jan on Mylyn
It’s now the third day of the JavaOne and the signs of fatigue are beginning to show, so today I haven’t been to any Bird of a Feather sessions at night. I did go to a session about Mylyn. I’ve blogged about it before, but I was impressed with what they have done with it. They have added a lot of connectors for different issue tracking system. One of the things I’ve missed, which they’ve now announced is the ability to automatically log time worked on an issue. Also they have created a perspective where you can keep more context for your task so that any webpages that you have looked at are also saved with your task.

With a demo the presenter showed another great use for Mylyn. When you’re pair programming for instance, and one of the two is going home, you can easily create a patch of the changes and save it with the task similar to the context. Your colleague can then easily continue the work on his own computer.

So my next project we all are going to use Mylyn, so that we can track the work that has been done and improve on our estimates. The added benefit of pairing and taking over will simplify pair programming.

Jeroen on Groovy scripting and the Semantic Web
To start off my day. I attended the Groovy and Grails talk by Guillaume LaForge and Graeme Rocher. Unfortunately Graeme was ill, so Guillaume did the presentation on his own. In this talk he went further than during the scripting bowl. People got to experience first-hand what it means to have the power of the Meta-Object Protocol (MOP) at their hands. Although Groovy is not the only language with a MOP – Ruby, Lisp and Smalltalk also have one -, we focus on this language.

THe Meta-Object Protocol makes Groovy a dynamic language. It makes it possible to add and override methods and properties to existing class definitions at runtime. Two small examples which Guillaume showed us were the following:

Adding methods at runtime

class Dog {}
Dog.metaClass.bark = { -> "Woof" }
def d = new Dog()
print d.bark()
==> Woof

Override method at runtime (Note: This is not a good idea…)

Integer.metaClass.plus = { Integer i -> 1 }
3 + 4
==> 1

Next to that, he also explained some nice methodMissing tricks, in the next code sample, the missing method will be added to the class definition so that the next time the penalty of going through methodMissing is removed.

class Dog {}
Dog.metaClass.methodMissing = { String name, args ->
	def cached = { Object[] a -> println "Dogs don't $name"}
	Dog.metaClass."$name" = cached
	cached.call(args)
}
new Dog().quack()

In all Guillaume showed what the power of Groovy over Java is, and what Groovy can contribute to your current enterprise application development.

After the lunch I went to the Semantic Web panel discussion. Here we had a panel of 5 Semantic Web gurus who held a discussion, showed some cool apps, and andwered questions from the audience. What soon became clear was that the current focus is on the Semantic Web as a social networking tool. Many of the demo applications were centered around that theme.

According to these gurus, the problem with the current social networks is that there are too many, and each of those is centralied and lives on its own island. The Semantic Web can help in this aspect. There are no competing standards, everything is interoperable, and it is decentralised, everything is identified by its own URI. One demo showed an addressbook, in whch you could drop yourself, and easily gain access to your friends, and your friends’ friends, etc.

Another big announcement they gve was that Yahoo! will be adding RDFa to all it’s pages and will be pushing it out through its APIs. This is a big step, which will make Yahoo! a semantic company joining other companies such as Reuters and the W3C as supporters of Semantic standards. Adding the RDF means adding semantic tags to the pages. A semantic tag is different from a normal blog tag in that it gives a meaning to the data such as whether it is a place, an organization, a person, or something completely else.

After almost 10 years, we’re finally taking steps to where Tim Berners Lee envisioned we should be going with the web, but the full Semantic Web is still far away. We can only hope that this step by Yahoo! will be followed by more companies.

Marco on his (SOA) day
Sun Java Composite Application Platform Suite: Implementing Selected EAI Patterns
At JavaPolis I was constantly being told what a great book Enterprise Architecture Patterns was, so as soon as I returned to the office I had it ordered. Unfortunately I haven’t really had the chance to put it to use it since then, as my last project was not exactly suited for this type of approach. This session, although a bit dry, rekindled my interest, showing real life implementations of those patterns using Sun’s Java CAPS. Now let’s hope that at least this time I will be able to use all the knowledge I gathered.

LifeCycle ES: Adobe’s Java 2 Platform, Enterprise Edition (J2EE Platform), SOA Platform
One thing is sure: there’s no lack of platforms in this session’s title. Even more than the previous session it was centered around a product, in this case created by the very same company that is famous for their Acrobat reader. Keeping that in mind, it wasn’t too surprising that the demo was about doing a PDF processor. Now I’m still not sure how that was connected to the SOA stuff, but that might also be because I was too busy trying to remember of what actor the speaker made me think of (French Stewart of 3rd Rock –mostly because of the nasal voice).

Converting Large Applications to OSGi
I knew only the basics of OSGi because of a session I attended by Peter Kriens at JavaPolis, and was warned by the very same speaker (well, not personally of course – although he did look directly at me when he addressed the room) that the subject could become a bit hard to grasp. He needn’t have feared: it was a very clear talk, with some useful instructions how to tackle the conversion of an already existing application.

Composite Application Design Patterns
Proof that even I make mistakes sometimes (everybody who knows me personally: stop laughing) I decided to ditch a session about choosing the right web for this. Basically it was nothing more than presenting some patterns people at SAP came up with in such a fashion that it added absolutely nothing extra to just checking the powerpoint. Now I know giving an interesting, lively presentation is really difficult but c’mon, there weren’t even any monkeys! How can you have a session about this subject without any monkeys? It’s crazy, that’s what it is ..

Designing Service-Oriented Architecture Applications with OSGI
Today’s final session took place several hours after my last one, but it was well worth going back to Moscone center for. A panel of 4 told us about the pros and cons of using OSGi based on their experience of using it to build the new version of JBoss ESB. In general they were very positive, giving some extra credit to the whiteboard pattern. Now I have never heard of it before, but it’s clear that with a name like that it must be something that can wipe all erroneous legacy code in one sweep.

Yes, I’m kidding.

Epilogue
Another very SOA-centric day, and the pieces start falling into place. I could have done without the session given by the SAP guys, but alas: win some, lose some. Tomorrow I’ll actually do some sessions from other tracks as well, here’s hoping they will be as interesting as most of those I’ve attended so far.

Mischa on Converting (Large) Applications to OSGi
BJ Hargrave and Peter Kriens are experts on OSGi and the goal of there presentation was to “Learn us how to Simplify Application Development by Building for the OSGi Service Platform”

OSGi is the dynamic module system for Java.
The Standard approach to modularization in Java has a couple of issues like:

• Granularity of classes and packages is too small for real world applications
• Jars provide packaging, but can not be used to restrict access
• Severe problems like split packages
• No versioning support
• Has no proper extension/collaboration model

Now the OSGi framework features the following:

• Class loading dispatch based on package name
• Allows multiple versions of the same class in one VM
• Jars can contain exported packages or private packages
• Bundle == Jar (Manifest contains metadata)
• Services provide a collaborative in-VM SOA model

So it contains all we need.

So how do you convert your application? Well, one step at a time.

• Analyse what the dependencies between the jars are.
• Make a project with your application and all its dependent jars
• Create a bundle activator that calls main (Include all libraries into one bundle).

Having a working bundle (whatever the size) is a good baseline and allows for gradually replacing the dependent jars with bundles
Keep it working!

Now there is a working version, start breaking up the bundle in smaller bundles.

Currently there are several open source projects that provide OSGi metadata:

• Apache (Derby, Struts, Felix, etc)
• All Eclipse code
• Codehaus Groovy

To make it even nicer there are also a couple of repositories online, so you don’t have to do all the work yourself. SpringSource Enterprise Bundle Repository is an example.

Unfortunately there are a few pitfalls such as:

• Too much at once (Get the complete application to work on OSGi, modularize a part, test, and iterate in small increments)
• Dynamic Class Loading (Most of the time custom class loaders are abused in applications, get rid of them)

So be careful and start small.

For those of you who want to look at some OSGi application models, have a look at the following examples:

• Spring-DM (formerly called Spring-OSGi)
• Apache iPOJO
• Service Application Toolkit
• OSGi Declarative Services