Gero Vermaas on...

This week the OSS/J TCK Foundation 1.0 is released. This open source project provides a basis for developing OSS/J TCKs and enables TCK developers to focus on developing functional tests and executes these exact same functional tests for all three OSS/J integration profiles (EJB, XML/JMS and web services). The TCK Foundation takes care of all the plumping required to bridge the three integration profiles.

The main improvements compared to the 0.9 version are:

• Performance: Execution of the tests against the XML/JMS and web services profiles is 4 times faster and now just 12-20% slower than the executing the tests against the EJB profile.
• The TCK Foundation itself performs more strict checking on messages being exchanged with an OSS/J API implementation.
  

The full release notes can be found here.

Currently the Order Management API and the OSS/J Fault Management API already use the TCK Foundation, but OSS/J API under development will also use this TCK Foundation. The new version of the Order Management TCK  (1.0.1) is already upgraded to use the 1.0 version of the TCK Foundation and will available from the Telemangement Forum website shortly.

Finally found some time to play with Google Maps. It is shockingly easy to create something with it and I decided to integrate it into my webalbum. I'm using JAlbum to generate a website for my photo's and using the Chameleon skin you generate a decent website easily. The Chamelon skin already links to Google Maps, but in a separate pop-up window and I wanted to have the map info next to the photo's themselves. Another feature I wanted was to have an overview of all photo locations on the index pages. Using the Google Maps API and by tweaking the Chameleon skin this was pretty easy to accomplish.

First challenge I had to solve was one related to Google Maps. When you sign up for the Google Maps API you get a API key that must be included in the pages that display a map. This key is bound to 1 directory and since most photo albums are organized in some form or directory structure that would require a new API key for each directory. Not very practical, especially when you use a automated process to organize your photo's by date of subject like me. The solution to this was to display the map in an iframe, this iframe is then included on the web album pages and because it is always the same page displayed in the iframe, it is possible to use 1 Google Maps API key. By including a couple of parameters (map width/height, coordinates, url of KML file) the contents of the map can be controlled by the page including the iframe.

Another challenge was not including hardcoded addresses in the templates. For a long time I was able to keep hardcoded addresses out of the solution, but in the end it became necessary to know the location at which the generated webalbum would be hosted. Reason being that the page containing the Google Maps scripts that is used in the iframe may be at a different server/location then the webalbum. However, for the index pages the Google Maps code needs to retrieve a KML file from the location where the webalbum is hosted and therefore needs the exact address.
Two properties have been added to the JAlbum project file:

# The root where the webalbum will be hosted
skin.webroot=/webalbums/gero
# The location of the HTML page that displays the map and
# has the Google Maps code in it
# This location is bound to the Google Maps API key.
skin.map.iframe=/webalbums/googlemap.html 
 

Both of the above properties could include a host name, but since I'm hosting everything on the same server that was not necessary for me.

The rest was pretty easy. JAlbum uses some template files to generate the webalbum pages and in these templates you have access to the details of the photo(s) being displayed. On the index template (index.htt) this information is used to generate a KML file of which the URL is passed to the iframe. The index pages display 1 marker for all photo's at the same location, when clicking the marker the balloon shows thumbnails of all images at that location. Clicking on one of the thumbnails takes you to large version of that photo.

On 1 photo template (slide.htt) the information provided by JAlbum is used to pass the coordinates of the current image.

There is probably some optimization possible (see also comments in the index.htt, slide.htt and googlemaps.html file), but getting this first version to work was great fun and really easy. The changes made to the standard index.htt and slide.htt file can be easily identified by searching for 'GOOGLE MAPS'.

Want to see what it looks like? Go here.

.... if it happens this year.

As I posted a while ago, completing the "Elfstedentocht" is one of my dreams. There were basically 3 challenges left to do that and today, one of these challenges was solved: I was a winner in the yearly draw that determines who is allowed to start. Yes!! 1 down, 2 to go:

1. As described, we need a real winter with some serious freezing. It's been already 10 years since the last one, so let's keep our fingers crossed
2. I need to practice and be in shape on time. This is actually the only point I can really influence myself and I'll increase the effort a bit. Luckily I joined  the local speed skating club last year, so there is definitely a basis ;-) Next month a 5KM outdoor artificial ice track will be opened and it's probably best if I do some training there ;-)

1. I did not run into a Starbucks for 48 hours after arrival (and the hotel and TeleManagement World conference takes place in the business district, you would expect that Starbucks is part of the infrastructure of such an area)
   
2. I have yet to see the first iPhone in the wild in the US

I'm flying to Telemanagement World conference in Dallas today and will do a presentation together with Andreas there on Wednesday. Since the tagline for the conference is about convergence we will link convergence to Order Management and explain why the Order Management API can help you converging your order management.

Looks like I'll have some free time on Sunday to explore Dallas. I'll probably visit the JFK museum, but the rest is still pretty open. Any suggestions on must sees in Dallas?

... your performance goes down the drain.

This problem caught me a couple of years ago and I ran into it recently again...

Years ago we designed an interface to a remote system to query some specific customer details. In case customer details could not be found by the remote system, an exception would be returned. Using an exception to deal with this case seemed valid, because (according to our client) the exception would only occur in max. 2% of the requests. During performance testing with production alike data we were not able to reach the required performance goals, performance was really bad. After running some profilers we discovered that most time was wasted on exception handling. It appeared that >50% of the requests was resulting is an exception because these specific customer details were not available. The incorrect assumption about the availability of those customer details  was seriously impacting the performance. After discovering this we decided to have the interface return 'null' in case no customer details could be found (thus avoiding exceptions) and performance was way over the goals we had to meet.

Why am I writing this? Well, I ran into the same problem with the OSS/J TCK Foundation. Performance of the OSS/J TCK Foundation was not satisfying and I was assuming this was due to the heavy use of reflection. However, after running some tests it appeared that although reflection related operations were consuming a significant amount of time, exception handling was consuming even more time. So again, if we could come up with a solution that did not result in that many exceptions, performance would be improved. Simply returning null, was not an option this time.

In the TCK Foundation we're using cglib to at runtime deal with subtypes of the OSS/J Common API class that are defined by either the specific OSS/J API or by a Reference Implementation of the OSS/J API. By doing this the TCK Foundation can be used to build TCKs for all OSS/J API because it is capable to handling OSS/J API specific extensions without need to write specific code.
In a
MethodInterceptor.intercept(java.lang.Object obj, java.lang.reflect.Method method, java.lang.Object[] args, MethodProxy proxy))
implementation we were always first invoking the requested operation on the
proxy object using proxy.invokeSuper() and only when it returned an NoSuchMethodException (for example when the method was not implemented by the object) we would apply some other logic to handle the requested method appropriately.

The optimization  was to cache the methods that resulted in a NoSuchMethodException in static variable and before invoking the method on the proxy we first check if the method is already registered as being not implemented. If we already know it is not implemented, there is no need to invoke the method again on the proxy. Now we only get the NoSuchMethodException once for each not implemented method and after that we know we need to apply the other logic.

This (again simple) fix  doubled the performance!

Next thing is to see if we can eliminate some of the reflection logic, profiling showed that this is now the biggest performance bottleneck (although performance is acceptable now).

Couple of weeks ago Andreas and myself recorded a podcast about the Order Management API for the Xebia Podcast. This episode (12) gives an introduction into the Order Management API and we also discuss how the JSR264 Expert Group organized itself (Scrum).

I didn't quite know what to expect, but participating in a podcast is fun and not so hard (of course, there is the production work that needs to be done afterwards, but that is in good hands with the Xebia podcast team).

So head over to the Xebia podcast page and subscribe to the feed, there is a lot of interesting stuff on this podcast!

And since I'm one of the JSR264 Expert Group (EG) Members this is a good day for me. The JSR264 Order Management API already passed the JCP ballot on August 27th, but getting through all the processes from both the OSS/J Community and JCP does take some time....

On the Xebia blog I posted an entry that describes the core features of the Order Management (OM) API. Make sure you read that one for details and of course you can download the specification and read all details of the API. The JSR264 Java.net page is also a good source of information.

My focus area in the EG was the Technology Compatibility Kit (TCK). Each JSR delivered through the JCP process must include this TCK such that implementors of an API can validate if the API is compliant to the specification. As part of the development of the OM API I started the OSS/J TCK Foundation project on Java.net. Why?

A little background... the Order Management API is part of the OSS/J Family of APIs. This group of API has it's origin in the telecommunications world, but several of the APIs (Order Management included) can also be used outside the telecommunications domain. All OSS/J APIs follow a common set of design principles, for example: all functionality exposed by the API must be available in 3 so-called integration profiles:

• EJB
• XML/JMS
• WebServices

These integration profiles are functionally equivalent and all expose the same operations. A TCK for an OSS/J API therefore has to test the same functionality on all three integration profiles. In a perfect world you would want to write one set of tests and execute it against the three integration profiles without developing integration profiles specific code. The OSS/J TCK Foundation project makes this possible.

Using the OSS/J TCK Foundation you develop one set of tests and are coded against the interface exposed by the EJB profile. The OSS/J TCK Foundation then enables you to execute these same tests against the XML/JMS and Webservices profiles. The advantages are obvious:

• OSS/J TCK developers can focus on developing tests.
• No need to develop plumping code for XML/JMS and Webservices profiles.
• A consistent set of tests is executed on all three profiles (previous OSS/J TCKs had variations in the tests for the various integration profiles).
• The amount of effort to develop a TCK is significantly reduced.

Currently this OSS/J TCK Foundation is used by the Order Management API TCK (yes, of course I eat my own dog food) and the Fault Management API TCK (so even better, others eat it too ;-)). More OSS/J API have shown interest so I expect that it's use will increase over time.

This week I realized how important podcasts have become for me as a news source.

I'm subscribed to a number of IT related podcasts (see list in sidebar on the right of this blog) and virtually always listen to podcasts on the daily 45 minutes commute to work. Using an iTrip as the FM transmitter on my iPod enables my to listen to them using the car stereo. Very convenient, you do loose a bit of sound quality but for podcasts that is not really an issue.

I was on vacation for a couple of weeks and did not listen to podcasts during that period. After returning back to work colleagues and friends started to mention stories that I was not aware of yet and I wondered why... While listening to the backlog of podcasts I realized it: I did not use one of my main news sources for weeks, podcasts.

Examples of what I missed:

• The JavaPosse podcast announced that JSR264 Order Management passed the JCP EC ballot (as EG member I knew we passed the ballot, but was kind of surprised that the JavaPosse already picked it up).
• There is an unlock available for the iPhone (from MacCast podcast)

And I still have 20 podcasts in the backlog...

On November 7th Andreas Ebbert-Karroum, John Wilmes and myself will be presenting a session titled "Converge your Order Management" at the TelemanagementWorld conference in Dallas. The theme for this conference is "Managing Operations for Converging Services" so with our presentation we're hitting the nail on the head. In our presentation we'll explain why using the Order Management API eases order management in a converging world (and we'll also briefly touch on the SOA buzzword). After doing the presentation with Andreas and John in Nice at Telemanagement World earlier this year I'm really looking forward to Dallas. It was a lot of fun in Nice and I'm sure it will be a lot of fun in Dallas again. There will definitely be surprises again with regards to people using the Order Management API without us knowing about it (especially now that we passed the JCP ballot and will publish the 1.0 version shortly).

Since a while I'm using iPhoto to manage my photo collection. One thing that kept annoying me was that I had to do manual actions to include selected photo's from iPhoto in my webalbum. Of course you can generate webalbums from iPhoto, but you need to do that over and over again each time you want to add more pictures to your webalbum. The solution I wanted to have was:

• Import pictures into iPhoto
• Tag them with keywords
• Have them appear in my webalbum automatically
  • sorted by date
  • sorted to subject

I only need to maintain iPhoto and the rest is automatic.

I've got this working now for the sorted by date part. What I now do is:

• In iPhoto I tag the pictures that I want to appear in my webalbum with a special keyword (webalbum)
• Scheduled a cronjob that periodically:
  • Runs a ruby script sortImages.rb [note: this is an updated version of the previous script, the description in the blog post is not 100% accurate anymore] which parses the iPhoto AlbumData.xml file. This scripts selects all pictures with the 'webalbum' keyword and exports these to a directory structure in which they are sorted by year/month. (The script first checks if the AlbumData.xml is changed since the last run to prevent unnecessary work.)
  • If the ruby script sortImages.rb [see previous note] found any changes, kick of the webalbum application to update the webalbum (I'm using JAlbum, but you can use any webablum application that takes a directory structure as input).

The shell script is really simple.

ruby sortByDate.rb webalbum /tmp/webalbum '/path/to/AlbumData.xml'

if [ $? -eq 0 ]; then
cd  /opt/JAlbum
java -Xmx256M -Djava.awt.headless=true -jar JAlbum.jar
 -projectFile webalbum.jap -appendImages
fi

The sortImages.rb [see previous note] script takes 3 arguments:

• The keyword that identifies the pictures to include in the webalbum.
• The directory to which the pictures should be copied. In this directory new directories per year/month will be created.
• The path to the iPhoto AlbumData.xml file

Writing the Ruby script was easy, it was the first time i really tried to do something with Ruby and I got it done pretty quick.... although I bet there is some improvement possible. Feel free to let me know ;-) The actual tricky parts were:

• Figure out the structure of the AlbumData.xml file
• Transform the DateAsTimerInterval element from the AlbumData.xml file into the date the picture was taken.

Next plan is to create a script that generates a directory structure using the other keywords set on the pictures. For example, group all pictures tagged with 'webalbum' and 'vacataion' and 'friends'. Sounds simple, but need to come up with some logic to be able to create a multi level structure where level one contains the images with only the 'vacation' keyword, level 2 has 'vacation' and 'friends' etc. What do I do with pictures that could end up in multiple parts of the tree?

*** Update ***

I just tested if this solution still works with iPhoto '09 and it works perfectly.

In the Order Management Expert Group we're counting down the week for the final release of the Order Management API (JSR264). We managed to put out an Proposed Final Draft 2 last week and this is your last chance to provide feedback before the 1.0 release. Feel free to drop us a mail at jsr-264-comments@jcp.org. As posted before, I also posted a summary of the Order Management features here. In the next couple of weeks we'll be ironing out the last details in the RI, TCK and documentation and then we'll release it.

TMW Nice 2007 is history, time for a quick flashback. Just as at JavaOne Andreas and myself did a presentation on the Order Management API (JSR264) and it's fit for use in an SOA. This time we were joined by John Wilmes, CEO of Ceon Corporation. It is really a pleasure to work with them and doing a presentation with a 2 or 3 people is more fun than doing it alone. Compared to the JavaOne presentation we weaved the two main subjects of the presentation such that Andreas and I would hand over to each other every couple of slides. That worked really well and in my opinion it made the presentation more dynamic. On the Xebia blog I posted a two part summary of the presentation (part1, part2).

At TMW Nice lunches are a bit more structured compare to JavaOne. Just as at JavaOne you join a queue, but at TMW you're directed to your seat and lunch is being served on the table. No take-away lunches. A nice side effect of this is that you spent 30 minutes with people you've never met before and while eating you discuss the conference, your work, etc. One day I was seated next to someone from a Danish operator that was using the 0.8 version of the Order Management API. Now that was really cool, the API is not even 1.0 yet and it is already being used. I wish we knew who else is using it..., so if you do, drop us a line on the jsr264 comments list.

Just as with JavaOne I ran into a number of former colleagues, co-workers and customers. Always nice to catch up with them, on one of the evening beach parties for example ;-)

During the keynote Nicholas Negroponte explained the vision of the One Laptop Per Child organization. They're not only doing really good work to enable children in underdeveloped countries to get education, but as part of this developed a $100 laptop. I was impressed, check it out at www.laptop.org.

Call for papers for TMW Dallas is already closed and again we submitted a proposal...

JavaOne 2007 is history for almost a week already and finally I found a little time to post a few of the highlights. I arrived on Sunday and Sunday evening Klaas Jan of the NLJUG (like very year) organized a nice diner for all NLJUG member. This year famous blogger MaryMary also joined. Monday was mostly spend together with Andreas to prepare our BoF session. We had worked on the slideset over the phone, but this was the first time we ran through it face to face and that definitely helped us to make it a bit more smooth and cut some slides to meet the time restrictions. When we registered in the speaker room I finally appreciated the fact that JavaOne attendees had to register themselves for session they wanted to attend. Why,... well now the organization could tell us how many people we could expect: 130+! Most likeliky not all 130 would show up, but it was a bit more than we expected and therefore we decided to cut the 'interactive' parts from the slides. With so many attendees that would get out of control (time wise).

Tuesday started of with the key note. As usual a slick and good produced session with JavaFX (Mobile), RealTime Java 2.0 and the milestone of achieving full open source of Java SE as the highlights. The actual mail notifying the world that Java SE was not fully available as open source was typed in during the key note... never try to type serious text in a demo... it was proven again that this is hard to do.

After a nice Mexican diner Andreas and I prepared for our BoF. We had the best timeslot possible, the first BoF on the first day of JavaOne when everybody still fresh and eager to attend evening sessions. We had a good audience (~80) and the session went pretty smooth. On my employers blog I posted an entry regarding the first part of the session: Order Management and SOA. In a few sentences:

Order Management is a process that is used in all industries and the Order Management API (JSR 264) is an API that can be used in all these industries. It is defined such that it fits perfect in an SOA and many of the concepts that apply to SOA are applied or supported by the Order Management API. This API can help you to reduce you integration costs.

Apart from the content of the session JavaOne is always a good place to meet old colleagues and make new friends. When they mention your session in their blog, it gets even better. By the way, Andreas really proved that he practiced, one of his slides had some example XML code and included a date/time: Tue, May 8th, 2007 20:18:00. This was intended to be the moment when the slide should be presented, guess what? Right on time, pretty impressive. Even more impressive was the fact that someone in the audience noticed this, well done Vincent, you were really paying attention ;-)

Unfortunately I missed the JavaPosse BoF session, it was scheduled after our BoF and we decided that we deserved a beer... and after hearing the podcast I regret that even more. Next year I'll definitely attend it.

Wednesday, Thursday I attended sessions on Ruby which convinced me that I should start playing with it. Especially with the good tool support like in NetBeans. Tor Norbye (The 'Demo Stud' as James Gossling announced him on Fridays keynote) showed of the cool features of NetBeans in a technical session and during Fridays keynote. Back home I immediately installed NetBeans 6M9 and it indeed works really smooth. Code completion is smarter, color coding is much smarter (for example variable names of unused of mistyped variables appear light grey or italic. Immediately notificying you that something is wrong.) You should really give it a try.

The session on BluRay, OCAP (Open Cable Application Platform), RealTime Java were interesting to get a feel for what going on in these areas. Not my speciality, but that's the good part of conferences like JavaOne: you can get a taste of all kinds of technology that you do not run into during day-to-day business.

Now I need to get ready for the next conference, Telemanagement World in Nice.

Just wanted to let you know that I started a sequence of blog posts on my employers blog titled Java in Telecommunications.

At Telemanagement World in Nice (May 20 -24) Andreas, John Wilmes and myself will do a similar presentation as the one at JavaOne this year. The presentation is titled Streamline Order Management in your SOA with OSS/J and is part of the Systems and Software track at TMW.

Together with Andreas I'll be doing at BoF sessions at this years JavaOne: BOF-8860 How to Integrate Your Order Order Management Solution in a SOA. In this session we'll explore the OSS/J Order Management API and demonstrate how it can be used in an SOA based environment. Since it's a BoF session we plan for an interactive session and we'll use the Order Management Reference Implementation as a basis for a demo.


I keep humming that song: if you're going to San Francisco...

I recently switched my server at home from a PC running Linux to a Mac Mini. Should have done that way earlier. The OSX UI is so much more convenient than a everything that Windows and Linux have to offer and getting the server processes running was dead easy (MAMP, Zimbra as mail/calendar server, Tomcat to run blogs etc). And then of course the great tools in the iLife suite make managing you photo collection, creating DVDs etc. so simple.

In the process of buying the Mac Mini I once took my 1.5 year old daughter with me the to the Mac shop. In the entrance they had an old Apple Lisa standing and it was love at first sight between my daughter and the Lisa. So young and already instinctively falling for the right computer :-)