BangBits

Java 7 on Ubuntu 11.04

2011-08-09T16:09:00.009+02:00

So after 5+ years, we finally have a new version of Java. In spite of mixed reviews, as a software engineer working a lot on the JVM, I still wanted to take it for a spin. However, being an Ubuntu user, this involves a tad bit of work since there are only RPM and binary packages available at this time.

So until there are official or unofficial .deb packages available, we're going to have to sneak in the raw binaries outselves. The following is how I did this on my 64bit Ubuntu 11.04 system. I take no responsibility in breaking your existing Java installation yada yada, you do this at your own responsibility.

Procedure
Start by downloading the binary.



casper@workstation:~$ wget http://download.oracle.com/otn-pub/java/jdk/7/jdk-7-linux-x64.tar.gz

Then unpack it.



casper@workstation:~$ tar -xzf jdk-7-linux-x64.tar.gz

Remove packed archive and move/rename the extracted folder into something a little more Ubuntu appropiate.



casper@workstation:~$ sudo rm java-7-sun-1.7.0.tar.gz

casper@workstation:~$ sudo mv jdk1.7.0 /usr/lib/jvm/java-7-sun-1.7.0

Follow the Ubuntu tradition, by symlinking a generic major java version to a concrete minor version.



casper@workstation:~$ sudo ln -s /usr/lib/jvm/java-7-sun-1.7.0 /usr/lib/jvm/java-7-sun

Override Ubuntu's standard alternatives mechanism, replacing links to Java 6 with links to Java 7. It would be better to use the update-alternatives tools available in Ubuntu, but I was unable to make this work. If you screw something up here, you may have to uninstall and reinstall your JDK/JRE stuff, in order to revert to a working Java installation.

Delete any existing symlinks.



casper@workstation:~$ sudo rm /etc/alternatives/java

casper@workstation:~$ sudo rm /etc/alternatives/javac

casper@workstation:~$ sudo rm /etc/alternatives/javadoc

casper@workstation:~$ sudo rm /etc/alternatives/javah

casper@workstation:~$ sudo rm /etc/alternatives/javap

casper@workstation:~$ sudo rm /etc/alternatives/javaws

casper@workstation:~$ sudo rm /etc/alternatives/java_vm

Create the new symlinks.



casper@workstation:~$ sudo ln -s /usr/lib/jvm/java-7-sun/jre/bin/java /etc/alternatives/java

casper@workstation:~$ sudo ln -s /usr/lib/jvm/java-7-sun/bin/javac /etc/alternatives/javac

casper@workstation:~$ sudo ln -s /usr/lib/jvm/java-7-sun/bin/javadoc /etc/alternatives/javadoc

casper@workstation:~$ sudo ln -s /usr/lib/jvm/java-7-sun/bin/javah /etc/alternatives/javah

casper@workstation:~$ sudo ln -s /usr/lib/jvm/java-7-sun/bin/javap /etc/alternatives/javap

casper@workstation:~$ sudo ln -s /usr/lib/jvm/java-7-sun/bin/javaws /etc/alternatives/javaws

casper@workstation:~$ sudo ln -s /usr/lib/jvm/java-7-sun/jre/bin/java_vm /etc/alternatives/java_vm

Finally, we may aid various client software in locating where Java in installed, by adding a few environment variables. Do this by editing .bashrc in your home directory.



casper@workstation:~$ gksudo gedit $HOME/.bashrc

Scroll down to the end of the file and add two new lines:



export JDK_HOME=/usr/lib/jvm/java-7-sun

export JAVA_HOME=$JDK_HOME

Restart and that's pretty much it, this worked for me, hope it works for you too. Otherwise, throw me a comment below.

Update: If you are unable to run applets wtihin your browsers, this may be caused by the existing Java Plug-in 1.6 clashing with the new incompatible JRE 1.7 you just installed. To remidy this, you can launch the Java Control Panel and disable the JRE 1.7, making 1.6 the only (and thus default) one.

As you can see below, you still retain Java 1.7, but applets and webstart won't try to use any of this new stuff.

Optware/ipkg on Synology DS211+

2011-05-20T20:01:00.023+02:00

Modding
Note that the following covers the DS211+ device, which is characterized by being based on the Marvell Kirkwood mv6282 ARM core (1.6Ghz version of 1.2Ghz mv6281). AFAIK the content of this blog entry should be equally applicable to all DS211 variations, but you should consult the Synology wiki for your device to be certain.

While quite feature rich out-of-the-box, developer types will likely want to make their NAS do even more, either out of a real need or just to tinker. For instance, I eventually plan to connect my USB weather station and generate live charts. Because of the modding desire, Synology has a faily comprehensive wiki about the subject. To make a long story short, ease of modding is greatly assisted by the possibility of installing Optware package manager.

Installing Optware
Optware (ipkg) is an online package system a la what you may know from Debian/Ubuntu. This makes it easy to locate, install and uninstall compiled binaries (*.ipk) through the command-line.

Bootstrapper and Optware packages are maintained by the NSLU2-Linux community for use with various modifiable hardware devices incl. many Synology products. The installation procedure simply involves you downloading and installing the Optware-bootstrapper for your NAS. Here's what I wrote while logged in as root via SSH/telnet, to get it working.

Download the Optware bootstrapper:


NAS> cd /volume1
NAS> wget http://wizjos.endofinternet.net/synology/archief/syno-mvkw-bootstrap_1
.2-7_arm-ds111.xsh
--22:58:07--  http://wizjos.endofinternet.net/synology/archief/syno-mvkw-bootstrap_1.2-7_arm-ds111.xsh
           => `syno-mvkw-bootstrap_1.2-7_arm-ds111.xsh'
Resolving wizjos.endofinternet.net... 94.212.228.25
Connecting to wizjos.endofinternet.net|94.212.228.25|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 251,866 (246K) [text/plain]

100%[====================================>] 251,866      435.14K/s             

22:58:08 (434.50 KB/s) - `syno-mvkw-bootstrap_1.2-7_arm-ds111.xsh' saved [251866/251866]

Start the installation:


NAS> sh syno-mvkw-bootstrap_1.2-7_arm-ds111.xsh 
Optware Bootstrap for syno-mvkw.
Extracting archive... please wait
bootstrap/
bootstrap/optware-bootstrap.ipk
bootstrap/wget.ipk
bootstrap/bootstrap.sh
bootstrap/ipkg.sh
1227+1 records in
1227+1 records out
bootstrap/ipkg-opt.ipk
Creating temporary ipkg repository...
Installing optware-bootstrap package...
Unpacking optware-bootstrap.ipk...Done.
Configuring optware-bootstrap.ipk...Modifying /etc/rc.local
Done.
Installing ipkg...
Unpacking ipkg-opt.ipk...Done.
Configuring ipkg-opt.ipk...WARNING: can't open config file: /usr/syno/ssl/openssl.cnf
Done.
Removing temporary ipkg repository...
Installing wget...
Installing wget (1.12-2) to root...
Configuring wget
Successfully terminated.
Creating /opt/etc/ipkg/cross-feed.conf...
Setup complete.

BusyBox v1.16.1 (2011-04-08 10:13:55 CST) built-in shell (ash)
Enter 'help' for a list of built-in commands.

NAS>

Note, if you get the message "Error: CPU not Marvell Kirkwood, probably wrong bootstrap.xsh", this is likely due to a too agressive sanity check (mv6281 but not mv6282) in the install script. If the output of the command "cat /proc/cpuinfo" mentions a "Feroceon" CPU, then you may safely open up the file "/volume1/bootstrap/bootstrap.sh" and edit line 21, changing "Feroceon-KW" to just "Feroceon", and run the script manually with "sh /volume1/bootstrap/bootstrap.sh".

The above will install a boot hook and create the directories /volume1/bootstrap and /volume1/@Optware where package manager and installed packages will reside. The content in /volume1/@Optware can also be found in /opt, due to an Optware bind mount requirement you can verify by invoking the mount command:


NAS> mount | grep @optware
/volume1/@optware on /opt type bind (bind)

Now reboot the NAS:


NAS> reboot

Managing packages
After a reboot, you can update the list of packages with:


NAS> ipkg update
Downloading http://ipkg.nslu2-linux.org/feeds/optware/cs08q1armel/cross/unstable/Packages.gz
Inflating http://ipkg.nslu2-linux.org/feeds/optware/cs08q1armel/cross/unstable/Packages.gz
Updated list of available packages in /opt/lib/ipkg/lists/cross
Successfully terminated.
NAS>

You can list all packages with "ipkg list" or search specific packages with "ipkg list [wildcard]".


NAS> ipkg list cpu* 
cpufrequtils - 006-2 - To make access to the Linux kernel cpufreq subsystem easier for users and cpufreq userspace tools, a cpufrequtils package was c
Successfully terminated.
NAS>

To install a package, simply type "ipkg install [name]". You may also browse the available packages by accessing the repository directly from within a browser.


NAS> ipkg install iperf
Installing iperf (2.0.4-1) to root...
Downloading http://ipkg.nslu2-linux.org/feeds/optware/cs08q1armel/cross/unstable/iperf_2.0.4-1_arm.ipk
Configuring iperf
Successfully terminated.
NAS>

Removing packages is just as easy as installing:


NAS> ipkg remove iperf 
Removing package iperf from root...
Successfully terminated.
NAS>

To make sure all installed Optware packages are up to date:


NAS> ipkg upgrade     
Upgrading grep on root from 2.7-1 to 2.8-1...
Downloading http://ipkg.nslu2-linux.org/feeds/optware/cs08q1armel/cross/unstable/grep_2.8-1_arm.ipk
Configuring grep
update-alternatives: Linking //opt/bin/grep to /opt/bin/grep-grep
update-alternatives: Linking //opt/bin/egrep to /opt/bin/grep-egrep
update-alternatives: Linking //opt/bin/fgrep to /opt/bin/grep-fgrep
Successfully terminated.
NAS>

Uninstalling Optware
To my knowledge, there isn't a one-liner for uninstalling the Optware system. It involves stopping the Optware service, unmounting the /opt bind mount, deleting the folder/files, editing the Linux service script and rebooting:


NAS> /etc/rc.optware stop
NAS> umount /opt
NAS> rm -rf /volume1/@optware
NAS> rm -f /etc/rc.optware
NAS> echo -e "#!/bin/sh\n" > /etc/rc.local
NAS> reboot

Note that the above wipes the rc.local script. If you have added custom stuff beyond just Optware, you should edit out the Optware stuff manually!

Of course, there aren't as many packages available as one would like, but it's still impressive that you can install Mono, Java, Python, Perl, Lua etc. on a small NAS device just with a single command. Hope this entry helps others get to hacking on their Synology device.

Home network benchmarking with iperf

2011-05-19T00:16:00.025+02:00

Having recently purchased a new NAS device, as well as upgraded network cables in my house to cat6 (1Gbps), I started wondering about just how fast and healthy my network setup was. Are all cables in order? Are any of my switches a bottleneck? Any particular slow endpoints?
performance challenged
There are of course commercial software to assist in this, but after having compiled and loaded up a bunch of Linux software onto my small NAS, it was only natural to give "iperf" a try. It's a small open source client-server utility you start in listening mode on one device, and in transmission mode on another, and have it transfer a bunch of random data over TCP. You can obtain iperf from sourceforge, from your Linux package manager or just Google for precompiled binaries if you are lazy.

Simple unidirectional test
The process is simple, log onto the receiving device and run iperf in listening mode, in the following case it's my Synology NAS:


NAS> iperf -s -p 5555
------------------------------------------------------------
Server listening on TCP port 5555
TCP window size: 85.3 kByte  (default)
------------------------------------------------------------

Then also run iperf, though this time in client mode targeting the server you just started:


casper@laptop:~/$ iperf -c 192.168.0.100 -p 5555
------------------------------------------------------------
Client connecting to 192.168.0.100, TCP port 5555
TCP window size: 19.0 kByte  (default)
------------------------------------------------------------
[  3] local 192.168.0.234 port 52742 connected with 192.168.0.100 port 5555
[ ID] Interval       Transfer     Bandwidth
[  3] 0.0-10.3 sec   26.2MBytes   21.4 Mbit/sec

Note that the above result is quite slow, as a consequence of being on congested WiFi and benchmarking the slowest node in my household, the NAS.

This gives you a bps metric for how fast the client could transfer data to the server. To benchmark both upstream and downstream, you must reverse the client-server pair and repeat the process.

Complex bidirectional test case
By running tests between each and every possible node, it becomes possible to draw some interesting conclusions about the setup in general. The wired setup in my household looks roughly like this (without smartphones, TV, PS3, IP phone etc.):

With Gigabit connections between all major nodes, I expected to see throughput up around 90% of the theoretical maximum bandwidth. What I saw was hardly consistent however, as the following graph shows:

Note that solid edges signify physical cat6 cables, dashed edges logical connections. Edges are labeled with directional throughput in Mbps and nodes contains summerized throughput on the form in/downtream and out/uptream.

Lessons learned
Infrastructure nodes like router and switch would appear to have performed optimal, and there is no hinting of faulty cabling. On several occasions, one can observe throughput beyond 940Mbps, or 94% of the theoretical maximum.
I was a little surprised to see that the overall best performer, was actually my 3 year old sub-notebook. The network stack (hardware+software) is obviously very well implemented on the laptop. The PC's, particularly one of them, would probably benefit from a new dedicated Gigabit adapter rather than relying on the one built into the motherboard.
However, the greatest surprise was to see how the NAS struggled, particularly when receiving data and when having to cross 2 switches. In all fairness, the slow CPU of the NAS (1.6GHz ARM) could very likely be key to the poor performance of iperf - loopback tests on all endpoints incl. the NAS suggests this to be the case.

There are of course many other parameters one could care about; ping time, jitter, packet loss, UDP packets, jumbo frames etc. but I was mostly just concerned about TCP bandwidth throughput. I've learned that perhaps I should flash my DD-WRT router back with the original firmware, or perhaps try another open source image like Tomato, in order to see whether I can mitigate some of the observed bandwidth loss. It also seems abundantly clear, that the network system of my NAS device is more optimized for delivering data than receiving it.

I'd like to do a plugin for Synology's management interface, having it run native iperf against a Java implementation hosted by the client as an applet. Currently looking into whether this is possible. I fear it's too low level for Java, as this was one of the reasons I changed to C# for dealing with raw sockets some years ago.

SVN checkout without branches and tags

2011-03-24T00:10:00.022+01:00

Subversion (SVN) is a decent step up from CVS, and Maven (MVN) likewise from Ant. However one thing continues to bug me about how the two work together. Since MVN requires a fixed directory layout of /trunk, /tags and /branches, it becomes more and more painful to checkout or update a complete corporate source tree from one of the lower roots.

In the perfect world, every project may be checked in at the root of the tree, but we all know the world ain't perfect and it's not unusual to require checkout and build of up to a dozen SNAPSHOT dependencies spread around deeper in the hierarchy. There is no (to my knowledge) easy way around this, either you have to live with insanely long checkout times and the associated waste of disk space, or meticulously checkout each every project trunk individually.

As unimpressed I am by the Java language itself, the hat must come off to the plethora of readily available libraries on this platform. One of these libraries is SVNKit, a complete client API for accessing SVN servers. So I wondered just how hard it would be to put a client together, doing full tree checkouts, *without* /tags and /branches. Turns out it only took a few hours and under 100 lines of code. :)



/* Copyright (C) 2011 Casper Bang (casper.bang@gmail.com) */

package com.blogspot.coffeecokeandcode;

import java.io.File;
import java.util.Collection;
import org.tmatesoft.svn.core.*;
import org.tmatesoft.svn.core.io.*;
import org.tmatesoft.svn.core.wc.*;
import org.tmatesoft.svn.core.internal.io.dav.DAVRepositoryFactory;

public class svntrunks 
{
    public static void main(String... args) throws SVNException
    {
        String checkoutPath = null;
        String username = null;
        String password = null;
        String checkoutRootPath = new File("").getAbsolutePath();
        
        if(args.length > 2){
            checkoutPath = args[0].trim();
            username = args[1].trim();
            password = args[2].trim();
            
            if(args.length == 4)
                checkoutRootPath = args[3].trim();
        }
        else
        {
            System.out.println("Usage: java -jar svntrunks.jar URL USERNAME PASSWORD [PATH]\n");
            System.out.println("URL:        The mandatory path to the SVN reposatory");
            System.out.println("USERNAME:   The username to log in as");
            System.out.println("PASSWORD:   Password for the username");
            System.out.println("[PATH]      Optional destination folder (defaults to current)\n\n");
            System.out.println("Example:   java -jar svntrunks.jar https://svn.java.net/svn/jersey~svn david secret jersey-checkout");
            System.exit(1);
        }
        
        DAVRepositoryFactory.setup();

        final SVNRepository repository = SVNRepositoryFactory.create( SVNURL.parseURIDecoded(checkoutPath) );
        repository.setAuthenticationManager( SVNWCUtil.createDefaultAuthenticationManager( username , password ) );
        
        final SVNClientManager clientManager = SVNClientManager.newInstance(null, repository.getAuthenticationManager());
        final SVNUpdateClient updateClient = clientManager.getUpdateClient();
        updateClient.setIgnoreExternals(false);
        
        final SVNNodeKind nodeKind = repository.checkPath( "" ,  -1 );

        if ( nodeKind == SVNNodeKind.NONE ) {
            System.err.println( "There is no entry at '" + checkoutPath + "'." );
            System.exit( 1 );
        } else if ( nodeKind == SVNNodeKind.FILE ) {
            System.err.println( "The entry at '" + checkoutPath + "' is a file while a directory was expected." );
            System.exit( 1 );
        }

        System.out.println("Checkout source: "+ checkoutPath );
        System.out.println("Checkout destination: "+ checkoutRootPath );
        traverse(updateClient, repository , checkoutPath, checkoutRootPath, "");
        System.out.println( "Repository latest revision: " + repository.getLatestRevision( ) );
    }

    public static void traverse(SVNUpdateClient updateClient, SVNRepository repository, String checkoutRootPath, String destRootPath, String repoPath ) throws SVNException {

        System.out.println(repoPath);
        
        updateClient.doCheckout(
                SVNURL.parseURIDecoded(checkoutRootPath + "/" + repoPath),  
                new File(destRootPath + (!repoPath.isEmpty() ? "/":"") + repoPath), 
                SVNRevision.UNDEFINED, 
                SVNRevision.HEAD, 
                SVNDepth.FILES, false);
    
        final Collection<SVNDirEntry> entries = repository.getDir( repoPath, -1 , null , (Collection) null );
        for(SVNDirEntry entry : entries){
            if(!entry.getName().equalsIgnoreCase("branches") && !entry.getName().equalsIgnoreCase("tags")){
                if ( entry.getKind() == SVNNodeKind.DIR ) {
                    traverse(
                            updateClient, 
                            repository, 
                            checkoutRootPath, 
                            destRootPath, 
                            ( repoPath.equals( "" ) ) ? entry.getName( ) : repoPath + "/" + entry.getName( ) );
                }
            }
        }
    }
}

Note that I do not subscribe to the legacy policy of 80 columns per line! This is 2011, I have more monitors than I have shoes and none are below 22".

You may download the complete source, or just the compiled binary I have build. The source code is licenced under GPL.



casper@workstation:~/Development/Code/Java/$ java -jar svntrunks.jar
Usage: java -jar svntrunks.jar URL USERNAME PASSWORD [PATH]

URL:        The mandatory path to the SVN reposatory
USERNAME:   The username to log in as
PASSWORD:   Password for the username
[PATH]      Optional destination folder (defaults to current)


Example:   java -jar svntrunks.jar https://svn.java.net/svn/jersey~svn david secret jersey-checkout
casper@workstation:~/Development/Code/Java/$

Now it's considerably easier to do a new clean checkout of trees, in fact the tool cut down checkout time from the corporate tree I work in, with a factor of about 10! Your mileage may of course vary, depending on the amount of snapshots and branches in the tree.

There are some obvious improvements I'd like to add, i.e. I never understood why the vanilla SVN client doesn't include commands to detach previously checked out source from its repository. Of course, the true solution to the above problems may simply be to switch to a distributed SCM/VCS like Mercurial or Git. :)

My issues with Spring

2010-09-04T19:56:00.039+02:00

One of the things I've had to come to turns with as a professional Java developer, is navigating the massive chaos of frameworks out there. It doesn't really matter which corner of the development stack we're talking, in Java we're sure there won't ever be just one official standard; if we're lucky, we can identify a state-of-the-art de-facto standard and if we're *truly* lucky, our choice will remain a good one for longer than a few years.

One of those de-facto standards appears to be Spring. There is little doubt, that IoC (Inversion of Control), or more specifically DI (Dependency Injection), can be a great tool to decouple concrete dependency layers. However, in my opinion Spring introduces just as many problems as it solves, and here's my take on why.

Everything and a Kitchen Sink
While Spring does address IoC/DI, it also does a gazillion other things as well - as evident by looking at the Spring maven repo. On one of the project I was on, my Maven POM ended up holding 15+ dependencies to Spring related technologies, leading me to categorize Spring as containing everything and a kitchen sink. Spring is so many things in one, that it's hard to fathom let alone explain the boundaries; there's Spring JDBC, Spring MVC, Spring Security, Spring Remoting, Spring AOP, Spring DI, Spring RESTfull and probably much more that. Each part may very well be useful in their own right, but one can not help but to be weary of this creeping featuritis.

Abstraction layer madness
Most of the frameworks we use, take the shape of some sort of abstraction layer shielding us from hairy details further down. However, from navigating a Spring projects various configuration files and Stack traces (btw. confirmed by Nasa of being visible from space), I get reminded of a short conversation between two luminaries within our industry.

Computer Scientist Butler Lampson is known to have said:

"All problems in computer science can be solved by another level of indirection"

.

Whereto David Wheeler supposedly responded wisely:

"...except for the problem of too many layers of indirection."

.

In other words, perhaps we should be careful not to get blinded by magic frameworks which, when everything gets added up, turns out to be as much a disadvantage as an advantage. In this day and age, arguably it's the frameworks rather than the programming languages, we spend the most time understanding - but where we should spend our time, is in solving our clients problems.

Configuration madness
The inventor of Java, James Gosling, is known to have said something along the line of

"Every configuration file ends up becoming a programming language"

Now, if you've dived into Spring, you know this is very much true. Inevitably you'll find yourself looking up documentation trying to figure out what XML to write, where to write it and in which order. There's a trend towards depending on intelligent IDE's in order to conquer this type of complexity, but honestly that feels more like treating the symptom rather than fixing the actual problem. This goes for annotations too btw. which is often abused as a type-unsafe embedded DSL sneaked in by language designers who gave up on trying to innovate by adding first-class language constructs.

Conclusion
No bashing of framework overuse can be complete, without a reference to the Hammer Story. While I understand that we do need frameworks and they can indeed help us solve many problems faster and better, Spring is one of those I just can't recommend. Perhaps it's just me and my interpretation of KISS, but since a picture says a thousands words let me end with one.

So if you're one of those who heard about Ioc and DI, but haven't quite made the jump yet, I urge you to try an alternative to Spring, one that does indeed reveal up front how deep the rabbit hole goes. Google's Guice is a good candidate, and it's a testament to its simplicity that it has been ported to other corners of Java i.e. Android.

Update: It seems even Maven is now using Guice.

Update: I had no idea that jotting down my experiences and associated feelings about Spring would cause such controversy. It's clear that Spring is working fine for many and/or is worth the extra complexity. For the record, I don't hate Spring but just find that perhaps we should question whether it's really needed before pulling in dependencies from left and right.

So take this for what it is; a developer questioning whether we can't solve our problems in more elegant and lean ways than what the Spring stack has to offer. I think that often we can. Although at the concrete level I primarily address Spring IoC/DI above, the mere vastness of Spring makes it impossible to go into every aspect even if I had the knowledge to do so. "Pick and choose what you need" is a valid argument of course, but for now I remain unconvinced. Try to imagine the state of your applications dependencies a few years from now. Or try to imagine adding a new green developer to your team and how hard it will be for him to become productive.

The one mantra that truly never failed me is to Keep It Simple Stupid.

Android and task killers: Don't

2010-03-27T23:04:00.029+01:00

There's an awful lot of misconceptions regarding Android and multitasking out there. When you read help forums and the issue of performance tweaking comes up, a very popular answer is to use a task killer to close unwanted apps. Even venerable tech people like TWiT's Leo Laporte appears to have acquired this habit. I reckon that these people have no idea how Android actually works and/or are making erroneous assumptions pulled over from the world of traditional desktop computing. In the best case, nothing happens when you kill an application except you spend time manually doing something that would otherwise have been done for you automatically at a later time. Worst case, you crash an application or get up too late tomorrow because your alarm didn't go off.

How Android does things
At an architectural level, applications running on Android are actually not supposed to halt its process in the traditional sense as we are used to from most desktop operating systems. When you switch to another application on Android, or use the back button, the previous application actually remains in memory but is just no longer active (though it's background services may be). It's up to the application and its author to play nicely in this environment. The vast majority of applications have no trouble doing so.

Only very few applications are so performance demanding, that they introduce a distinct exit button. This can be seen i.e. in the GPS navigation software CoPilot which engages many services and sensors on the phone, and is assuming that even if you require the use of another application (i.e. get a call), the navigation software should keep guiding you on your way. However, this exit button might as well be called "stop navigation services" but that would probably just confuse.

Why Android does it this way
At the usability level, I suspect Google liked being able to combine Cancel, Back and Exit into one physical button. To most people, the difference comes down to some fairly narrow semantics. Apple of course gets around this simply by not allowing multitasking altogether, probably driven by the desire to only have one button! At a more technical level, realize that DRAM memory cells in computers and smart-phones costs just as much in power/battery to keep alive, regardless of whether these cells are used or not. So in the world of Android, applications which you've used are considered likely candidates for use again later and hence, stays dormant in RAM. The Android operating system will manage these and in the case of low memory, will suspend and free up RAM for other purposes. Think of it this way, it's cheaper/faster to keep the application idle in fast RAM and just move a memory pointer to it when you want to use it again, than it is to load the whole application from scratch again from slow flash.

So why do people use task killers?
Apart from wrong assumptions that things works as on a PC, I suspect using too many applications (or rather, too many busy background services) and perhaps witnessing a small lag when Android is freeing memory, will get people to hunt for ways to shut down applications. A smart-phone does not have the same abundance of resources, so one must be careful when specifying settings for various synchronization services. So instead of killing an application, say i.e. the popular News Room app, go into the preferences and disable or tweak the background update service instead.

Conclusion
On a modern Android smart-phone, I have yet to see a real need for a task killer apart from shutting down Android Marked when changing carrier with Marked Enabler, but that's not performance related. And the few times I do need that, it's sufficient to do this using the stock Android option you can find by exploring Settings -> Applications -> Manage Applications, pick application and click "Force stop".

On my Nexus One here, after a day of using a bunch of applications I now have 26 running processes in 338MB of RAM, but still 48MB free. In essence, all the applications I use are loaded in RAM and ready for me to use - just as Google intended.

UPDATE:
Dianne Hackborn, a Google software engineer on the Android team explains it in detail here.

Android cubicle figure

2010-01-04T05:06:00.006+01:00

So my girlfriend, who is very artistic, has been doing some special clay modeling lately. Since I'm the kind of guy who likes to have lots of geek cubicle stuff (even if I do not work in a cubicle), what better to ask for than an Android figure. And lo and behold, this time I got what I asked for... hope this is a good indicator for the new year.

Cute eh?

Fun with the iGala picture frame

2009-12-30T01:56:00.032+01:00

NOTE: This is an old article that I never got around to finishing. So it might or might not still be relevant. Turns out iGala is about to launch Android support for the frame, but until then, I suspect the following could still be of interest to some.

One of the most geeky of shopping sites must be thinkgeek.com. They have many wonderful and useless items to appeal to the geek inside of you, hell even my wife had a blast reading their catalog. Anyway, one of the items they sell (exclusively apparently) is the iGala digital picture frame, from Aequitas Technologies. Now I've come across countless of these, but the iGala is one of the few ones running an easy-to-access embedded Linux. In the following I will show what I mean and provide some documentation that I have collected.

Probing the frame from outside
It's an 8" LCD, capable of a 800x600 resolution and with a resistive touch membrane in front. Apart from that, not much info is given to the consumer - in spite of this frame being marked as "Linux inside". You can find the device on your local LAN, by doing an IP broadcast or using nmap. Here's how I found mine:

casper@workstation:~$ nmap -sP 192.168.0.1-254
Starting Nmap 5.00 ( http://nmap.org ) at 2009-12-30 02:06 CET
Host 192.168.0.1 is up (0.0018s latency).
Host 192.168.0.10 is up (0.086s latency).
Host 192.168.0.101 is up (0.00015s latency).
Host 192.168.0.105 is up (0.0025s latency).
Nmap done: 254 IP addresses (4 hosts up) scanned in 12.88 seconds

I happen to know that the 192.168.0.1 router, the 192.168.0.10 is a wifi web-cam, 192.168.0.101 is my own computer so that leaves only 192.168.0.105 as the frame. Once we located it on the LAN, let's probe it a bit with the nmap tool.

casper@workstation:~$ nmap 192.168.0.105 -p1-65535
Starting Nmap 5.00 ( http://nmap.org ) at 2009-12-30 02:11 CET
Interesting ports on 192.168.0.105:
Not shown: 65532 closed ports
PORT      STATE SERVICE
21/tcp    open  ftp
514/tcp   open  shell
65534/tcp open  unknown

Ok, it appears to be running an FTP server on port 21, an (unencrypted) telnet service at port 514 as well something unknown on port 65534. Let's check out the FTP server real quick.

casper@workstation:~$ telnet 192.168.0.105 21
Trying 192.168.0.105...
Connected to 192.168.0.105.
Escape character is '^]'.
220 localhost.localdomain FTP server (GNU inetutils 1.4.1) ready.
USER anonymous
530 User anonymous unknown.
USER igala
530 p
...

Ok so no anonymous account. We'd have to use exhaustive trial and error to get in here so let's move on to the next.

casper@workstation:~$ rsh -l igala 192.168.0.105 514
Login incorrect.
casper@workstation:~$ rsh -l root 192.168.0.105 514
514: not found
...

Not much better. Again, we'd have to start some brute-force attack against the device to get in. Off to the 3'rd one.

casper@workstation:~$ telnet 192.168.0.105 65534
Trying 192.168.0.105...
Connected to 192.168.0.105.
Escape character is '^]'.

BusyBox v1.4.1 (2008-12-29 10:57:28 CST) Built-in shell (msh)
Enter 'help' for a list of built-in commands.

root:/>

Whoa, bingo! Someone left a BusyBox telnet service listening on one of the very last possible ports.

Probing the frame from inside
Let's fire off some commands to see what we're dealing with here.

root:/> uname -a    
Linux blackfin 2.6.22.16-ADI-2008R1-svn #2477 Wed Dec 31 13:02:59 CST 2008 blackfin unknown

Interesting, Linux kernel 2.6.22.16 for the Blackfin processor.

root:/> cat /proc/cpuinfo
processor : 0
vendor_id : Analog Devices
cpu family : 0x27a5000
model name : ADSP-BF531 540(MHz CCLK) 108(MHz SCLK)
stepping : 5
cpu MHz  : 540.000/108.000
bogomips : 1073.15
Calibration : 536576000 loops
cache size : 16 KB(L1 icache) 16 KB(L1 dcache-wt) 0 KB(L2 cache)
dbank-A/B : cache/sram
icache setup : 4 Sub-banks/4 Ways, 32 Lines/Way
dcache setup : 1 Super-banks/4 Sub-banks/2 Ways, 64 Lines/Way
No Ways are locked
board name : ADDS-BF533-STAMP
board memory : 65536 kB (0x00000000 -> 0x04000000)
kernel memory : 63476 kB (0x00002000 -> 0x03dff000)

A fairly fast CPU - substantially faster than the 108MHz ARM inside my Samsung SPF-105V frame.

root:/> mount
rootfs on / type rootfs (rw)
proc on /proc type proc (rw)
ramfs on /var type ramfs (rw)
sysfs on /sys type sysfs (rw)
devpts on /dev/pts type devpts (rw)
usbfs on /proc/bus/usb type usbfs (rw)
debugfs on /sys/kernel/debug type debugfs (rw)
securityfs on /sys/kernel/security type securityfs (rw)
/dev/mtdblock1 on /mnt/flash type yaffs (rw)
/dev/mtdblock2 on /mnt/fdisk type yaffs (rw)

A good deal of various filesystems, of which /dev/mtdblock1 and /dev/mtdblock2 are probably the most interesting in regard to modding.

root:/> netstat
Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 192.168.0.105:50350     www.flickr.vip.mud:http TIME_WAIT   
tcp        0      0 192.168.0.105:50348     www.flickr.vip.mud:http TIME_WAIT   
tcp        0      0 192.168.0.105:50351     www.flickr.vip.mud:http TIME_WAIT   
tcp        0      0 192.168.0.105:50353     www.flickr.vip.mud:http TIME_WAIT   
tcp        0      0 192.168.0.105:50352     www.flickr.vip.mud:http TIME_WAIT   
tcp        0      0 192.168.0.105:50345     www.flickr.vip.mud:http TIME_WAIT   
tcp        0      0 192.168.0.105:50347     www.flickr.vip.mud:http TIME_WAIT   
tcp        0      0 192.168.0.105:50346     www.flickr.vip.mud:http TIME_WAIT   
tcp        0    164 192.168.0.105:telnet    192.168.0.101:57949     ESTABLISHED 
tcp        0      0 192.168.0.105:50349     www.flickr.vip.mud:http TIME_WAIT

A busy device indeed. For some reasons, the frame have multiple idle connections to flickr.

root:/> dmesg
Hardware Trace:
0 Target : <0x000059f4> { _trap_c + 0x0 }
Source : <0xffa0860c> { _exception_to_level5 + 0xb4 }
1 Target : <0xffa08558> { _exception_to_level5 + 0x0 }
Source : <0xffa084b0> { _ex_trap_c + 0x5c }
2 Target : <0xffa08454> { _ex_trap_c + 0x0 }
Source : <0xffa086ac> { _trap + 0x28 }
3 Target : <0xffa08684> { _trap + 0x0 }
Source : <0x0061ef62> [ /lib/libuClibc-0.9.29.so + 0x1ef62 ]
4 Target : <0x0061ef46> [ /lib/libuClibc-0.9.29.so + 0x1ef46 ]
Source : <0x0061ef3e> [ /lib/libuClibc-0.9.29.so + 0x1ef3e ]
5 Target : <0x0061ef30> [ /lib/libuClibc-0.9.29.so + 0x1ef30 ]
Source : <0x036257f8> [ /mnt/flash/abies/lua + 0x257f8 ]
6 Target : <0x036257f0> [ /mnt/flash/abies/lua + 0x257f0 ]
Source : <0x0362f49e> [ /mnt/flash/abies/lua + 0x2f49e ]
7 Target : <0x0362f488> [ /mnt/flash/abies/lua + 0x2f488 ]
Source : <0x0366a3a8> [ /mnt/flash/abies/lua + 0x6a3a8 ]
8 Target : <0x0366a39c> [ /mnt/flash/abies/lua + 0x6a39c ]
Source : <0x0362f484> [ /mnt/flash/abies/lua + 0x2f484 ]
9 Target : <0x0362f45c> [ /mnt/flash/abies/lua + 0x2f45c ]
Source : <0x0362f456> [ /mnt/flash/abies/lua + 0x2f456 ]
10 Target : <0x0362f450> [ /mnt/flash/abies/lua + 0x2f450 ]
Source : <0x0362f444> [ /mnt/flash/abies/lua + 0x2f444 ]
11 Target : <0x0362f42e> [ /mnt/flash/abies/lua + 0x2f42e ]
Source : <0x0362f420> [ /mnt/flash/abies/lua + 0x2f420 ]
12 Target : <0x0362f3a4> [ /mnt/flash/abies/lua + 0x2f3a4 ]
Source : <0x0362f39a> [ /mnt/flash/abies/lua + 0x2f39a ]
13 Target : <0x0362f394> [ /mnt/flash/abies/lua + 0x2f394 ]
Source : <0x0362f382> [ /mnt/flash/abies/lua + 0x2f382 ]
14 Target : <0x0362f32e> [ /mnt/flash/abies/lua + 0x2f32e ]
Source : <0x0362f2e4> [ /mnt/flash/abies/lua + 0x2f2e4 ]
15 Target : <0x0362f2d4> [ /mnt/flash/abies/lua + 0x2f2d4 ]
Source : <0x0366a3fa> [ /mnt/flash/abies/lua + 0x6a3fa ]

Looks like we have the omnipresent libC library servicing Lua code located in /mnt/flash/abies/

root:/> top
Print certain system information.  With no OPTION, same as -s.
Mem: 45392K used, 15304K free, 0K shrd, 0K buff, 5600K cached
Load average: 2.69 2.42 2.22
PID USER     STATUS   VSZ  PPID %CPU %MEM COMMAND
438 root     R      27536     1 71.7 45.0 lua
21151 root     R        844 13454  7.2  1.3 top
495 root     S      27536   460  3.2 45.0 lua
343 root     S       2806     1  0.8  4.5 nano-X
13453 root     S        508   276  0.8  0.8 telnetd
349 root     SW         0     2  0.8  0.0 rt73
460 root     S      27536   438  0.0 45.0 lua
359 root     S        836     1  0.0  1.3 syslogd
360 root     S        836     1  0.0  1.3 klogd
194 root     S <      800     1  0.0  1.3 udevd
1 root     S        568     0  0.0  0.9 init
547 root     S        516     1  0.0  0.8 dhcpcd
277 root     S        484     1  0.0  0.7 udisk_mount

Some Lua processes, a nano-X server, a few telnet deamons, a DHCP client deamon and a udisk mount service.So anyway, since today is not the day for me to learn Lua, I will proceed playing with just shell scripting. Let's mod the frame to download some custom telemetry data or public weather satellite picture once a minute.

rm /mnt/flash/abies/default/*.*
cp /mnt/flash/wait.png /mnt/flash/abies/default/chart.png
sleep 30
while [ 1 ]
do
rm /mnt/flash/abies/default/chart.png
wget -O /mnt/flash/abies/default/chart.png http://www.ntua.gr/weather/sat.jpg
sleep 60
done

The above script takes advantage of the fact that the frame by default cycles between 4 preinstalled images located under /mnt/flash/abies/default/. So first it clears this picture index, then it copies a waiting image into the picture area, which makes the frame show a nice image while we wait for the actual live data. Then we loop indefinitely, and in this loop the old image is deleted, a new image is downloaded and then we sleep for 60 seconds.

The above image shows live telemetric data from my house, in the form of temperature, humidity etc. as 24h charts. In principle there's no limit to what you can render on the frame, as long as you are capable of producing 800x600 image representations.

Turns out, it's even possible to use the official update mechanism and create an update package which does this modding on a frame just by inserting a USB stick with the software on - just be aware of updates being pulled down from iGala's website which may conflict (you can block this of course, but then you might as well simple write your own Lua hosting application).

Android debug bridge on ubuntu 9.10

2009-12-23T02:42:00.023+01:00

It turns out the latest Ubuntu release makes it a bit more difficult to connect the multi purpose Android debug bridge to your Android device. The following is really just an update of my older entry, to remind myself of the changes in Ubuntu 9.10. This stuff is pieced together from various other sources online (mostly android-discuss) and thus not particularly original.

Ok so first of all, there are quite a few more vendors and devices now (yay). In order to identify your device, make sure your device is not connected and then execute the Linux command lsusb.


casper@workstation:~$ lsusb
Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 005 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 001 Device 004: ID 07cc:0501 Carry Computer Eng., Co., Ltd Mass Storage
Bus 001 Device 002: ID 0409:005a NEC Corp. HighSpeed Hub
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 003 Device 002: ID 051d:0002 American Power Conversion Uninterruptible Power Supply
Bus 003 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 004 Device 002: ID 046d:c51a Logitech, Inc. MX Revolution/G7 Cordless Mouse
Bus 004 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub

Now connect the device and make sure USB debugging is enabled, and run the command again. You should have one more line:


casper@workstation:~$ lsusb
Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 005 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 001 Device 016: ID 0bb4:0c02 High Tech Computer Corp.
Bus 001 Device 004: ID 07cc:0501 Carry Computer Eng., Co., Ltd Mass Storage
Bus 001 Device 002: ID 0409:005a NEC Corp. HighSpeed Hub
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 003 Device 002: ID 051d:0002 American Power Conversion Uninterruptible Power Supply
Bus 003 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 004 Device 002: ID 046d:c51a Logitech, Inc. MX Revolution/G7 Cordless Mouse
Bus 004 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub

So now we learned that HTC stands for High Tech Computer. :) We then need to install the rule for the device, by creating a file under /etc/udev/


gksudo gedit /etc/udev/rules.d/51.android.rules

Enter the following, but adjust vendor id and product ID according to what you just found out in the previous step. The device entry below will likely only work if you also happen to have an HTC Magic/Saphire A6161/Nordic (32a).


SUBSYSTEM=="usb", ATTRS{idVendor}=="0bb4", ATTRS{idProduct}=="0c01", MODE="0666"

Make sure everyone can access and execute it:


sudo chmod a+rx /etc/udev/rules.d/51.android.rules

Now reload the udev service:


sudo service udev reload

Now you are ready to start the adb service. Note that due to a change/bug in the security policies of Ubuntu 9.10, you won't have access to the device unless you execute adb (or rather, the adb service) as a super user. This is mildly annoying:


casper@workstation:~/development/android-sdk-linux/tools$ adb devices
* daemon not running. starting it now *
* daemon started successfully *
List of devices attached 
???????????? no permissions

Instead what you will have to do is start the server manually in super user mode (make sure to kill any existing server first, with sudo adb kill-server):


casper@workstation:~/development/android-sdk-linux/tools$ sudo ./adb start-server
* daemon not running. starting it now *
* daemon started successfully *

And now you may use adb as per usual:


casper@workstation:~/development/android-sdk-linux/tools$ adb devices 
List of devices attached 
HT95PKF00221 device

Not really groundbreaking stuff, but I thought it might be useful and save time for others running Ubuntu 9.10 and wanting to get ADB up and running.

Update
The Nexus One, Google's latest Android beast, appears to be identified as 18d1:4e11 but without any vendor string. Interesting since the Nexus One is also hardware produced by HTC. However using adb, it will list with serialid: HT9CRP805273 so HTC is not entirely hidden. It appears that internally the phone is referenced as the Passion and/or Mahimahi.

Tweaking javac leniency

2009-08-20T04:32:00.070+02:00

While a great fan of type-safety and static checking, I also like a certain amount of leniency from compilers. Sun's Java compiler is a good example of one that goes overboard in some anal, misunderstood attempt at servicing the developer.
In the following I will explain why I think so and how to fix it by modifying the publicly available source code for the compiler. Note that although I have done something similar before, I am no compiler expert and never will be. The modifications shown in this post are mere tweaks and I will stay far away from anything below semantic analysis.

"Exception is never thrown"

Have you ever had a good coding session, with design, implementation and refactoring happening at an immense speed as you try to perfect the internals of a piece of code? All of a sudden you are distracted because a try block no longer contains any methods that declares a checked exception. So now, in order to satisfy the compiler, you'll have to focus on removing these alternate, albeit dead and harmless paths. Indeed, you will have to carefully uncomment everything but the body of the try block.

As a concrete but contrived example, imagine something like this:



    Settings settings = null;

    try {
        settings = Settings.loadFile("settings.conf");
        settingsObservers.fireChangeEvent();
    } catch (IOException ex) {
        // Logging...
    }
    finally{
        // Cleanup...
    }

Now then imagine you need to test something real quick, and thus prefers to just new up the Settings() object or something similar, so you comment out the line where it loads from a file:



    Settings settings = new Settings();

    try {
        // settings = Settings.loadFile("settings.conf");
        settingsObservers.fireChangeEvent();
    } catch (IOException ex) {
        // Logging...
    }
    finally{
        // Cleanup...
    }

That won't work of course, because of the paranoid rules surrounding checked exceptions. Instead, we'll see the compiler complain:


casper@workstation:~$ javac ExceptionNeverThrown.java 
ExceptionNeverThrown.java:13: exception java.io.IOException is never thrown in body of corresponding try statement
    } catch (IOException ex) {
1 error

So in order to have it run, you meticulously comment out everything related to the try-catch-finally block:



    Settings settings = new Settings();

    //try {
        // settings = Settings.loadFile("settings.conf");
        settingsObservers.fireChangeEvent();
    //} catch (IOException ex) {
    //    // Logging...
    //}
    //finally{
    //    // Cleanup...
    //}

That's just stupid and gets even worse if you have any kind of propagating hierarchy in place! Static checking should be an assistance rather than an annoyance, this is clearly a case of the static dial being placed a tad too high.

Catching checked exceptions without a throw

We can fix this by getting our hands on the OpenJDK source, in my case I opted for the easy-to-use Kijaro sandbox, which Stephen Colebourne set up to encurrage this kind of hacking. Kijaro includes instructions on how to build javac for both Windows and Linux. If you want to try this kind of hacking yourself, you are going to need a checkout of this sandbox or a similar OpenJDK branch. Alternatively, if all you want to do is play with the tweaks I'll demonstrate here, you may just get a copy of my modified javac.

The semantic analysis parts of OpenJDK is largely contained in the package com.sun.tools.javac.comp, for our purpose we're going to need Flow.java hosting a bunch of data-flow analysis methods that's responsible for raising error conditions surrounding the use of checked exceptions. The compiler walks the AST of the source code through a double-dispatch mechanism (visitor pattern) that calls methods in Flow.java with the current AST node as argument. This means all we have to do is locate the proper callback and modify it according to our need. Down around line 951 you should see the following:



    public void visitTry(JCTry tree) {
            ...

            if (chk.subset(exc, caughtInTry)) {
                log.error(l.head.pos(),
                          "except.already.caught", exc);
            } else if (!chk.isUnchecked(l.head.pos(), exc) &&
                       exc.tsym != syms.throwableType.tsym &&
                       exc.tsym != syms.exceptionType.tsym &&
                       !chk.intersects(exc, thrownInTry)) {
                log.error(l.head.pos(),
                          "except.never.thrown.in.try", exc);
            }

            ...
    }

Evidently, here's some logic that looks like it's logging an error if a checked exception is not being thrown (catch-list does not intersect with thrown-in-try-list). Let's change the line from logging an error, to logging a warning:




    log.warning(l.head.pos(), "except.never.thrown.in.try", exc);

That's actually all that's needed in the compiler itself. However, note the obvious reference to a resource key "except.never.thrown.in.try". This is part of a reference to an entry in the file com.sun.tools.javac.resources.compiler.properties. If you open this you'll notice the following line:



compiler.err.except.never.thrown.in.try=\
    exception {0} is never thrown in body of corresponding try statement

The key does not match the one from the log statement completely, as it is prepended with "compiler.err.". Since we changed the logging from an error to being a warning, javac will search in vain for an entry with the key "compiler.warn.except.never.thrown.in.try". As we can not simply fix this by changing the key reference in Flow.java, we are going to modify the existing, or add a new entry to compiler.properties:



compiler.warn.except.never.thrown.in.try=\
    exception {0} is never thrown in body of corresponding try statement

Now compile Kijaro/OpenJDK and watch what happens when you use your new javac build to compile our previous Settings sample:


casper@workstation:~$ tweakedjavac ExceptionNeverThrown.java 
casper@workstation:~$

We have successfully modified the compiler to make our life a little easier. There are a bunch of similar tweaks one could make, all in the same easy fashion as explained above. For instance, I have converted checked exceptions from being an error to being a warning (hint: errorUncaught on line 298), which means they don't get in the way of rapid development while at the same time not really losing any of the benefits - production code should compile without warnings anyway.
Likewise, I have made it so that the unreachable statement error is now also just a warning (hint: scanStat on line 493), thus allowing me to short-circuit a method or similar with a return statement without having me temporarily comment out the remaining code. To demonstrate all of this in one go, take a look at the following sample code:



import java.io.IOException;

public class TweakedJavaCTest{
    public static void main(String... args){
        // Test of "checked exception not caught" (throws InterruptedException)
        Thread.sleep(100);
        System.out.println("After sleep...");

        // Test of "checked exception not thrown"
        try{
            System.out.println("Inside try...");
        }catch(IOException e){
        }

        // Test of "unreachable statement"
        return;
        System.out.println("This will never be executed!");
    }
}

With a stock javac, you won't get very far:


casper@workstation:~$ javac TweakedJavaCTest.java 
TweakedJavaCTest.java:12: exception java.io.IOException is never thrown in body of corresponding try statement
        }catch(IOException e){
         ^
TweakedJavaCTest.java:17: unreachable statement
        System.out.println("This will never be executed!");
        ^
TweakedJavaCTest.java:6: unreported exception java.lang.InterruptedException; must be caught or declared to be thrown
        Thread.sleep(100);
                    ^
3 errors

In fact, we have no artifact to run. With the tweaked compiler it's an entirely different matter however:


casper@workstation:~$ tweakedjavac TweakedJavaCTest.java
TweakedJavaCTest.java:12: warning: exception java.io.IOException is never thrown in body of corresponding try statement
        }catch(IOException e){
         ^
TweakedJavaCTest.java:17: warning: unreachable statement
        System.out.println("This will never be executed!");
        ^
TweakedJavaCTest.java:6: warning: unreported exception java.lang.InterruptedException; must be caught or declared to be thrown
        Thread.sleep(100);
                    ^
3 warnings

Since we've reduced the previous errors to now being just warnings, we'll get an actual build which we can run:


casper@workstation:~$ java TweakedJavaCTest
After sleep...
Inside try...
casper@workstation:~$

Voila, pretty easy eh? If you want to play with this javac build you can grab it here. To compile a Java source file with this javac build, you need to use it this way:


casper@workstation:~$ java -Xbootclasspath/p:tweakedjavac.jar -ea:com.sun.tools -jar tweakedjavac.jar TweakedJavaCTest.java

In conclusion

I'm actually surprised at how easy it was to make these small tweaks. While some people clap their hand at checked exceptions, I think this more lenient version is how the Java compiler should have behaved from day one. The obvious drawback is that you are required to build and distribute your own javac which won't sit very well in many organizations, even if you could still use it as a less-hassle development tool for yourself. The other issue is that of IDE support, although it should be relatively easy* to plug this javac into NetBeans, other IDE's rely entirely on their own parser.

It would be nice if tweaks like these would be considered for the official JDK7, since it doesn't actually break backwards compatibility. However, Sun is an extremely conservative company and has not shown interest in fixing or evolving the compiler over the last couple of years.
Perhaps the way forward is an alternative approach, which does much the same, but without requiring a modified compiler. Reinier Zwitserloot from the Lombok project is dabbling on such an approach which you might want to check out.

* I did give it a quick try, packing up a tools.jar and placed in the JAVA_HOME/lib folder and making sure NetBeans were using this platform for my project. However it did not work as expected. While I was able to build inside NetBeans, the syntax highlighting did not pick up on my modifications.

Update

I have since added this to Kijaro under the branch leniency (you'll need a java.net login).

Android book roundup

2009-08-06T06:24:00.048+02:00

While it may no longer be so much for reference purposes as in the past, I still really like to have good books at my disposal as a software developer. The DPI of a book still beats that of any screen and I can bring a book to the restroom without raising eyebrows from my girlfriend. In the following I will come with a brief but hopefully useful review of the 3 Android books I have in my library.

O'Reilly's Android Application Development

The book covers Android 1.1 stuff and is thus already a little dated. The content and organization is a odd and lackluster I find, for instance there's a chapter on signing and publishing your application which comes before chapters on basic views and widgets. It also doesn't come with an ebook/PDF so there's really not a whole lot going for this book, you are probably better of looking elsewhere.

Manning's Unlocking Android

Also covers 1.1 stuff, but better content and definitely better organized than the O'Reilly book. It comes with ebook/PDF as well as source code. It does make certain assumptions regarding the skills of the reader (for instance how the Eclipse IDE works, as examples are Ant based and needs to be imported) but I reckon that most readers would be quite satisfied with this book. It has foreword by none other than Java Posse's chief editor Dick Wall.

Commonware's The Busy Coder's Guide to Android Development

This is the most recent published book in this mini roundup. I only have the ebook/PDF version so I am not 100% sure whether the dead tree version covers 1.5/Cupcake as well. You actually get 3 books, incl. one on advanced topics such as reading sensory and camera data. It works by 1 year subscription basis and without DRM, so you are likely to also get 1.6 and 2.0 coverage by simply downloading the books at a later point in time when they have been revised. The material itself feels very to-the-point, yet it's actually the only book I have come across that provides a thorough introduction to lists - an essential part of any Android application.

In conclusion

It's my humble opinion that all the above books favors XML layout a bit too much, as it makes examples harder to read/type - and lets face it, it's limited how complex a layout will be on such a small screen anyway. This appears to be more or less dictated by the architecture of Android so not much to do about that. If you have developed in JSF vs. Wicket/GWT then you know what I'm talking about. :)

If you only want one book on the subject, "The busy coders guide to Android Development" would be the one to go for. The content, organization and presentation is just unmatched by any of the others, though "Unlocking Android" was by no means a bad book. However, "Android Application Development" was a disappointment.

Update
Since writing this initial entry, Romain Guy from the Android team have informed me on this thread, that XML is favored in order to have multiple resources set up declaratively such that Android can automatically select the best match depending on hardware and environment. That makes a lot of sense of course, even if I still think this is an aspect better introduced to the reader after having tried some basic UI building with Java in order to even out the initial learning curve. After all, Java provides beginners with familiarity, type-safety and code completion. Although I've talked to other developers who share this opinion (slides from a Danish JUG meeting), yours may of course vary.

DDMS on Ubuntu 64bit

2009-07-10T20:05:00.007+02:00

The Android SDK comes with a pretty nice suite of tools, one of these is the Dalvik Debug Monitor Service (DDMS). However, it seems like the Android SDK is distributed with some 32bit SWT libraries so if you are on a 64bit Linux, running a 64bit Java default, you might run into this little message:


casper@workstation:/$ dbms
43:27 E/ddms: shutting down due to uncaught exception
43:27 E/ddms: java.lang.UnsatisfiedLinkError: /android-sdk-linux_x86-1.5_r2/tools/lib/libswt-pi-gtk-3236.so: /android-sdk-linux_x86-1.5_r2/tools/lib/libswt-pi-gtk-3236.so: wrong ELF class: ELFCLASS32 (Possible cause: architecture word width mismatch)
at java.lang.ClassLoader$NativeLibrary.load(Native Method)
at java.lang.ClassLoader.loadLibrary0(ClassLoader.java:1778)
at java.lang.ClassLoader.loadLibrary(ClassLoader.java:1687)
at java.lang.Runtime.loadLibrary0(Runtime.java:823)
at java.lang.System.loadLibrary(System.java:1030)
at org.eclipse.swt.internal.Library.loadLibrary(Library.java:123)
      ...

This is fairly easy to fix, by first installing the 32bit version of the JRE:


casper@workstation:/$ sudo apt-get install ia32-sun-java6-bin

And then making sure DDMS is using this particular one. There are countless ways to do this (add new environment variables etc.) but I chose to simply modify DDMS itself, which seems like the least invasive way for this purpose. If you go to line 71, it should currently read:


java_cmd="java"

It's obviously relying on the /usr/bin/java symlink which we have in path, which leads to /etc/alternatives/java which again leads to our default 64bit version of the JRE. So change the line to this instead:


java_cmd="/usr/lib/jvm/ia32-java-6-sun/jre/bin/java"

Now DDMS should run so you can monitor, debug and take screenshots of your virtual or physical device.

Firefox 3.5 on Ubuntu 9.04

2009-06-30T22:43:00.000+02:00

Well today the much anticipated speedy Firefox 3.5 arrived. Ubuntu probably won't push this one out as an update and I am not sure when Firefox's own auto-update would provide this upgrade, so if you're impatient as I, this is how to install it manually. Do read the whole thing through before deciding whether to do this, as there are some potential plugin issues involved!

Installation procedure
First you need to download and extract in an appropriate place. I'm extracting to /opt/firefox-3.5 such as to avoid collisions later when an official Ubuntu version is available:


casper@workstation/$ cd /opt/
casper@workstation/opt/$ sudo wget http://releases.mozilla.org/pub/mozilla.org/firefox/releases/3.5/linux-i686/en-US/firefox-3.5.tar.bz2
casper@workstation/opt/$ sudo tar -xjf firefox-3.5.tar.bz2
casper@workstation/opt/$ sudo mv firefox firefox-3.5
casper@workstation/opt/$ sudo rm firefox-3.5.tar.bz2 -f

Perhaps you notice that the download is a i686/32bit Linux release, this is because Mozilla do not presently build amd64/64bit versions. For this, we will have to wait for a version from our distribution. Now, lets check Ubuntu's browser settings:


casper@workstation:/opt$ sudo update-alternatives --display x-www-browser 
x-www-browser - status is auto.
 link currently points to /usr/bin/firefox-3.0
/usr/bin/firefox-3.0 - priority 40
Current `best' version is /usr/bin/firefox-3.0.

As you can see on my machine, only Firefox 3.0 is installed. We can add the newly downloaded version as an alternative and give it precedence on the system by issuing:


casper@workstation/opt/$ sudo update-alternatives --install /usr/bin/firefox-3.5 x-www-browser /opt/firefox-3.5/firefox 50

Also, we can make it default:


casper@workstation/opt/$ sudo update-alternatives --set x-www-browser /opt/firefox-3.5/firefox
Using '/opt/firefox-3.5/firefox' to provide 'x-www-browser'.

However, it's still not default on the path. To make it so, Ubuntu needs to update its symlink from /usr/bin/firefox to /opt/firefox-3.5/firefox:


casper@workstation/opt/$ sudo rm /usr/bin/firefox
casper@workstation/opt/$ sudo ln -s /opt/firefox-3.5/firefox /usr/bin/firefox

Voila. Issuing "firefox" on the command-line should now start Firefox 3.5 just as Ubuntu's shortcuts should now also point to the new version. On initial launch, Firefox 3.5 will check your extensions and plugins, as well as use your existing bookmarks etc. from your users home as usual on Linux.

Caveats
Note that if you previously had the amd64/64bit version of Firefox and plugins, your plugins will no longer work! It is of course very easy to just use 32bit plugins instead. In my case, I just lifted the two plugins I am interested in (libflashplayer.so and libjavaplugin.so) from another 32bit installation, but you can simply use Synaptic package manager to install 32bit plugins if you do not have these already.

If you don't wish to have multiple versions and perhaps have already uninstalled the old 64bit 3.0 version, then you may simply place the files in ~/.mozilla/plugins/. However, if you wish to have both versions on your system, you should keep the 64bit stuff around and instead add the 32bit plugins locally to your 32bit Firefox 3.5 installation in /opt/firefox-3.5/plugins/.

It's annoying to be back to 32bit for the time being but I do love the speed of this new version, and I'm sure you will too.

Update: Turns out there's an easier way, explained in this blog entry: http://talkingincircles.net/2009/07/01/firefox-3-5-in-ubuntu-9-04-64-bit/

Android Debug Bridge on Ubuntu 9.04

2009-06-30T02:51:00.000+02:00

To perform general debugging and install alternative ROM's on the HTC Magic in Ubuntu 9.04, you will need a little more footwork than the documentation mentions.

First, I assume you have installed the SDK and added it to path so that you can perform ADB commands from everywhere. Then, you need to have USB debugging enabled on the phone, do this by going under Settings > Applications > Development and check the "USB Debugging" item.

Now, add a udev rule for your device:


gksudo gedit /etc/udev/rules.d/51.android.rules

Add the following to the file and save it:



SUBSYSTEM=="usb", ATTRS{idVendor}=="0bb4", MODE="0666"

Reload USB devices by issuing the command:


sudo /etc/init.d/udev reload

Unplug and plug the device. Check if you can see the device:


casper@workstation:~$ adb devices
* daemon not running. starting it now *
* daemon started successfully *
List of devices attached 
HT95PKF00221 device

There, now you can browse your phone with the adb shell command and start diving into the rather interesting world of rooting and alternative ROM's found over on XDA-developers. My next move is to try the HTC Hero ROM on my Magic, which will give the phone the new multitouch Rosie/Sense interface.

Another cool thing is that if you start your Eclipse SDK and try to run an application, it will now deploy to the physical device rather than the emulator - pretty neat!

HTC Magic Android emulator skin

2009-06-20T05:39:00.000+02:00

So I started playing with Android development, just received "Unlocking Android" and "Android Application Development" from Amazon. However before getting to do any real development, I got sidetracked in trying to create a skin for the Android Emulator that matches my new fancy HTC Magic. There actually exists one, but it's branded Vodafone, looks silvery and has the buttons all wrong so I decided this would be a good way to brush up on some Gimp skills. And here it is, I am no graphics artist so I am moderately pleased.

You may use images and skin as you please, under the creative commons license. You can download the skin by clicking here. To install, simply extract the files to {android_install_dir}/platforms/android-1.5/skins/HTCMagic/.

If you can not select the skin in Eclipse, you may have to edit the config.ini file of your virtual android device setting manually (under ~/.android/avd/), simply set the skin.path property to point to HTCMagic. You can also run the emulator manually by executing {android_install_dir}/tools/emulator and pass along the command line argument "-skin HTCMagic".

NOTE: I am aware that pressing the search button in the emulator has no effect. This appears to be because it is not implemented for the emulator at this time, since no other skin appears to have a working search button. I even read through the C and Python source code to see if I could find the proper key name, but with no success. Also note, the screen shown within the emulator in the above image, is not of the generic Android 1.5 (Cupcake) but rather a static image of HTC's Rosie/Sense UI which I find more sexy (can phone software look sexy?).

Android awesomeness

2009-06-10T00:11:00.000+02:00

So I finally got an Android device, in the form of the second generation hardware from HTC known as the Magic, G2, Ion and Saphire. Since the original HTC Dream (G1) this phone received a major visual overhaul and now boosts a soft keyboard rather than a physical one making it a loss less clunky. And let me admit right away, I fell in love at once and have hardly put it down since. It is not my intention here to write any kind of throughough or balanced review, but merely to showcase Android and the applications to others contemplating getting one of these phones as well.

Initial impression
The phone looks and feels sturdy and quality, thankfully not branded like appears to be the case in the US. The 3.2" touch screen is glass just like the iPhone and the body is thick scratch-proof plastic. It has what amounts to 11 buttons (incl. a joypad) below the screen such as well as volume buttons on the side.
Having played with an iPhone a few times, my impression is that the Magic is very reminiscent of this groundbreaking device. I never actually invested in an iPhone as I don't care very much for the handcuffs Apple like to put on its customers - it's a somewhat different story with this phone. Also, to me the Magic feels better in the hand than an iPhone and definately slips easier down into a pocket. The battery is a 1340mAh Litium-Ion, bigger than the one in the G1 and enough to keep the phone powered for the day. It's important to note that it takes a few days for the battery to start charging correctly (to know its state) and it also takes a few days to learn how to use it such as not to drain the battery immediately but this is true of any smartphone.

Android
While the hardware is nice, the real kicker is Google's Android operating system. The HTC Magic comes with version 1.5 (Cupcake) as well as some extra software installed into the ROM by my phone carrier that enables Microsoft Exchange integration etc.
Android can have applications installed from either the Android marked or by directly downloading the .apk file. There's already around 5.000 applications available, and with so many phones coming out and a rapidly growing community I see no reason why Android would stay shy of iPhone's 50.000 applications.

You can opt to lock the device by a custom gesture. This is a very handy feature that beats the traditional approach of having to enter a code.

The home screen with widgets and shortcuts on the desktop, live picture of the Eiffel tower as wallpaper.

On the left home screen I have primarily system tools.

On the right home screen I have frequently used applications.

The applications menu pops up when you drag the slider up. The screenshot does not convey this information, but I have around 75 application installed.

Long-pressing the home button reveals other recently run applications, unlike the iPhone this device has no trouble multitasking.

At the top of the screen, the status panel can be expanded as well. It's here notifications of any kind goes (email, SMS, instant message) and it works remarkable well.

In horizontal mode, the soft keyboard is a joy to use thanks to the dictionary suggestions.

In vertical mode, you really need to be precise and having small fingers is definitely a plus.

Google applications

The build in browser, based on KHTML like Safari and Crome. It does its job to perfection, best mobile browser experience I have tried.

The gmail integration is equally impressive. Simple and functional.

Of course, Google maps is there as well and works with the GPS.

It feels special to be out and about, with satellite pictures looking down at your position.

Even street view is integrated.

Skymap uses all the sensors of the phone to render an accurate representation of the sky complete with stars, planets etc. depending at where you point the phone.

It plays mp4 in very decent quality, here Romain Guy from the Android team.

YouTube is available via an integrated application that simply works.

The camera used as a barcode scanner, here a book is scanned.

Voila, we have looked up a book and can read reviews and find cheapest stores.

The Android marked is full of stuff, approximately 5.000 apps. but growing daily.

aTrackDog can track all installed applications and tell you when there are new versions and provide an easy way to update.

GPSstats is good to determine GPS coverage.

CellTower can be used to triangulate and display cell towers around your neighbourhood. Not really useful, but fun to see in action.

FlightStats was great on a recent trip, always providing me with up-to-date info about delays.

There are of course countless games, though they are less interesting to me personally.

No matter the IM protocol you rely on, you are sure to be connected.

Yes believe it or not, there's even a metal detector.

NetCounter is invaluable in monitoring data traffic. It may save you from receiving a nasty bill.

SpareParts provides great system info as well as tweaks.

Speedtest is good to debug and determine connection speeds.

TaskManager lets you monitor and kill applications.

MyTracks tracks you as you move around. Here is my walking route from the office to the local subway.

Some metrics from the walk.

Not quite detailed enough to show me mowing the lawn. lol

The beauty of an open platform. You can run Mono/C# stuff on it.

...as well as Python, BeanShell and Lua.

...and execute shell commands since it's a real Linux underneath.

Conclusion
There are only a few thorns on this white rose. It would be nice if HTC would use a standard 2.5mm mini jack instead of the propriatary mini-USB plug although this is easily fixed with a small adaptor. Also, the speakers are not the loudest I've heard from a phone so I would've preferred if they faced the same direction as the screen such as to improve the video experience.

As for Android and the software it's even harder to find flaws. The menu where you see each and every application is perhaps a bit overwhelming, although you quickly get used to it (sorted alphabetically). To remedy this, people sometimes install home application extensions such as to allow more than 3 screens. This is something Google can easily adjust through the Android updates coming.

The real beauty of this device is how open it is. For instance, Android itself has not been ported to other languages than english yet, but that has not stopped people from developing localized soft keyboards that matches a particular locale (in my case Danish). Even if the phone is 200-300$ cheaper than an iPhone, it has more potential and longevity that I think only Apple fanboys will miss the slightly better polish put on by Apple. I'm already looking forward to the next upgrade to Donut in a few months, as well as Eclair by the end of the year and I'm eager to start developing on it myself.

Maven: Compile to a RAM-drive

2009-05-25T19:49:00.000+02:00

While preparing to do a backup recently, I realized that I had over 2GB in 110.000 files which was the result of either an Ant build or Maven target. It occured to me that with Maven especially, this is nothing more than garbage to keep around, since Maven will copy the artefacts to its /.m2 folder anyway!

In a previous blog entry, I explained how to mount a RAM-drive on Ubuntu and use it as a development folder for much higher performance in the compile-test-run cycle. I have to admit, I don't use this for each and every project since it's a little complex and fragile.

But there's an interesting compromise to be had here. It turns out it is possible to instruct Maven to build artefacts to a RAM-drive. That way you not only gain some performance but also some automatic "garbage collection" in that by the next boot, you will have no traces of these build steps laying around. It would also be a very healthy thing to do if you're running from of an SSD drive, which are susceptible to wear-and-tear. The following will explain how to set this up with Maven.

Prerequisites
You are going to need a RAM-drive for this purpose. It is extremely easy to set one up on Ubuntu. In the following I set the permissions of the mount to that of the Ubuntu user "plugdev" which is the one being used for auto-mounting USB-drives etc. That way all users should have permission to use it:


sudo mkdir /media/ramdrive
sudo chgrp plugdev /media/ramdrive
sudo chmod g+w /media/ramdrive
sudo chmod +t /media/ramdrive
sudo mount tmpfs /media/ramdrive -t tmpfs

You can have your system automatically create and mount a TMPFS partition for you, by modifying your /etc/fstab file. Simply add the following to it:


none /media/ramdrive tmpfs defaults,user,size=1G,mode=0777 0 0

An alternative approach could be to have the RAM-drive mounted at compile time. This is perfectly possible by calling out to an Ant target in Maven, and have it execute a Bash script. The problem is though, in order to mount filsystems on Linux you need to be a super user. So for this approach to work, you would need to hardwire your SUDO password in the script and that would be pretty dumb. It is entirely possible there is a way to do it, but if there is I am unaware of it.

The POM modification
Basically all we need to do is instruct Maven where out build directory is, our output directory and our test directory. This can be done by simply specifying it within the build tag:



<project>
    <build>
        <directory>/media/ramdrive/maven-targets/${project.name}</directory>
        <outputDirectory>/media/ramdrive/maven-targets/${project.name}/classes</outputDirectory>
        <testOutputDirectory>/media/ramdrive/maven-targets/${project.name}/test-classes</testOutputDirectory>
        ...
    </build>
    ...
</project>

You'll notice I place everything under the sub-folder "maven-targets", this is so that none of my targets conflicts with other stuff on my RAM-drive. Also, the actual sub-folder for each individual project will be named the same as the project.

As Maven profile
While the above certainly works, it's arguably some heavy bending of Maven's conventions and we run the risk that other people not as fortunate as us (i.e. Windows users) won't have a RAM-drive nor the possibility to create one. To remedy this, we can encapsulate this custom behaviour in a Maven profile.

Sadly in a profile, we are not allowed to specify build paths like we just saw above. We can however cheat a bit, by going through some properties. Start by defining some global properties somewhere in a properties tag under the project tag:



<project>
    <properties>
        <build.dir>target</build.dir>
        <build.outputDir>target/classes</build.outputDir>
        <build.testOutputDir>target/test-classes</build.testOutputDir>
        ...
    </properties>
    ...
</project>

This complies with the standard Maven conventions. Then in the non-profile build tag, do like before but rather than hardwire the paths, use the properties we just defined. Like so:



<project>
    <build>
        <directory>${build.dir}</directory>
        <outputDirectory>${build.outputDir}</outputDirectory>
        <testOutputDirectory>${build.testOutputDir}</testOutputDirectory>
        ...
    </build>
    ...
</project>

The behaviour thus far should not differ in any way from the default Maven build cycle. The last thing we need to do now is to add a profile for emitting to the RAM-drive:



<project>
    <profile>
        <id>RAM-drive</id>
        <build>
            <plugins>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <inherited>true</inherited>
                    <configuration>
                        <source>1.6</source>
                        <target>1.6</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>
        <properties>
            <build.dir>/media/ramdrive/maven-targets/${project.name}</build.dir>
            <build.outputDir>/media/ramdrive/maven-targets/${project.name}/classes</build.outputDir>
            <build.testOutputDir>/media/ramdrive/maven-targets/${project.name}/test-classes</build.testOutputDir>
        </properties>
    </profile>
    ...
</project>

That's it. Now you just select the profile "RAM-drive" in your IDE when you build, without it having negative consequences for your less fortunate collegues. Of course a similar setup can be made with Ant and most other build environments.

The pain of request scoped JSF

2009-05-16T12:46:00.000+02:00

While I like the idea of a component based web framework, JSF never really felt right to me. There are too many pitfalls and the whole programming model (even with the use of Facelets) feels cumbersome and more complex than necessary. I could probably write up a detailed list of reasons for why I think JSF is the least productive and fun web frameworks of those I know, but that is not the purpose of this blog post. Suffice to say this appears to be a shared sentiment. This post addresses only JSF's focus on server state and the associated overloaded POST aspect.

The problem of state
All programs that does anything remotely interesting, needs to keep some kind of state. In web applications, there are really only two places to put state and that is either on the server or on the client. Because HTTP itself is stateless, most frameworks stores state on the server in a session that is allocated the very first time a unique user visits. This is done either through an associated cookie or a sessionId that's passed along at all times. It's a simple approach that works reasonable well, but it also has some problems.

Scalability - When you do state, inevitably you start to consume memory that accumulates over time only to be cleared when your session times out. While memory and swap space by itself is relatively cheap, you can only throw hardware at it while your user count remains relatively low. Another problem comes to play when you decide to add more machines to assist in carrying the workload, since then you need to propagate out to a globally shared state between all the machines.
Complexity - The moment you do state, you have to think about concurrency and visibilty. Everything is essentially shared so opening several windows in the browser or using asyncronious (Ajax) calls can potentially wreck havoc in the state space for your session. Only with a debugger and non-trivial testing can you gain an overview of this aspect. It does not help that in JSF, there's (to my knowledge) no way to detect a new page load in a session scoped backing bean so you can't use that to do a partial "reset".
Unpredictable - Have you ever been working on something online, then picked up a phone call or gone to lunch only to return and receive an error message that says your session has timed out?. In JSF you often receive the more cryptic message "Could not restore view!". This happens because of the stateless nature of HTTP, there's no way for the server to know if a user is still sitting there in the other end, so it relies on a timeout for the session. There's a reverse proportional relationship between the size of this session timeout and the amount of memory consumed by the server, which is why the timeout is often kept down around 30 min.

I'm not totally against state on the server when it's used as a application level caching mechanism or for lightweight session info like language setting etc. Unfortunately it is all too common to see a heavyweight hierarchy from another layer (JPA entities comes to mind) creep into the user session and then it's bye bye to scalability.

JSF favors statefullness
Everything about the JSF programming model is clearly made with session scoped backing beans in mind. For instance, if you try to use various components in request scope, you will find it to be a major problem how events dispatch BEFORE your bean have had its properties filled out from the POST request. So, since JSF does not provide sufficient context, what people often do is to go behind JSF's back and grab the required context from the request parameters.

Example, say that you have a JSF page that displays some info about a customer entity. You would like an easy way to test and interface with legacy apps, so you allow a request parameter called customerId to be passed along as initial context. From within this page, you may perform various CRUD operations on the customer, which means you pass along this context in various ways, typically by including something like this in your POST-back form:



<html:form id="someform">
   <html:commandButton value="Show customer" action="showCustomer"/>
   <html:inputHidden id="customerId" value="#{customerBB.customerId}" binding="#{customerBB.customerIdHidden}"/>
</html:form>

What people do then in the backing bean, is to use lazy detection code to first try to fetch a property directly (if they know the form name) or from bound components. The latter approach would look something like this:



private static final String CUSTOMER_ID_PARAM = "customerId";
private Long customerId;
private HtmlInputHidden customerIdHidden;

public HtmlInputHidden getCustomerIdHidden() {
    return customerIdHidden;
}

public void setCustomerIdHidden(HtmlInputHidden customerIdHidden) {
    this.customerIdHidden = customerIdHidden;
}

public Long getCustomerId(){
    if(customerId == null){
        String customerIdString = getRequestParameter(CUSTOMER_ID_PARAM, false);
        if(customerIdString != null && !customerIdString.isEmpty())
            customerId= Long.parseLong(customerIdString);
        else if(getCustomerIdHidden() != null){
            customerIdString = getRequestParameter(getCustomerIdHidden().getClientId(getFacesContext()), false);
            if(customerIdString != null && !customerIdString.isEmpty())
                customerId = Long.parseLong(customerIdString);
        }
    }
    
    return customerId;
}

Very verbose and fragile. And while JSF proponents will probably claim this is not the sanctioned way to use JSF, that's the kind of hacks I've seen on numerous occasions. In the following sections I'll describe an approach which is essentially a return to an action based framework where the idea is to separate functionality out into distinct pages and backing beans, with a controlled context flowing between these.

Managed properties
It turns out, you can instruct JSF to automatically initialize a backing bean property from both POST and GET requests. You do this via the managed-property tag in faces-config.xml, like so:



<managed-property>
   <property-name>customerId</property-name>
   <value>#{param['customerId']}</value>
</managed-property>

That still leaves us with the problem that in JSF, input variables are identified on the form [formname]:[inputname], so a <h:inputHidden> would not be injected into the beans customerId field. There's a way around this though. In your form, simply escape back to basic HTML by using the <core:verbatim> tag. This prevents JSF from modifying the tag name and id:



<core:verbatim>
   <input type="hidden" id="customerId" name="custumerId" value="#{customerBB.customerId}"></input>
</core:verbatim>

Overloaded POST's with GET redirects
A strongly associated aspect of the state on the server, is how everything in JSF is done through POST's. That presents a particular problem to JSF authors who wish to write in request scope, since an URL no longer expresses any of the necessary minimum state needed for the website to "live in the know". Hitting refresh in the browser won't work. What I do is to peek over at the RESTfull architectures, and only use POST for actions that causes state to mutate (updating or creation), and GET for the remaining idempotent actions.

For instance, rather than using a <html:commandLink> and navigation rules to go to an edit page for an item in a list, I'll use <html:outputLink> that points to the JSF page itsef along with the necessary context:



<html:outputLink value="customer-edit.jsf">
   <html:outputText value="Edit"></html:outputText>
   <core:param name="customerId" value="#{customerBB.customerId}"/>
</html:outputLink>

Note that this actually has nothing to do with the form, it simply expands to a hyperlink which is why in this case we won't need the <core:verbatim> tag.
The second part to this is to ensure we always emit the new context from the logic in the backingbean, that means for mutating POST operations to forward to a GET. This can be done by manually navigating to a result URL rather than returning a navigation rule. The following could be an example of what to do after a save operation was invoked on the consumer-edit.jsf page.



FacesContext.getCurrentInstance().getExternalContext()
.redirect("customer-view.jsf?customerId=" + getCustomerId());

In conclusion
JSF makes it very hard to avoid state on the server, but I hope this entry will have proven that it is possible to compose simple CRUD pages with this objective in mind. It's arguably bending JSF beyond its intentions, but if you have had your share of problems with JSF as I have, perhaps this classic way of thinking in request parameters will let you utilize some of JSF's nice looking components in a simple way without walking down the dreaded statefull alley. As a side effect, it becomes trivial to document the state space and assert preconditions of your pages.

The approach probably does not scale beyond relatively simple pages although I could claim adherence to the Separation of concerns principle. So if you command your own toolchain, I would urge you to have a look at Wicket (for classic broad-spectred web apps) or GWT (for data-intensive intranet apps) instead.

Confessions of an RC heli noob

2009-01-11T16:18:00.000+01:00

Ever since I was a boy, I've been impressed with two kinds of machines: Ferrari's and helicopters. I guess the two don't share much apart from the price tag and being primarily a male thing. Never the less, since treating myself a ride this summer in a Robinson R-44 over a Canadian national park, I've been moving slowly but surely into the realm of remote controlled helicopters.

Off to a wrong start
I always knew helicopters were among the most difficult things to control, yet I still wasn't prepared for exactly HOW difficult. Of course, I did not exactly make it easy for myself by starting out with a 400 series 6-channel 3D capable outdoor helicopter, like this Hughes 300:

Since then, I had some fun with other models. For instance, just as a toy for my nephew I got the Silverlit TandemZ mini helicopter, a tiny 3-channel indoor model that actually flies pretty decently albeit terrible susceptible to drafts. This really is just a toy though, do not expect to be able to practice for the big ones with these:

The last model I got is somewhere in between, the Lama V4, a very popular 4-channel co-axial indoor model. At half the size of the Hughes 300, it still takes a bit of space and will break if you're too tough, but it's a great learner since the controls are so similar to a full size one.

Tips and advice
You must walk before you can run, and crawl before you can walk. It's the same with helicopter flying. With that in mind, here are a few pointers to other newbies considering going into this fun but potentially very expensive hobby.

A 4-channel indoor is realistic enough to provide you with a lot of cheap flying time and practice reflexes. Do not get ambitious and go for a 6 or 7 channel chopper. Trust me, learning to control yaw, pitch and roll with the aileron stick and the trottle/rudder stick is challenging enough.

Start to fly indoor. You won't have to fight any wind which can have profound implications to the flight characteristics of the helicopter, so that's one variable you should factor out when initially learning.

The smaller the helicopter, the more durable it will be when crashing and the cheaper the parts usually are. If you already are going for an indoor practice helicopter, you have already excluded wind as a factor and then size matters less. The larger the helicopter, the more stable it flies. There's a balance here, i.e. while you can fly the medium sized Lama V4 outside in no wind, the same is not true for the Blade mCX as its simply too small.

Consider going with a co-axial model where left and right torque cancels itself out such as to not need a tail rotor. There are a few advantages to this. The tail rotor is delicate by itself, not having it is one less thing that can break. It also makes it possible to grab the heli by the tail if something goes wrong which I've done several times. There's one drawback to it though. Turning a co-axial helicopter basically means relaxing the speed a bit on one of the axles and that means you'll loose lift and start to drop. It's not too hard to learn to compensate for this by giving it a bit more thrust as you turn, but it's a habit you don't want to carry with you over to uni-axial helicopters.

Needless to say, you are also going to need a training gear. The intuitive reflex we all have when something is about to go wrong, is to cut the gas - biiiig mistake with a helicopter. Even if you've learned never to do this, maintaining perfect pitch, roll and yaw takes a long time to master and it takes only one wrong turn on the aileron stick to slam the blades into the ground.
The training gear can be purchased or you can do as I, and construct it yourself using some bamboo (flexing is your friend), a glue gun and some ping-pong or Styrofoam balls. That way you can drop the heli from about a meters height and it won't suffer any damage.

Consider getting some better blades when you master the basics. The plastic blades that often come with the smaller/cheaper models are inexpensive to replace, but they also flex more, require higher RPM's and is generally less stable in the air while breaking extremely easy. You can purchase carbon fiber or fiberglass blade upgrades for many small helicopters and in my experiences its well worth it for the 40-50% higher price.

Get a 2.4GHz spread spectrum version rather than a fixed frequency x-tal. The problem with a x-tal system is that it's inherently susceptible to crosstalk from other devices and require a long antenna on both helicopter and radio controller. This is the reason why, if you go to an RC club, you will see people holding a dedicated frequency token such as to prevent two from using the same frequency. With 2.4GHz technology, you can pair up (bind) the receiver and the transmitter just like you may know from blue-tooth technology. It's just more future proof to get 2.4GHz stuff which is why I payed slightly extra to have this for my Lama V4. Potentially you also save money in the long run, by being able to own only one controller for your fleet of helicopters.

Last but not least, you should get a simulator. I'm no big fan of simulators myself, but they can help you build up more of the required "feel" while keeping crashing a cost-free exercise. There are some fine commercial ones out there I am told, but I just practice with the free one you often get with the helicopter.

Wrapping up
Keep in mind, I am just a beginner and my advice needs to be taken with a grain of salt. Those are my own real experiences however. Start in the small, keep things simple and minimize variables before to drive a $300-400 piece of electronics into the ground and loose your interest. Happy flying. :)

Java Enum relational modelling

2008-12-06T22:18:00.000+01:00

As I have blogged about before, the Java Enum is almost perfect. I say almost because of the annoying restriction that its constructor cannot include a relation to itself, due to forward reference limitations when using the Sun compiler. The issue came up again recently when I wanted to model authority roles in Wicket, so I spent a bit more time with the issue and the following is what I've learned. First though, a recap of the original problem. Consider the following attempt at modeling states of a CD player:



public class IlligalForwardReference {
    enum Player{
        PLAYING(Player.PAUSED, Player.STOPPED),
        PAUSED(Player.PLAYING, Player.STOPPED),
        STOPPED(Player.PLAYING);

        private  final EnumSet<Player> transitionStates;

        Player(final Player... states){
            this.transitionStates = EnumSet.copyOf( Arrays.asList(states));
        }

        public EnumSet<Player> getTransitionStates(){
            return transitionStates;
        }
    }

    public static void main(String... args){
        System.out.println(Player.PLAYING);
    }
}

The compiler will complain with:


IlligalForwardReference.java:18: illegal forward reference
        PLAYING(Player.PAUSED, Player.STOPPED),
IlligalForwardReference.java:18: illegal forward reference
        PLAYING(Player.PAUSED, Player.STOPPED),
IlligalForwardReference.java:19: illegal forward reference
        PAUSED(Player.PLAYING, Player.STOPPED),
3 errors
BUILD FAILED (total time: 0 seconds)

This problem comes up as soon as you need to reference an Enum value which has not yet been initialized. Often you can avoid this if no circular relationship exists, by declaring the ones with no relations first and then adding related ones below. That is not an option however in the above example.

Passing ordinals instead
One could imagine then passing in the ordinal value or String representation instead, as a workaround to this limitation. It's less type safe and somewhat reminiscent of what an Enum is supposed to solve in the first place. The following is an attempt at this, using ordinal values:



public class ExceptionInInitializerError {
    enum Player{
        PLAYING(1, 2),
        PAUSED(0, 2),
        STOPPED(0);

        private final EnumSet<Player> transitionStates;

        Player(final int... ordinals){
            Collection<Player> states = new ArrayList<Player>();

            for(int ordinal : ordinals)
                states.add( Player.values()[ordinal]);

            transitionStates = EnumSet.copyOf(states);
        }

        public EnumSet<Player> getTransitionStates(){
            return transitionStates;
        }

        @Override
        public String toString(){
            return name() + " -> " + transitionStates;
        }
    }

    public static void main(String... args){
        System.out.println(Player.PLAYING);
    }

But unfortunately not. Although the code now compiles, we have effectively just traded the compile time error with a runtime InitializerError:


Exception in thread "main" java.lang.ExceptionInInitializerError
        at ExceptionInInitializerError.main(ExceptionInInitializerError.java:42)
Caused by: java.lang.NullPointerException
        at ExceptionInInitializerError$Player.values(ExceptionInInitializerError.java:15)
        at ExceptionInInitializerError$Player.(ExceptionInInitializerError.java:26)
        at ExceptionInInitializerError$Player.(ExceptionInInitializerError.java:16)
        ... 1 more
Java Result: 1
BUILD SUCCESSFUL (total time: 0 seconds)

That's because we cannot access the ordinals before the Player Enum has been initialized.

Deferred initialization
Hmm ok, but we can defer this step until we actually start querying for transition states. The following is an attempt at this, using String representations this time around:



public class DeferredStringBased {
    enum Player{
        PLAYING("PAUSED", "STOPPED"),
        PAUSED("STOPPED", "PLAYING"),
        STOPPED("PLAYING");

        private final String[] transitionStateStrings;
        private volatile EnumSet<Player> transitionStates;

        Player(final String... transitionStateStrings){
            this.transitionStateStrings = transitionStateStrings;
        }

        public EnumSet<Player> getTransitionStates(){
            if(transitionStates == null){
                synchronized(this) {
                    if(transitionStates == null){
                        transitionStates = EnumSet.noneOf(Player.class);
                        for(String transitionStateString : transitionStateStrings){
                            transitionStates.add( Player.valueOf(transitionStateString));
                        }
                    }
                }
            }
            return transitionStates;
        }

        public String toStringWithTransitions(){
            return toString() + " -> " + getTransitionStates();
        }
    }

    public static void main(String... args){
        System.out.println(Player.PLAYING.toStringWithTransitions());
        System.out.println(Player.PAUSED.toStringWithTransitions());
        System.out.println(Player.STOPPED.toStringWithTransitions());
    }
}

Halleluja, it's working, we get:


PLAYING -> [PAUSED, STOPPED]
PAUSED -> [PLAYING, STOPPED]
STOPPED -> [PLAYING]
BUILD SUCCESSFUL (total time: 0 seconds)

Note that if you are modelling something where it makes sence to have transitivity (say authority roles where an administrator automatically assumes the role of user, as long as administrator declares a transition to superuser, and superuser declares a transition to user) then in the inner loop of the getTransitionStates() method, add the line:



transitionStates.addAll( Player.valueOf(transitionStateString).getTransitionStates() );

Modelling transitions instead
It was suggested to me in my last entry about the subject, that I could model the transitions instead of the states, as Josh Bloch recommends in Effective Java SE, item 33. This is true, if you do not need symmetric relations (if playing can go to stopped, then stopped must also go to playing) and is fine with adding another layer consisting of the transition states too. By focusing on modelling transitions rather than states (which makes sence in Bloch's phase change example), you arrive at something like this:



public class Bloch{
    public enum Player {
        STOPPED, PLAYING, PAUSED;

        public enum PlayerTransition {
            STOPFROMPLAYING(PLAYING, STOPPED), PLAYFROMSTOPPED(STOPPED, PLAYING),
            PAUSEFROMPLAYING(PLAYING, PAUSED), PLAYFROMPAUSED(PAUSED, PLAYING),
            STOPFROMPAUSED(PAUSED, STOPPED);

            private final Player src;
            private final Player dst;

            PlayerTransition(Player src, Player dst) {
                this.src = src;
                this.dst = dst;
            }

            private static final Map<Player, Map<Player, PlayerTransition>> m =
                    new EnumMap<Player, Map<Player, PlayerTransition>>(Player.class);

            static {
                for (Player p : Player.values()) {
                    m.put(p, new EnumMap<Player, PlayerTransition>(Player.class));
                }
                for (PlayerTransition trans : PlayerTransition.values()) {
                    m.get(trans.src).put(trans.dst, trans);
                }
            }

            public static PlayerTransition from(Player src, Player dst) {
                return m.get(src).get(dst);
            }
        }
    }

    public static void main(String... args)
    {
        System.out.println( Player.PlayerTransition.from(Player.STOPPED, Player.PLAYING) );
        System.out.println( Player.PlayerTransition.from(Player.PLAYING, Player.PAUSED) );
        System.out.println( Player.PlayerTransition.from(Player.PAUSED, Player.STOPPED) );
    }
}

Which yields the output:


PLAYFROMSTOPPED
PAUSEFROMPLAYING
STOPFROMPAUSED
BUILD SUCCESSFUL (total time: 0 seconds)

While I'm sure there are things you can model with this approach, I would much rather be modelling the states rather than the transitions. There are however an idea that comes to mind from seeing this.

Getting rid of the circular dependency
If the whole problem stems from the fact that we cannot have circular relations, then perhaps we can split it in two such that only one relation is modelled statically, while the other is modelled dynamically - but setup statically. It's hard to explain, but take a look at this code:



public class MirrorEnum {
    public enum TransitionTo{
        PLAYING, PAUSED, STOPPED;

        Player state;

        private void setState(Player state){
            this.state = state;
        }

        private Player getState(){
            return state;
        }

        public enum Player{
            PLAYING(TransitionTo.STOPPED, TransitionTo.PAUSED),
            PAUSED(TransitionTo.PLAYING, TransitionTo.STOPPED),
            STOPPED(TransitionTo.PLAYING);

            private final EnumSet<TransitionTo> transitionToSet;
            private volatile EnumSet<Player> transitionStates;

            Player(final TransitionTo... transitionToArray){
                this.transitionToSet = EnumSet.copyOf( Arrays.asList( transitionToArray ) );
            }

            public EnumSet<Player> getTransitionStates(){
                if(transitionStates == null){
                    synchronized(this){
                        if(transitionStates == null){

                            // Make sure each Transition state is in sync with each PlayerState
                            for(TransitionTo transition : TransitionTo.values()){
                                transition.setState( Player.values()[transition.ordinal()]);
                            }

                            // Construct TransitionState's by mapping from Transition to PlayerState
                            transitionStates = EnumSet.noneOf(Player.class);
                            for(TransitionTo transition : this.transitionToSet){
                                transitionStates.add( transition.getState() );
                            }
                        }
                    }
                }
                return transitionStates;
            }

            public String toStringWithTransitions(){
                return toString() + " -> " + getTransitionStates();
            }
        }
    }

    public static void main(String... args){
        System.out.println(TransitionTo.Player.PLAYING.toStringWithTransitions());
        System.out.println(TransitionTo.Player.PAUSED.toStringWithTransitions());
        System.out.println(TransitionTo.Player.STOPPED.toStringWithTransitions());
    }
}

When run, the above results in:


PLAYING -> [PAUSED, STOPPED]
PAUSED -> [PLAYING, STOPPED]
STOPPED -> [PLAYING]
BUILD SUCCESSFUL (total time: 0 seconds)

The whole idea is to have two Enum's which mirror eachother yet are distinct to the Java compiler - not unlike when aliasing a column in SQL. You have to deal with two Enum's (Player and TransitionTo) at compile time, but at runtime only Player comes into play. It's not a solution I will actually use however, for that it is too complex and not DRY enough.

Conclusion
In practice I'll go for the ordinal approach when modeling relations. While there is no code completion to be had and only limited type-safety, it stands out as the cleanest and most elegant solution. It's also relatively easy to add some assertions and unit testing to improve on this a bit.

The best would obviously be for Sun to simply fix this in the compiler. The Eclipse compiler have already shown it is possible to do this and make it more lenient. Until then, if you have a more elegant solution to the stated problem, I'd love to hear about it.

Jasper Reports and legacy formats

2008-11-08T03:14:00.000+01:00

I'm not sure when exactly or between which versions, but at some point Jasper Report designs moved from being based on legacy DTD to the more modern XSD schema. It turns out that most tools today, i.e. the iReport plugin for NetBeans, are now overwriting the DTD information of legacy designs in favor of XSD information.
This can cause problems if and when you are not able to change the Jasper engine itself that fills out the template designs. It also did not seem possible to simply plug-in another XML parser and I found it rather hard in general to find information about this and support forums to turn to. So I sought another solution.

If you try to run an XSD based design against the Jasper engine that can only deal with DTD, you will get an error along the line of this:


net.sf.jasperreports.engine.JRException: org.xml.sax.SAXParseException: Document root element "jasperReport", must match DOCTYPE root "null".

By using a legacy designer which favors DTD's (iReport 3.0 standalone) and the recent NetBeans plugin which favors XSD's, it becomes apparent what the exact differences are. Obviously the DTD version has a doctype clause:


<!DOCTYPE jasperReport PUBLIC "//JasperReports//DTD Report Design//EN" "http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">

Furthermore, the jasperReport root element has the extra attributtes:


xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation=http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd

One could just edit the files manually, but seriously, what fun is that. Instead, we can create a decorator to perform this job on-the-fly as we send the design off to the Jasper engine to be compiled. We would need to do the following:

Read the InputStream into a DOM tree
Add the missing DTD doctype
Remove the undesired attributtes
Write the dom back out to an InputStream

The result of doing the above I've placed in LegacyJasperInputStream.java.

An example on how to use it:



JasperDesign design = JRXmlLoader.load(
        new LegacyJasperInputStream(new FileInputStream("MyXsdBasedDesign.jrxml"))
        );

Probably I am not the only one facing this issue, which is why I chose to write a small entry about it and hopefully helping others. Be advised, you're going to need the slf4j logging facility, or modify the source slightly to make use of the standard java.util.Logger.

Congratulations America!

2008-11-07T01:55:00.000+01:00

I think it's only in order to congratulate the USA for what has happened. While oddly 47% of Americans still haven't noticed, the last 8 years of an illiterate republican doctrine "if you're not with us, you're against us" has hurt their country incredibly much. As evident right from the beginning to most of us, Bush will go over in history as the worst president of all time - only elected for his second term I suppose due to that fuzzy term called "American patriotism".

The only sad part will be missing someone to laugh at when watching Letterman, The Colbert Report or The Daily Show. Ah for a while at least, we'll always have Gucci Palin. ;)

Best of luck Obama, you sure have your work cut out for you! The future just got a lot brighter in the prospect of regaining an America so many of us used to admire once! With a new dawn near and a fresh breeze blowing from the west, let the healing begin.

Groupwise 7 on Ubuntu 8.04

2008-09-27T16:48:00.000+02:00

While web applications in browsers are continuing to improve, they still can't quite compete with desktop applications. One of the examples of this is the Novell Groupwise client. Running 64bit Ubuntu poses a bit of a challenge, since Novell only offer prepackaged rpm bundles for 32bit Red Hat and Suse systems. Note, some of this stuff is inspired by Scott's blog entry earlier this year, however I could never get his howto to work for me.

Start by downloading the Groupwise client RPM onto a 32bit version of Ubuntu (I use a 32bit image in VirtualBox). I'm not sure from where I found mine, but it's out there if you search a little. You should end up having a file called something like novell-groupwise-gwclient-7.0.3-20080310.i386.rpm

To convert this into a debian package, you are going to need alien. Get this by typing:


sudo apt-get install alien

With alien, you can convert the RPM into DEB by typing:


sudo alien -c novell-groupwise-gwclient-7.0.3-20080310.i386.rpm

Now you're done with the 32bit stuff. Move your novell-groupwise-gwclient_7.0.3-20080310.deb to your target 64 bit box. Before installing the DEB, make sure you have the nessesary dependencies. On my system I needed lib std. C++ 5 (you might need others as well) so I had to do:


sudo apt-get install libstdc++5

Install the Groupwise client itself by issuing:


sudo aptitude install novell-groupwise-gwclient_7.0.3-20080310_i386.deb

You should now have Groupwise installed in the /opt/novell/groupwise folder and shortcuts created on your desktop and in the Ubuntu Internet application menu. Groupwise is actually written (mostly) in Java, which it bundles (in my case the Sun JRE 1.5.0_06-B05). This works fine except if you are using Compiz, but I am so I needed to replace the 32bit slightly old bundles JRE with a newer one. Download a .bin from SUN's site, be sure to only download a JRE (not a JDK) and a 32bit (i586, not a amd64) one. Once downloaded, you can extract it to a folder by running:


sh jre-6u10-rc2-bin-b32-linux-i586-12_sep_2008.bin

Finally, we need to replace the JRE Groupwise is bundled with, with this new one you just extracted into the folder /jre1.6.0_10. So delete the folder /opt/novell/groupwise/client/jre/:


sudo rm -R -f /opt/novell/groupwise/client/jre

Then copy the new JRE in folder jre1.6.0_10/ to /opt/novell/groupwise/client/jre/:


sudo cp jre1.6.0_10 /opt/novell/groupwise/client/jre -R

There you go. That should give you Groupwise 7.03 running on the latest Ubuntu 8.04.

Java 6 update 10 on Ubuntu 8.04

2008-09-26T21:01:00.000+02:00

The official Ubuntu 8.04 repositories comes with a slightly outdated version of Java, namely 1.6.0 update 6. If you issue a java -version you can assert this is the case:

Unfortunately, if you are running Compiz, you are likely to then suffer the notorious gray rectangle syndrome as described in 6429775, 6434227 and 6632124 among others. The good news, the problem appears to be fixed in update 10.

Installing the latest JDK
Start by downloading the JDK for your architecture from SUN. Take the .bin file, extract it by running it as a shell script:


sh jdk-6u10-rc2-bin-b32-linux-amd64-12_sep_2008.bin

This will create a new folder called /jdk1.6.0_10. Rename this to java-6-sun-1.6.0.10 (just to remain consistent with how Debian/Ubuntu refers to JDK's) and move this folder to /usr/lib/jvm:


sudo mv jdk1.6.0_10 java-6-sun-1.6.0.10
sudo mv jdk1.6.0_10/ /usr/lib/jvm

Officially you are suppose to use the update-java-alternatives command when using a Debian distro, but frankly I find it easier to do this manually. We need to update the /usr/lib/jvm/.java-6-sun.jinfo, so type:


gksu gedit .java-6-sun.jinfo

This will open up a hidden configuration file. The first line likely shows:


name=java-6-sun-1.6.0.06
...

Simply change this to point to the new version:


name=java-6-sun-1.6.0.10
...

Also, update the java 6 symlink to point to the one we just installed:


sudo rm /usr/lib/jvm/java-6-sun
sudo ln -s /usr/lib/jvm/java-6-sun-1.6.0.10/ /usr/lib/jvm/java-6-sun

This should actually work for most applications, but to be sure I always like to add a few common environment variables. Do this by typing:


gksu gedit $HOME/.bashrc

Scroll down to the end of the file and add two new lines:


export JDK_HOME=/usr/lib/jvm/java-6-sun
export JAVA_HOME=$JDK_HOME

That should do it. Issuing a java -version command now yields the latest version:

Remember the above isn't necessarily the official sanctioned way to do it, but it worked for me. Good luck to you!

Update:
It has come to my attention that Ubuntu 8.04 updates to the JVM overrides/reverts the modifications above. Keep an eye on this, I noticed it when starting seeing Compiz grey-box frames again in NetBeans.

@SuppressWarnings completion

2008-09-03T01:53:00.000+02:00

Why it was made
Although NetBeans is capable of suggesting and auto-inserting @SuppressWarnings, it doesn't actually provide code completion or documentation for these values. Indeed, as I've blogged about before, it is tricky to track down the exact enumeration and semantics of these magic values. This is due to the fact that they are entirely dependent on the compiler and IDE. This plugin adds support for the values currently supported by NetBeans 6.1, namely "cast", "deprecation", "divzero", "empty-statement", "empty", "fallthrough", "finally", "serial" and "unchecked". It also tries to explain how and when to use them.

How it was made
Creating plugins for NetBeans is relatively easy if you start by grabbing existing code and have invested in the RCP book. Especially blogs like Geertjan's and Sandip's are virtual goldmines. So for this one, I used the Geertjan's blog entry entitled Caret Aware Code Completion. I had some trouble hooking into the Java parser as the tutorial shows, whenever invoking completion, there would be a lag between obtaining the caret position and resolving the current element. I did not figure out why this is, other than for some reason, the mapping from caret position to the underlying AST went out of sync. So instead I ended up relying only on the build-in Java lexer, which did not exhibit the same lag. This means there were a little bit of manual parsing to do, to assert if indeed the context invites for @SuppressWarnings values. The following scenarios had to be accounted for:


    @SuppressWarnings(STRING_LITERAL
    @SuppressWarnings({STRING_LITERAL
    @SuppressWarnings({STRING_LITERAL, STRING_LITERAL
    @SuppressWarnings(value=STRING_LITERAL
    @SuppressWarnings(value={STRING_LITERAL, STRING_LITERAL

In other words, we have to consume the Java token stream in reverse, from any open of closed STRING_LITERAL, and pass the following finite-state machine:

This is implemented by a simple recursive descent parser, which looks like this. Should you care to use it for your own parsing of a DSL inside Java String tokens, you can download the complete source code here.

Where to get it
There might still be some bugs and perhaps I a missing something, but if you want to give it a spin, you can download the plugin from NetBeans plugin central.

The hardest thing was to gather information regarding the valid values, since it differs from compiler to compiler and the various IDE's. If you do happen to find a bug or something incorrect, please let me know so I can correct it.

Myth: Java widely used in the browser

2008-08-29T14:51:00.000+02:00

Yes I aspire to be a MythBuster, don't we all? For a while now there has been some concern over Apple's apparent lack of love for Java. Lately the debate has shifted over to the iPhone and the Java blogosphere is doing its best to send a message to Apple. While I am far from a supporter of the policies and practices of Apple, I do think they are right in determining Java as legacy or an anomaly on the web of 2008.

A sniffing bot
It turns out it's hard to find concrete evidence of how widespread the use of Java client technology is on the internet. What we can do however, is simulate a web user, randomly browsing around and taking note of how often we bump into Java.
The first issue is, how can we come up with truly random URL's? Three different approaches comes to mind:

Use some existing randomizer service

Methodically run through IP ranges

Screen scrape Google results

I actually implemented all 3. Of those both item 2 and 3 potentially raises some ethical questions, consistent scanning of remote systems can be considered a hostile activity as can web scraping. Thus the one presented here uses the 1'st approach only and is quite slow due to the fact that the random function of the site I am using seems to be bound by timestamp data (probably works by hashing the hh:mm:ss and looking up an index in a table). For that reason, and out of politeness, I've inserted a 1 sec delay between each attempt.

The scent of Java
Due to Java's age, there are quite a few ways it can be embedded onto a page depending on both HTML standards and individual browsers. There the APPLET tag, there's the OBJECT tag and then there's the EMBED tag. This should also include the recent iteration of Java client technology, namely JavaFX, since they appear to be reusing the APPLET tag for this - odd actually, considering W3C/HTML4.x deprecated this tag 9 years ago now.

Apart from these tags, JavaScript and frames can further hide the fact that Java technology is being used. This is not very common from what I've experienced though, much more common with Flex and especially Silverlight. Also we need to take into consideration Java Web Start, we do this by capturing links which points at *.jnlp files.

Implementation
Was pretty trivial, thanks to Java Swing's old but readily at hand HTMLEditorKit. The hardest part was coming up with a simple yet functional query language as I did not want to hardwire these rules nor depend on any 3'rd part library. The essence of the markup matching is modeled by an enum (I love Java enum's) and it looks like this:



enum TagMatch{
    JAVA(// Most Java applets exist inside an APPLET tag
         Tag.create(HTML.Tag.APPLET, Attr.create(HTML.Attribute.CODE)),
         // Java Web Start will be anchors ending in .jnlp
         Tag.create(HTML.Tag.A, Attr.create(HTML.Attribute.HREF, ".*\\.jnlp$")),
         // OBJECT and EMBED tags pass in class or jar file
         Tag.create(HTML.Tag.PARAM, Attr.create(HTML.Attribute.VALUE, ".*\\.(class|jar)$"))
    );
     
    private List<Tag> tagMatches = new ArrayList<Tag>();

    TagMatch(Tag... tagVararg){
        tagMatches = Arrays.asList(tagVararg);
    }

    public List<Tag> getTagMatches(){
        return tagMatches;
    }
}

If you want to take a look at the whole source file, it's available righ here.

Enough with the talk
The following is the result of scanning 1.000 random sites:


Found 7 sites matching JAVA
+--[www.gailzavala.com/]
+--[www.nationalhealthcouncil.org/]
+--[web2c.com]
+--[armadaweb.com/Anime/Sailor/]
+--[www.gloverpainting.com]
+--[www.theschrodts.com]
+--[members.shaw.ca/micheil/burns/burns.htm]

Well well, 7 sites out of 1000 were identified as using Java on the client tier. I have of course run it a number of times, each resulting in roughly the same numbers somewhere between 5 and 10. This leaves me to conclude that the amount of sites using Java is less than 1%. And how about those that do? If you take a look at some of the links, at least half of them are webcam viewers, scrollers and counters reminiscent of the 90's.

Conclusion
Can't say I was surprised by the result. I am aware of a few things that relies on Java (home banking comes to mind) but then again, I also know of minority sites that use ActiveX. So I still think we can not slam Apple for this one. Certainly iPhone users would be missing Flash much more than Java. Of course, let's hope the new JavaFX stuff and the forthcoming update 10 will pan the way for a renascence.

Update:
People don't seem to like this entry very much. I'm not sure whether its because I am speaking negative about Java in the browser or if I simply didn't convey the message good enough. So to rephrase, this is a simple test to show that Java applets and web start applications are in such low use on websites that to most people (and by inference browser vendors) not having support for these doesn't matter much. Contrast this to the results I get when running another test, this time searching 1000 random sites for for Flash/Flex usage (tags with a SRC attribute containing ".swf"). Such a query results in the following matches:


Found 179 sites matching FLASH
+--[www.countrybumpkin.com.au/]
+--[www.chrissmithphoto.com]
+--[www.bostonbw.com]
+--[www.lipseylipsey.com]
+--[www.zewa.com]
+--[www.webguide.com/attractions.html]
+--[www.socaldelivery.com]
+--[www.lincolnspeedway.com]
+--[www.redcliffslodge.com]
+--[www.baldwin-school.org/]
+--[www.bdainc.com]
+--[www.hydraulicpumps.co.uk/]
+--[www.mainstreetcottonshop.com]
+--[www.yellowstonevacations.com]
+--[www.acmotorcars.com]
+--[www.deadwooddicks.com]
+--[www.judycarter.com]
+--[biz.yahoo.com/n/l/s/sun.html]
+--[www.siasat.com]
+--[www.jackand.co.jp/]
+--[www.meritax.com]
+--[www.westpasco.com]
+--[www.calpers-governance.org/]
+--[www.paradiseranch.com]
+--[www.tamilnaduwomen.org/]
+--[www.dynamitedetail.com]
+--[sportsillustrated.cnn.com/basketball/ncaa/men/teams/oregon/]
+--[www.glenfir.com]
+--[www.marquette.org/]
+--[www.uwwsports.com/index.asp?path=football]
+--[www.sfballoonguy.com]
+--[www.alliedmodular.com]
+--[www.helenelliott.com]
+--[www.nationwidemortgage.com.au/]
+--[www.admissions.umich.edu/]
+--[www.globalcredit.com]
+--[www.godinos.com]
+--[www.leonidas-chocolate.com]
+--[www.01-flash-web-templates.com]
+--[www.gwmcnamara.com]
+--[www.HiDoctor.com]
+--[www.metromayors.org/]
+--[www.vigorita.com]
+--[www.goforth.org/]
+--[www.reitdesign.com]
+--[www.brentlmiller.com]
+--[www.abingdon.com]
+--[www.ravenwoodgolf.com]
+--[www.goldner.com]
+--[www.sarasota.k12.fl.us/brookside/]
+--[www.craigsmithrv.com]
+--[www.labelexpress.com.au/]
+--[www.bagsoflove.co.uk/]
+--[www.var-provence.com/web_anglais/]
+--[www.santafe.cc.fl.us/]
+--[www.terrybryant.com]
+--[www.philanthropy.iupui.edu]
+--[www.kkla.com]
+--[www.iconicimaging.co.uk/]
+--[www.christielodge.com]
+--[www.waynegoodwin.org/]
+--[www.livingdesert.org/]
+--[www.scblues.com]
+--[www.skippinggirl.com]
+--[www.thebusinessgarden.co.uk/]
+--[www.armbrusterrealty.com]
+--[www.butterfly-kisses.com]
+--[www.acceptancefinancial.com]
+--[www.nvhomes.com]
+--[www.gerlinglaw.com]
+--[www.aweuk.com]
+--[www.uintagolf.com]
+--[www.lawinc.com]
+--[www.neteffects.com]
+--[www.coe.ufl.edu/]
+--[www.key2holidays.co.uk/]
+--[www.sachem.k12.ny.us/]
+--[asia.weather.yahoo.com/asia/China/]
+--[www.ecofurn.com.au/]
+--[www.breckenridgeskishop.com]
+--[www.camroadproperties.com]
+--[www.saassociates.com]
+--[www.cabrillo-inn.com]
+--[www.wwf.org.nz/]
+--[www.kenilworthinn.com]
+--[www.marinedivers.com]
+--[wagner.rivals.com]
+--[www.kanales.gr/]
+--[www.tourinfo.ru]
+--[www.krischs.com]
+--[www.visitlaportecounty.com]
+--[www.roninyachtcharters.com]
+--[www.utp.ac.pa/]
+--[www.colmet.com]
+--[www.rolltidebama.com]
+--[www.automotivecad.co.uk/]
+--[www.titancomics.com]
+--[www.breakfastclub80.com]
+--[www.arowanaclub.com]
+--[www.parachuteschool.com]
+--[www.kraft.com.au/]
+--[www.insuranceoffice.com]
+--[www.sbpolo.com]
+--[www.jlg.com/jlg/products/product-center.html]
+--[www.whmis.net/]
+--[www.theharleystreetclinic.com]
+--[www.rimatravel.co.uk/]
+--[www.uppercaperealty.com]
+--[www.cranecare.ltd.uk/]
+--[www.hostingpartners.co.uk/]
+--[www.jawfixer.com]
+--[www.telemoneyworld.com]
+--[www.minaret.vic.edu.au]
+--[www.houstontexaslaw.com]
+--[www.noisepop.com/2003/]
+--[www.crosswind.ms/]
+--[www.sweethomestexas.com]
+--[www.kahaku.go.jp/]
+--[www.keyualcohol.com]
+--[www.sdb.com]
+--[www.fgcswim.org/]
+--[www.quesnelcurlingclub.com]
+--[www.eggsolutions.ca/]
+--[www.msmedia.com.au]
+--[www.revesbypress.com.au/]
+--[www.strategicevents.com]
+--[www.anabenitez.com]
+--[www.ldai.com]
+--[www.c21capital.ca/]
+--[www.olympic.si/]
+--[www.mma.org.my/]
+--[www.markspencer.com]
+--[www.tdfund.com]
+--[www.residence-hotel.com]
+--[www.loanguy.com]
+--[www.middletonmann.freeserve.co.uk/]
+--[www.dallashomesales.com]
+--[www.firstcolorado.com]
+--[www.predatorsoftheheart.com]
+--[www.adtechintl.com]
+--[www.bleibtreu.com]
+--[www.kurt-darla.com]
+--[www.dreamkitchens.com]
+--[www.artsaloft.com]
+--[www.Theoakridgeschool.org/]
+--[www.maharashtratourism.gov.in/]
+--[www.lampson.com]
+--[www.token.com.tw/]
+--[www.panoptic-online.com]
+--[www.cbpacific.com]
+--[www.stricklandchevrolet.com]
+--[www.jamesnewhouselaw.com]
+--[www.vlada.hr/]
+--[www.calc.com]
+--[www.mustakbil.com]
+--[southwestutahfilm.com]
+--[www.sackville.com]
+--[www.bonbonniere.nl/]
+--[www.lizzydesign.com]
+--[www.ambientjobs.com]
+--[www.nola.com/lsu/]
+--[www.greenbergchiropractic.com]
+--[www.donsphoto.com]
+--[sports.espn.go.com/ncf/clubhouse?teamId=324]
+--[www.dangleterrehotel.com]
+--[www.mcsellshomes.com]
+--[www.driversity.com]
+--[www.gbm.net/]
+--[www.ingraham.net]
+--[www.bib-aveiro.rcts.pt]
+--[www.carlos-restaurant.com]
+--[sanbruno.ca.gov/]
+--[www.tufts.edu/as/astronomy/]
+--[www.ci.superior.wi.us/]
+--[www.mitchellrepublic.com]
+--[www.utcc.ac.th/amsar/about/document24.htm]
+--[www.nonchalance.org/]
+--[www.pelicancruiser.com]
+--[www.rayhana.com]

With 179 vs. 7 hits, obviously one must conclude that, at present time at least, having Flash support in the browser matters a great deal more to an average user than having Java support does.

NetBeans on speed

2008-08-23T01:47:00.001+02:00

In the post from yesterday I was a little harsh regarding the performance of recent NetBeans versions, which seems to have taken a toll for the worse. One of the most annoying things is how much scanning and processing is going on all the time which harms responsiveness and the overall user experience. The NetBeans mailing list yielded responses like "more features requires more work" which is fair enough. However, I decided I wanted to have my cake (speed) and eat it too (features).

Memory mapping to the rescue
It's not exactly new. So called "RAM drives" have been used for ages to speed things up, some Linux distro's even mount the temporary files location into RAM to improve performance. We can do the same to our source checkouts to gain massive increase in throughput as well as access time. There are two easy ways to archive this out of the (Linux) box, mount a dedicated RAM drive or use the TMPFS filesystem. Sorry, Windows users will have to look elsewhere for info about how to set up a RAM drive.

RAM drive
In this approach, you allocate a part of the memory and map it to a mount point. The following will create a 64MB RAM disk and let you access it under /media/ramdisk/:


dd if=/dev/zero of=/dev/ram1 bs=4096 count=16k
mke2fs /dev/ram1
mkdir /media/ramdisk
mount /dev/ram1 /media/ramdisk

It turns out that the kernel decides how much memory you can mount like this, on Ubuntu 8.04 the limit is 64MB. You can however change this to your liking by adding a kernel option before it loads:


ramdisk_size= XX

Note however that while you can unmount these again, the physical memory it occupied will not be released to the system. Another limitation of this approach is that whether you need it or not, the RAM disk will permanently occupy whatever you allocated to it - no more and no less. So you should probably only use this approach if you need a small RAM drive or you are just testing the technique out. The only benefit of this approach I can think of, is that your mounted partition will be listed and can be monitored from the system monitor.

Temporary filesystem
TMPFS is rather different than the traditional block oriented RAM disk. It turns out it's actually even easier to deal with, just try this:


mkdir /media/ramdisk
mount tmpfs /media/ramdisk -t tmpfs

Not only is it easier, it's much more flexible. As you no doubt noticed, we did not actually specify any capacity. TMPFS will use half of your RAM as default. Although you can also specify it directly, there's really no need to since TMPFS is not only able to dynamically decrease but also increase its capacity on demand. This means that if you do not use the partition, you won't pay any memory penalty. Apparently TMPFS is even able to use swap file so that IF you should go overboard in space consumption, you won't suffer loss of data or the like.

You can have your system automatically create and mount a TMPFS partition for you, by modifying your /etc/fstab file. Simply add the following to it:


none /media/ramdisk tmpfs defaults,user,size=1G,mode=0777 0 0

Now I don't actually want to run into scenarios where my system has to start using virtual memory, so I limited the size of the temporary partition to 1GB, that leaves me with at least 3GB for the OS and applications.

Applied to a NetBeans project
It's rather hard to measure and express something as subjective as responsiveness and general feeling of an IDE with and without a RAM drive. Suffices to say it feels like it's running at a blazing speed! Nodes expand at once, tabs activate immediately and it's just an overall impressive experience - it feels like you're back to writing C code rather than Java. Let me try and prove this to you the best I can with just static images. The below screen shots both show the result of running the same simple Ant build target on a small NetBeans module project, first on a normal disk drive and then from of a RAM drive.

It took 10 sec to build on my 10.000rpm VelociRaptor disc, the fastest desktop drive available today. An average disc would require around 12-13 sec I suspect.

Running from of the RAM drive it took just 1 sec, an amazing 10x faster. It's the kind of thing you have to see in order to believe.

I also tried placing NetBeans itself as well as its user directory directly on the RAM drive, but without noticeable difference at run time. It did start up 40-50% faster and became responsive right away, but this is probably not an optimization worth going for.

Applied in practice
So there you have it. No magic involved, all you need is enough RAM which is dirt cheap* and some consistent working habits. You do have to manually copy your project onto the RAM drive as well as remember to move it to a non-volatile partition before you shut your computer down. However given the fact that we usually always work out of CVS/SVN/HG this should not be much of an issue, in fact you could claim it encourages healthier check-in habits.

As a cautionary measure though, I have invested in a cheap UPS in case of power loss and when I shut down my system, a script will automatically copy the content of the RAM drive to a persistent backup partition. For convenience, when I start up, another script will automatically copy the most recent backup back onto to the RAM drive. Thus, rather than having to do a full checkout/clone in the morning, I only have to issue an update. If you really wanted to minimize risks, you could also have a timed cron job or a low-priority synchronization deamon running.

In conclusion
Of course, this technique really doesn't have anything to do with NetBeans per se, so any IDE would benefit from it as well as freeform/Ant/Maven projects. If you feel uneasy about working entirely in volatile memory, I suppose it would be possible to simply modify your build scripts such that only the build artifacts are emitted this way, leaving the actual source code intact on a fully journaled non-volatile file system.

I had fun setting this up, though I am somewhat surprised of how I/O-bound NetBeans appears to be. In a related exercise with Visual Studio and C# a few years back I did not experience anywhere near this speed-up, possibly because the compiler and tool chain is multi-threaded unlike javac and Ant.
So go ahead and give it a try, you might like it too. I obviously take no responsibility for whatever data loss you may experience yada yada. You have been warned!

Update:
Someone asked me how to put the automatic copy mechanism I mentioned above into effect. We are going to need 2 scripts as well as installing these at the appropriate life cycle hooks of Linux. In the following I assume you have created a directory at /ramdisk_archives with root access permissions only and that you are using a Debian derived distro.

Put the below script in a file called ramdisk_to_archive.sh, give it execute rights (chmod +x ramdisk_to_archive.sh) and save it under the /etc/init.d/ directory which is usually where service scripts are put.


#!/bin/sh
#/etc/init.d/ramdisk_to_archive.sh
a=$(date +%T-%d-%m-%Y)

mkdir /ramdisk_archives/$a
cp -i -p -R /media/ramdisk/* /ramdisk_archives/$a
rm /ramdisk_archives/latest
ln -s /ramdisk_archives/$a /ramdisk_archives/latest

This script will create a new subdirectory under /ramdisk_archives based on the current timestamp and copy all content of the RAM disk (with file permissions intact), to this newly created folder. Then it will delete any eventual existing link called latest and finally, it will create this new link again and point to the directory we just created. Finally, you need to install it so it runs at system halt (runlevel 0) as well as reboot (runlevel 6) which you can do by typing this:


ln -s /etc/init.d/ramdisk_to_archive.sh /etc/rc0.d/ramdisk_to_archive.sh
ln -s /etc/init.d/ramdisk_to_archive.sh /etc/rc6.d/ramdisk_to_archive.sh

Next time you reboot or shut down your system, the script above will be run, thus saving the content of the RAM disk onto /ramdisk_archives/ somewhere. Now, to have your RAM disk restored again at boot time, write another script:


#!/bin/sh
#/etc/init.d/ramdisk_to_archive.sh
cp -i -p -R /ramdisk_archives/latest/* /media/ramdisk/

Again, remember to give it execute permission and copy it to the services directory like the prior script. This time we're going to hook into all the other remaining runlevels 2-5. To do this, issue the following command:


update-rc.d /etc/init.d/ramdisk_to_archive.sh defaults

That's it. Remember to clean up the /ramdisk_archive folder from time to time as there's no purge or rotation scheme in place. You are of course free to add this yourself, if you do, drop me a line. :)

*You can have 4GB DDR2 for less than US$ 100. Even older consumer motherboards supports 4GB, newer ones 16-32GB.

NetBeans: Pretty Much Unusable

2008-08-20T04:23:00.000+02:00

NetBeans Pretty Much Unusable
If you care about NetBeans and its performance, an interesting development occurred over the last 24h on the nbusers mailinglist. It seems the upcoming 6.5 release sparked a debate claiming that it's pretty much unusable. While I wouldn't go that far, there is actually some truth to the matter as experienced by my colleagues and I.

A little bit of history
I've been back and forth between various IDE's over the years, coming from Visual Studio (VB/C/C#) I've been rather spoiled in regard to syntax highlighting, code completion and debugging. In fact I remember back in 2001 how I was convinced into doing a college project in Java, primarily because of the assistance offered by Visual Studio J++. At that time, no tool provided these kind of features (although Forte and JBuilder tried).
In this day and age, things looks quite different of course. SUN finally realized that it's worth having great tools (some would argue they have to solve the problems at the tooling level, since the language has effectively gone stale). In any event, todays Java developers can rely on pretty much the same features as Visual Studio. However, for this there still is a price to pay.

The paradox of choice
Having choices is generally a positive thing. But when it comes to software, having too many choices quickly becomes a burden - less is sometimes more. The problem with having multiple IDE's is that, apart from handling of java source files, they aren't really compatible. They all use each their own build system, supports different layout managers etc. so in reality you can't just switch from one IDE to the other. Given the love for committees in the Java space, I do not understand why a project standard was never established through a JSR. In light of this, it becomes rather important you and your project team settle on one IDE that hopefully satisfies everyone.

We chose NetBeans
After initially having used Oracle's JDeveloper for a number of years, we got fed up with the complex stack that Oracle pushed, as well as the semi-yearly releases. We had to live with bugs for a very long time and newer versions of the IDE could never really cope with migrating from the existing code base.
We chose NetBeans 5.5 after having had some success with Swing UI work (Matisse) as well as noticing how SUN were pushing for standards as well as de-facto standards such as Ant etc. Swing now also seemed to be better able to deliver a UI experience where you did not curse constantly at the lack of responsiveness or mismatched L&F. The best part of NetBeans is probably how we constantly get new versions (release, beta, milestone or daily) as well as the plugin community around it. However, not everything is rosy.

Why we might not stay
Since SUN decided to focus their attention on a polyglot of languages, performance seems to be hurting. Java and Swing always felt slow and overly complex to me... but that's subject for another blog post. In NetBeans 6.0 it really did get worse though. Often you would experience lag as you were typing, clicking tab or invoking a menu. It may very well only be 200-300ms but it is enough to be perceived as annoying. I believe it was in 6.1 where they introduced massive Action lazy-loading, with the end result that after NetBeans had started, the whole UI was effectively still unusable for 3-5 seconds.

Having tried 6.5 beta, I can't say I've experienced the gain in speed the new compile-on-save feature promised. Instead, NetBeans feels* even more busy and hence, less responsive to what I am actually trying having it do. I hope this will be sorted out because otherwise I might be compelled to try and move on to Eclipse or IntelliJ. The former always did run fast and smooth but I never really committed to it fully. The latter I have absolutely no idea about, except I keep hearing it's the best.

Is there a point to this?
No not really, apart from documenting the dilemma of choice and warn about the negative developing performance trend of NetBeans. I love NetBeans and the potential I've seen over the last year but productivity comes first. For SUN's sake I hope it will all be resolved, seeing as NetBeans 6.5 is now in beta 2, I doubt it will happen in the 6.5 time frame though.

*I should probably note that I by no means rely on slow hardware (Core II 2.66GHz/4GB Ram/10.000rpm HD) nor outdated software (Ubuntu 8.04 64bit with Sun's Java6u10rc JDK).

JSF and binary content

2008-08-15T03:28:00.000+02:00

So I have been learning JSF and JPA at work recently. While I can't say those are the most exciting technologies to me, at least they appear to be (or become) de-facto standards and that means more leverage over the long term (something not always the case when dealing with Java technologies). Using JSF with Facelets can be a little challenging, the tools are only so-so and frankly it bugs me to have to type so much type-unsafe stuff in XML, EL and annotations. Anyway, what this blog entry is about is how you can bridge the gab between JSF page rendering and binary content delivery.

JSF and PDF
Corporate applications often need to deliver a lot of PDF content, and it is no different where I work. Static PDF documents as well as dynamic ones. Even if frames and iframes are generally frowned upon these days, I find then to be the best way to embed PDF documents inside the browser. However, with JSF you can't just make an xhtml page and expect to be able to stream binary content from it, since the HTTP protocol only allows you to send the header once. Indeed, JSF contains assertions to try and catch this and will complain:



java.lang.IllegalStateException: getWriter() has already been called for this response

You can always use an ActionListener or even an accessor on the backing bean if you just want a link to download a PDF, but embedding one inside a frame or iframe is an entirely different matter. I tried many things, most of them felt like fragile hacks. I will now present the best solution in my opinion, it's generic, it's KISS and it solves the problem.

Back to basics: HttpServlet
It turns out that it is possible, inside a processRequest method of a vanilla HttpServlet, to access session scoped backing beans. This means we just need some way of telling the Servlet about where it can uptain the binary data from and various other meta-data. So I came up with the following simple "API" using HTTP GET parameters:



ServletName?BackingBeanName.MethodName[;ContentType][;FileName]

The Servlet then has to do the following:

Parse and validate parameters
Locate the specified backing bean and call the method to uptain the binary content
Stream the result back to the browser using the specified parameters

The complete source code for the Java Servlet that perform this job, you can get here. To use it, you would add it to your web.xml configuration and then simply call it from your JSF or Facelet files like this:



<iframe name ="frame" scrolling="auto" align="center"
       src="BinaryJSFServlet?myBackingBean.createPDF;application/pdf" width="100%" height="700" >
</iframe>

This way, you can still keep your state and logic in the backing beans without having to mess around with JavaScript, ActionListeners or PhaseListeners. Just generate your URL in the *.jsp or *.xhtml file such that it specifies a backing bean, a method name to invoke as well as optional MIME type and file name.

Update:
Tim Boudreau mentions a cool technique the code above could make good use of, by relying on a general key/value parser based on dynamic proxies.

The Enum is perfect... well almost.

2008-07-01T21:55:00.000+02:00

Ok so its time to admit to something. I'm deeply in love with Java's Enum! In my opinion it was the best part of Java 5 and I still wonder why it took Sun 10 years to add this powerful static modeling construct.

The power of the Enum
Although there certainly are known limitations of the Enum, i.e. how you can't extend it, I have never run into a practical limitation myself. Until now that is. The issue I want to raise is that of Enum forward referencing.

The great Alan Turing taught us that at the end of the day, everything can be modeled by a Turing Machine and finite automata. We may not often consciously operate at this level, but many things still makes sense to model this way being it a regular expression matcher, navigation rules or similar. The Java Enum appears to be a perfectly simple, fast and type-safe way of modeling this... or does it?

State machine with an Enum
Since the Java Enum effectively is just a group of static class instances, it allows us to attach methods and state to each static instance. We should be able to use this fact to express a transitive relationship with outself. To model a CD player, we'd write something like this:



public enum PlayerState {
   STOPPED(PlayerState.PLAYING),
   PLAYING(PlayerState.STOPPED, PlayerState.PAUSED),
   PAUSED(PlayerState.PLAYING, PlayerState.STOPPED);

    private final EnumSet<PlayerState> transitions;

   PlayerState(final PlayerState... transitions){
        this.transitions = EnumSet.copyOf( Arrays.asList(transitions));
   }

    // State transition and query logic below...
}

Except that won't compile! The compiler complains with an "illegal forward reference" error. I can understand why it's the easiest to simply not allow this circular use case, but considering everything else in Java allows forward referencing (i.e. we don't need header files as in C++) it would've been nice if that was the case with Enum's too. The JLS simply states:

"It is a compile-time error for the constructors, instance initializer blocks, or instance variable initializer expressions of an enum constant e to refer to itself or to an enum constant of the same type that is declared to the right of e"

Granted, it has been some years since my last compiler course but I can't see any reason not to allow forward referencing in this particular case where everything is known. I suspect the culprit simply being that Enum, as with so many other things, was added later using only existing features such as not to change existing initialization rules of the JVM.

NetBeans plugin: Special copy/paste

2008-05-14T19:57:00.000+02:00

The very little I've had to paste code into this fairly new blog, was enough to give me the idea of creating an extension to NetBeans which would help to remedy this formatting nightmare. Now, in my world, there's approximately a 100:1 ratio between idea and actual realization, so I'd have to salute the awesome OpenIDE API's for making this possible spending just a few late nights and taking just 200 lines of code. Without further ado, I present, my first NetBeans plugin.

Special copy/paste
The plugin will add a couple of new actions to the context-sensitive popup-menu of the source editor, which will allow you to copy the selected text as preformatted HTML, as well as a CSS version which will preserve the formatting used in NetBeans.

Using the "Copy as HTML and CSS" menu as in the above screen dump will result in you being able to paste it directly into a website/wiki/blog and have it display like this:


    /**
    * @param args the command line arguments
    */
    public static void main(String[] args) {
      // TODO code application logic here
    }

For a larger example of what the output of the plugin looks like, take a look at the plugin's own source code.

It's supposed to be language agnostic, in that it should work with all types of sources NetBeans is able to tokenize. The plugin will try to mimic the formatting of the tokens in regard to font family, keyword and literal colors. It will however *not* be able to show member-wide variables in green as NetBeans does nor show method and class decelerations in bold. This is a limitation caused by the fact that I am only using the NetBeans lexer API rather than doing any kind of semantic analysis or parsing.

If you want to give the plugin a try, download it from NetBean's Plugin Portal. Source code is available here.

Update:
It has been made clear to me through the comments, that NetBeans already contains functionality to extract source code as HTML. You can find the feature in the "File" menu under the ill named item "Print to HTML". Since it would appear other people than just me did not associate "print" with that of exporting HTML content, I have filed an issue for the relocation and/or renaming of this.

Keurig Platinum B70

2008-05-09T20:44:00.000+02:00

Time to try to live more up to the name of this blog. As most developers, I have a passion for coffee and coke and consume it in quantities which are probably not on the healthy side. Anyway, when I saw the Keurig Platinum B70 coffee maker in action, I absolutely had to own one. Why? Take a look below.

Yup, it takes 45 sec. for it to brew a large cup (4 sizes to choose from) of fresh programmer oil, has a very gadgety blue light and is ready to serve its master 24/7. It probably isn't the most economical way to get your caffeine dose, but it does allow for a small filter so that you can use normal coffee beans rather than the convenient K-cups. Also, it came with samples of Van Houtte's Kenyan Kilimandjaro roast, so now I know why Stephen Colebourne named his OpenJDK sandbox Kijaro. ;)

Type registry strategy pattern

2008-05-07T21:30:00.000+02:00

One pattern that I have often seen applied in Java, is the one where you plug-in and register a handler for a given type of object to thereby supply a specific behavior for it. For instance, this is often used in order to render, edit and validate elements of various visual components in Swing, such as the JTable. I am unaware of any official name for this mechanism, but it appears to be a combination of Martin Fowlers Registry Pattern and the GoF Strategy pattern so I like to think of it as the Type registry strategy pattern.

Legacy example
Conditional behavior is encapsulated by some common interface, which provides the mechanism for dispatching to elsewhere, responsible for applying a concrete strategy. An example is this format handler, which allows an object to be formatted as a String:


1  interface Handler
2  {
3      String format(Object object);
4  }

And an API, capable of associating handlers for various Object types registered and dispatching to these:


5  class SomeAPI
6  {
7      Map handlers = new HashMap();
8
9      public void installHandler(Class clazz, Handler handler)
10     {
11         handlers.put(clazz, handler);
12     }
13
14     public String format(Object obj)
15     {
16         Handler handler = (Handler)handlers.get( obj.getClass() ); 
17         if(handler != null)
18             return handlers.format( obj );
19         else
20             return obj.toString();
19     }
20 }

This way, we can supply an API with an implementation (in the following example, an anonymous inner class) of formatting behavior for a given Object type, i.e. a Date:


21 someApiInstance.installHandler(Date.class, new Handler(){
22     public String format(Object obj)
23     {
24         Date date = (Date)obj;
25         return SimpleDateFormat.getInstance().format(date);
26     }
27 });

This works fine, but it's a little verbose and not particular type-safe. I wondered if I could device a generified version which improved on this. After all, we KNOW that the object passed is an instance of Date, we just need to convince Java of this as well.

Generified type strategy
Like many others in the Java space, I am not super comfortable nor experienced with generifying methods and dealing with use-site covariance. So in order to work out the following, I got some much appreciated help from the usenet group comp.lang.java.help.

Take one
First things first, the required changes to the callback interface is pretty obvious. We now simply declare our Handler to be of the type T, for which it has a format method accepting an instance of this type:


28 interface Handler<T>
29 {
30     String format(T object);
31 }

Now comes the tricky part. We need to have the compiler able to infer the type we provide, that is, apply some wildcard capturing magic. Our map now maps unknown Class types to an unknown Handler type. The installHandler method makes use of this, and associates an unknown Class type with a Handler of type T. We capture the type of the Handler in the format method, by casting to any type that is a super type of T:


32 class SomeAPI
33 {
34     Map<Class<?>, Handler<?>> handlers = new HashMap<Class<?>, Handler<?>>(); 
35
36     public <T> void installHandler(Class clazz<?>, Handler<T> handler>)
37     {
38         handlers.put(clazz, handler);
39     }
40
41     public <T> String format(T obj)
42     {
43         Handler handler<? super T> = getHandler(obj); 
44         if(handler != null)
45             return handler.format( obj );
46         else
47             return obj.toString();
48     }
49
50     @SuppressWarnings("unchecked")
51     private <t> Handler<? super T> getHandler(T obj)
52     {
53         return (Handler<? super T>) handlers.get(obj.getClass());
54     }
55 }

This allows the type to flow all the way out through the callback, such that we may implement it as follows:


56  someApiInstance.installHandler(Date.class, new Handler<Date>(){
57         public String format(Date obj){
58             return SimpleDateFormat.getInstance().format(obj);
59         }
60 }

Voila, no more casting needed. :)

Take two
Now, the observant reader will notice that while we got rid of the casts, we still need to supply the type twice, once as class literal (the key of the internal map) and secondly as the type of the Handler (the value of the map). I was not sure if this could be done, given Java's generics by erasure. But it turns out that the type information actually is saved as meta-data, in order for reflection to still be possible:


61     public <T> void installHandler(Handler<T> handler) 
62     {
63         callbacks.put(extractGenericType(handler), handler);
64     }
65
66     private <T> Class<T> extractGenericType(Handler<T> handler)
67     {
68         Type[] interfaces = handler.getClass().getGenericInterfaces();
69
70         for(Type type:interfaces)
71             if(type instanceof ParameterizedType)
72                 return (Class<T>)
                           ((ParameterizedType)type).getActualTypeArguments()[0];
73
74         throw new IllegalArgumentException ("You must supply a generified Handler
                    with a single parameterized type");
77     }

It's not pretty and generally makes everything a bit more fragile, but it sure makes for a nice public API for your consumers:


78  someApiInstance.installHandler(new Handler<Date>(){
79         public String format(Date obj){
80             return SimpleDateFormat.getInstance().format(obj);
81         }
82 }

The issue of erasure
While the parameterized type of the Handler can be uptained through reflection, as shown in the previous example, it isn't actually available at the core of the type system. For a demonstration of this, imagine your consumer of SomeAPI tries to implement several formatters:


83 public class Formatter implements Handler<Date>, Handler<Calendar>
84 {
85     public String format(Date obj){
86              return SimpleDateFormat.getInstance().format(obj); 
87     }
88
89     public String format(Calendar obj){
90              return SimpleDateFormat.getInstance().format(obj.getTime()); 
91     }
92 ...

This code won't compile, for the simple reason that during compilation, the parameterized types with Date and Calendar are lost and both resolve to the same Handler interface, and you are of course not allowed to implement the same interface twice (one of the reasons for why delegates exists in C#, but that's another story).

I'll try to make more use of this type-safe way of applying composition to factor away centralized conditional complexity. And it should be interesting having it work together with the service provider pattern.

Update
It turns out there's a trick to get rid of the unchecked cast in the SomeAPI class. The trick is to use a dynamic cast to make up for a limitation in the Java type system and is mentioned in Joshua Bloch's Effective Java Second Edition, item 29.

@SuppressWarnings values

2008-05-02T14:32:00.001+02:00

Meta-data and how to associate it has always been a bit of a confusing topic in Java. For instance, the transient modifier is really a kind of marker annotation, as is the @deprecated javadoc tag compilers are also required to process, as is the marker interface Serializable. Then in JDK 1.5, a dedicated annotation facility was added, probably in light of the success of C#'s attributes. One of the first practical uses of annotations appears to be as a way to suppress compiler warnings.

@SuppressWarnings
This build-in annotation allows the developer to signal a respecting compiler that it should forgo a particular warning. It can be applied in front of a type, a field, a method, a parameter, a constructor as well as a local variable. It is up to the compiler to make sense of whatever you put inside the String, the only value mandated by the JLS is the "unchecked". Compilers as well as IDE's will typically implement each their own set of warning types, the Eclipse IDE defines far more of these than NetBeans does for instance.
Here I will only cover the ones supported by the SUN compiler. To see the supported types, issue a "javac -X" command. On my JDK1.6.0_03 system I get:


-Xlint:{all,cast,deprecation,divzero,empty,unchecked,
fallthrough,path,serial,finally,overrides}

Of those ones, "all", "empty", "path" and "overrides" doesn't seem to have any effect when using the SUN compiler or when used inside NetBeans. The following lists the remaining ones and how to use them.

@SuppressWarnings("deprecation")
Use this when you are deliberately using a deprecated method, realizing full well that your code might one day break, but you do not wish to be notified of this. In the following example, we use getYear of java.util.Date which has been deprecated:



   @SuppressWarnings("deprecation")
    public void suppressWarningsTest()
    {
        Date date = new Date();
        int year = date.getYear();
    }

Without suppressing the warning, the compiler (if invoked with -Xlint:deprecation) would've complained:


warning: [deprecation] getYear() in java.util.Date has been deprecated
       int year = date.getYear();

@SuppressWarnings("unchecked")
Java 1.5 brought a crippled, but mostly working generics facility into play. This of course vastly improves type-safety. However, you often need to mix non-generic and generic types and this usually provoked the compiler into complaining. Take the following example:



   @SuppressWarnings("unchecked")
   public void uncheckedTest()
    {
        List nonGenericStringList = new ArrayList();
        nonGenericStringList.add("Some string");
        List<String> genericStringList = (List<String>)nonGenericStringList;
    }

Without suppresssing the warning, the compiler (if invoked with -Xlint:unchecked) will complain with something like:


warning: [unchecked] unchecked call to add(E) as a member of the raw type java.util.List
nonGenericStringList.add("Some string");
warning: [unchecked] unchecked cast
    found : java.util.List
    required: java.util.List
List genericStringList = (List)nonGenericStringList;

@SuppressWarnings("fallthrough")
Java has always followed the C-style of switch statements, where you need to explicititly break out of a switch unless you wish to simply fall through and execute the code in the case below. This can be dangerous of cousee and errors of this kind can be very hard to track down. In the following example, case 1 lacks a break:



    @SuppressWarnings("fallthrough")
    public void fallthroughTest(int i)
    {
        switch (i)
        {
            case 1:
                // Execute both 1 and 2
            case 2:
                // Execute only 1
        }
    }

Without suppresssing the warning, the compiler (if invoked with -Xlint:fallthrough) will complain with something like:


warning: [fallthrough] possible fall-through into case
         case 2:

@SuppressWarnings("serial")
To ensure a serialized class is consistent with how the Java runtime perceives this object (based on its class definition), it is important that serialVersionUID be present. In practice, most people rely on the compiler to insert an appropriate UID:



    @SuppressWarnings("serial")
    class Serialest implements Serializable
    {
    }

Without suppressing this warning, the compiler (if invoked with -Xlint:serial) will complain with something along the following lines:


warning: [serial] serializable class SerTest has no definition of serialVersionUID
    class SerTest implements Serializable

@SuppressWarnings("finally")
Since try-finally blocks are really glorified goto instructions, the compiler can be instructed to complain if it sees a violation of "good practice" when it comes to execution flow. In the following example we issue a return from within a finally. The compiler allows this, since the JLS specifies a finally clause will always get executed, but realize that any exception thrown in the try may be completely disregarded:



    @SuppressWarnings("finally")
    public String finallyTest(String str)
    {
        try
        {
            str+=".";
        }
        finally
        {
            return str.toUpperCase();
        }
    }

Without suppressing this warning, the compiler (if invoked with -Xlint:finally) will complain with something along the following lines:


warning: [finally] finally clause cannot complete normally

@SuppressWarnings("divzero")
This can be used to catch explicit integer division by 0. It should be default in my opinion, since the compiler KNOWS that executing the code will always result in a a java.langArithmeticException. The annotation has no effect on double's or float's, since these can represent infinity:



    @SuppressWarnings("divzero")
    public void divzeroTest()
    {
        long l = 12l/0;
    }

Without suppressing this warning, the compiler (if invoked with -Xlint:divzero) will complain with:


warning: [divzero] division by zero
       long l = 12l/0;

IDE's
I reckon most people do not mess with the compiler and supply -Xlint flags, but use the facilities of their IDE. NetBeans allows you to see all (+more) warnings as hints in the gutter section of the editor. You can tweak this to your liking, by going in the options.

NetBeans supports a few more values, namely "empty-statement" and "cast". But that's nothing compared to Eclipse, which supports "unused", "empty", "UnusedAssignment", "UnusedDeclaration", WeakerAccess", "autoboxing" and many more.

Update
Should you be using NetBeans 6.1 or later, I have created a small plugin to assist in the code completion and documentation of these values. You can read more about that here.

Worst travel experience ever

2008-04-14T20:12:00.000+02:00

Friday I was suppose to go to Montreal, the usual route over London Heathrow. Slightly concerned with the recent mishaps of the new Terminal 5, I actually managed to get to the good old Terminal 4 without much trouble. Little did I know, my trouble were just about to start.

Canceled flight
Yup, just 1 min. after entering Terminal 4 I learned that BA95 to Montreal was canceled. Inquiring at the help desk I experienced the deja-vu of being told that I had to go fetch my luggage, contact the ticket office and expect a layover. I had experienced another layover about 2 years ago so I pretty much knew what has coming... or so I though anyway.

Heathrow, JFK or Newark
My luggage was nowhere to be found, so I proceeded to the ticket counter and when it was my time to be served I was presented with the option og taking the same flight tomorrow, go to JFK in New York and a very short layover involving an early flight or go to Newark in New York and a longer layover involving a later flight. I thought the Heathrow option would take too long (tried that before btw.), that the JFK option would be too hectic so I opted for going to Newark. With a couple of new tickets in my hand, I rushed to check in and to my gate and soon was on the way across the Atlantic - towards Newark.

The American greeting
After setting the right check marks documenting that I am not a terrorist, have never been deported from the US and a bunch of equally ridiculous questions I landed around 22:30 and was provided a few notes by ground personnel. One note said my luggage had not made it there and another provided me with a hotel voucher for "Newark Airport Hotel". This was expected, so I began to make my way out of the airport. The initial customs check went fine, they just wanted the usual prints and photo. However, prior to exiting the secure area there was another individual collecting customs cards. The guy took a quick look at mine and asked where my luggage was. I replied that I was in transit so the backpack was all I had. As if he didn't hear me, he asked the same a second time only more aggravated. I then tried explaining that my original flight had been canceled so my luggage was somewhere between London and Montreal. That seems to have made him even more mad, and now raised his voice considerably and said that he had been working there for 13 years and bla... blah. I did not know quite how to react, but realized that I was now in the country where I could be held back, tasered etc. without that being particularly unusual. So I tried once again to explain myself. He must have gotten tired of me, because he then waved me off and I could walk in to the land of the free with a sigh of relief.

A ghost airport
I now just wanted to find my hotel so I could grab as much sleep as possible before the next morning. But that proved to be quite difficult. It was apparently too late in the evening for any information people to be working, so all I could find were the occasional passenger like myself, janitor/cleaning personnel and suspicious looking people.
Newark airport is a bit like a maze. Rather than having a large open space where you can get an overview from a far and navigate your way like London or Amsterdam, Newark consists 5-6 split-levels which reminded me of a mall more than of an airport. It took me 30 min of walking around to realize that I was not going to find anyone who knew about "Newark Airport Hotel" or signs to help me. Eventually, I was able to find the British Airways check in counter located at the lower level (basement) but it was as abandoned as everything else. Not far from the counter however, a woman was located behind a counter so I decided to ask her. She kept asking "which one?" when I mentioned "Newark Airport Hotel". So I tried showing her my voucher which didn't really say anything else, but she either refused or just couldn't see it. I asked what I was to do, as a passenger in an airport which for all practical purposes was sleeping. She then got very defensive and said she couldn't help me if I was going to be like that. I might have sound frustrated, but I don't know what else could be expected of me... in any event, I apologized and asked her again, this time putting extra effort into not sounding tired or irritated.
She advised me to contact British Airways. I told her I had failed at locating anyone else than her, let alone British Airways staff. She pointed to a woman behind the BA counter and said "There's one right there". I told her that was a cleaning lady, which made her stand up and yell "Are you cleaning?" to which a mute "Yes" was returned. She then told me she saw BA personnel enter the door in the back so advised me to go knock. Knocking and a brief conversation earned me a photocopy of a poster for "Newark Airport Hotel" with a picture and address, but most importantly of all, the tip that all hotel shuttle buses leave from parking area P4.

Newark Airport Hotels
A quick train ride later I arrived at P4 and started investigating which shuttle bus I needed. There were a bunch of buses arriving and leaving constantly, and a list of about 20 hotels in the vicinity. It quickly became clear to me, that the vast majority of the hotels referred to themselves as Newark Airport Hotel. When a shuttle bus arrived 15 min later, saying Newark Airport Hotel in capital and Sheraton after, I thought that might be it. I showed the driver the picture of the hotel I had and asked if this was the hotel he was going to, but there was no answer. So instead I asked, is this the Sheraton hotel? He answered yes so I quickly got in. As soon as we were on our way, I realized he COULD have misunderstood me as asking if he goes to the Sheraton hotel. It later became clear that indeed it was not the Newark Airport Hotel I was looking for. I asked if they recognized the hotel in the picture, and they thought it looked like the Renaissance. So I went out in front again and started waiting in front of the two mini-buses parked with the engines running. After about 15 min. a guy came and asked if I was waiting for the bus. He agreed to take me back to P4. I was back at P4 around 00:30 and started investigating hotels again, this time I noticed a picture of the Renaissance and made a call for a shuttle. It arrived about 10 min. later and I finally thought a comfortable bed was within reach. When I arrived and was told by the lady at the front desk that everything was sold out, I did not know whether to laugh or cry.

Classic yellow cab
The lady informed me that no hotel in the vicinity had any available rooms, but that she could call their sister hotel in Springfield about 20 min. away, only, I had to pay cash because they did not accept my voucher. I was drop dead tired, with no intention to spend the night in the insecure part of the ghostly Newark Airport so I accepted her proposal and thought I would simply have to try and get British Airways to give me a refund later. The lady was nice, clearly felt bad for me because she gave me an apple and a soft drink while I waited for the cab.
The cab arrived and I got in on the backseat as I've seen is the custom in the US. And sure enough, a thick Plexiglas window separated me and the driver. It started pouring down and we slowly made out way... somewhere unknown. I could hear the cab radio, in typical big city jargon, talking about whether the police had arrived yet. After about 20 min. I started getting worried, I really did not want to get too far from the airport, also knowing there would be a bill to pay. But we soon arrived so I fetched my Visa card and gave it to the driver through the little door in the protective glass. But his card sweeper didn't work, after many attempts on both my Visa and MasterCard he gave up and called his boss. They were annoyed at each other, obviously not agreeing on whether it was the card or the machine that didn't work. Eventually he handed the cellphone to me and I provided his boss with my Visa detail and that was the end of that - 55$ but no receit.

Springfield Holiday Inn
Not exactly the Hilton, but after paying 144$ I was just glad to have a bed within reach. I slept about 4 hours that night and got up around 6 such as to try and make my way back to the airport and resolve the various issues that had piled up. I got the hotel to call me a cab and not long after a large black car pulled up. Apparently that was the taxi, I couldn't help wonder whether it was a limo service or perhaps a pirate-cab but I went along. Unlike the night before, this chap was very chatty. The driver was originally from Egypt and as soon as he learned I was from Denmark he wanted to discuss the Muhammad drawings. Not knowing where exactly he was taking me, and wanting to remain on friendly terms, I adopted an unusually confrontationless style of argumentation trying to convince him that Danes do not intentionally want to mock or make fun but that religion isn't really particular important to us and that Denmark is a little isolated/ignorant up there in the north. I certainly was not going to say that by all accounts, Muhammad would qualify as being called a pedophile and that the current problems comes from the more moderate Muslims not taking a stand against the primitive head-chopping Shari Muslims.
On the way I noticed the guy had no taximeter and when he said he couldn't take credit cards I got convinced he was a pirate-taxi. I proposed that we go find an ATM right inside the airport but he refused, claiming he could not park there. So we went to the Hilton hotel which was close by, he asked how much I had payed the night before. I quickly realized he was going to use that as a benchmark to charge me, so instead of 55$ I said 45$. And sure enough, he required 60$. Had I said 55 he would probably have said 70$.

Bye bye US
I went to the British Airways check in counter from last night and get a hold of someone, explaining my situation and that I would like to have a refund. They were very understanding, almost puttied me, but were confused as to how to resolve the matter. So we agreed it would probably be best if I pursued it at my end destination Montreal. I quickly made my way to Terminal A and within long was on the way to Montreal. When I arrived in Montreal, my luggage was not there (really, I was not expecting that after all that happened) so I tried to find British Airways missing luggage personnel... with no success. I went to the Air Canada counter instead, since my last flight was actually operated by Air Canada. And sure enough, the guy there informed me that my luggage had just left London on the way to Montreal. I've had delayed suitcases many times before so that didn't really concern me much, I filled out a report and hurried out. Then I tried locating British Airways personnel at a ticket office or checking counter, to try and make my case of getting a refund. The time now was around 13:00 and at the counter all I saw was a sign with the opening hours saying they open at 16:30. Not wanting to wait 3½ hour just to complain, I left and planned on making my case another way. I received my luggage the day after.

The moral of the story
I am sure this will be yet another laughable experience eventually, but for now it is still a little too close for comfort. I have definitely had enough of American "hospitality" as well as London's Heathrow airport. I am now more sure than ever that it's worth it paying more for a ticket going with KLM (my preferred airline).

Know thy acronyms

2008-04-07T23:53:00.000+02:00

Maybe it's caused by the passing of time, maybe it's because of its open nature or maybe it's simply because people like to make them up. In any event, few technologies in computing are as littered with acronyms as Java is.

Just for fun, while eating lunch (yeah I know it's bad habit) I compiled a list off the top of my head of what an average developer might be subjected to, when tracking technologies in the Java space.

AWT - Abstract Window Toolkit (UI)
BGGA - Gilad Bracha, Neal Gafter, James Gosling, and Peter von der Ahe (Closures)
CICE - Concise Instance Creation Expressions (Closures)
EAR - Enterprise ARchive (Packaging)
EDT - Event Dispatching Thread (Lingo)
EJB - Enterprice Java Beans (Packaging/technology)
FCM - First Class Methods (Closures)
JAR - Java ARchive (Packaging)
JAX-RPC - Java API for Xml-based Remote Procedure Call
JAX-RS - The Java API for RESTful Web Services
JAX-WS - Java API for Xml-based Web Services
JAXB - Java Archtecture for Xml Binding
JAXP - Java API for Xml Processing
JCK - Java Compatibility Kit
JCP - Java Community Process
JDBC - Java DataBase Connector
JDK - Java Development Kit
JDO - Java Data Objects
JDOM - Java Document Object Model
JEE - Java Enterprise Edition
JLS - Java Language Specification
JME - Java Micro Edition
JMM - Java Memory Model
JMS - Java Messenging Service
JMX - Java Management Specification
JNDI - Java Naming and Directory Interface
JNI - Java Native Interfacing
JNLP - Java Network Launch Protocol
JPA - Java Persistency API
JPQL - Java Persistency Query Language
JRE - Java Runtime Environment
JRO - Java Runtime Object
JSE - Java Standard Edition
JSF - Java Server Faces
JSP - Java Server Pages
JSR - Java Specification Request
JSTL - JavaServer Pages Standard Tag Library
JTA - Java Transaction API
JTS - Java Transaction Service
JVM - Java Virtual Machine
JWS - Java Web Start (Deployment)
JXTA -Juxtapose (Peer-2-Peer)
NIO - New Input/Output API
NPE - NullPointerException (Lingo)
POJO - Pure Old Java Object (Lingo)
RT - Runtime (rt.jar, the JRE)
SAF - Swing Application Framework (JSR-296)
SOP - System.out.print (Lingo)
SWT - Standard Widget Toolkit (UI)
StAX - Pull-parsing XML
WAR - Web ARchive (Packaging)

I have only included direct Java acronyms, not framework (Swing, Spring, Struts...), libraries (iText, JodaTime, log4j...), tools (Maven, JUnit, JMeter...) or general purpose technologies (SVN, HG, CVS...).

The amount of acronym soup is staggering. No wonder people are sometimes overwhelmed.

C# type inference

2008-03-31T00:16:00.000+02:00

While I work mainly in a Java shop, I continue to be impressed by what Anders Hejlsberg, chief architect of C#, brings to the table to a language which in my mind has always represented Java done right. I do wonder however, how come they did not take the concept of type inference just a little bit further.

Local variable type inference
This feature of C# 3.0 basically allows you to omit the declaration which, especially when generics is involved, causes a lot of repetition and long lines of code:


Dictionary<int, IEnumerable<decimal>> myCollection =
        new Dictionary<int, IEnumerable<decimal>>();

Which can be reduced to this:


var myCollection = new Dictionary<int, IEnumerable<decimal>>();

No late binding is taking place, the compiler simply infers the actual type and substitutes var with it.

No method return type inference?
Some languages operates with the concept of tuples, a way of returning multiple values without having to wrap them in an array and use casting or a predefined data transfer object. Wouldn't it be nice, if we could use type inference here instead to be able to return multiple values from one invocation - and still be type-safe about the whole thing:


var getInferredType()
{
    return new {X = 22, Y = -3};
}

var coordinate = getInferredType();
Console.WriteLine(coordinate.X);
Console.WriteLine(coordinate.Y);

Perhaps this isn't doable for reasons of method signature lookup or polymorphism rules, I don't know. But it strikes me as something that would be very usefull and further reduce the need of temporary housekeeping objects.

Java Puzzler: How low can you go?

2008-03-10T23:26:00.000+01:00

Any seasoned Java developer would know of the seminal books Effective Java and Java Puzzlers by Joshua Bloch. The latter covering pitfalls and corner cases of the Java language, listing some 95 different examples of traps to watch out for in your daily work.

Java puzzlers
While a great read for toilet visits, unlike Effective Java, I don't consider Java Puzzlers particularly essential material to know as a developer. Not because there isn't anything to learn, but because there are many other pitfalls of the language not mentioned which you are just as likely to encounter before many of the exotic ones mentioned in the book. I recently ran into another one of this kind, which I will now describe.

How low can you go?
Take a look at the following snippet, which is a more flexible version of Math.max() which tries to find the largest Double in an array:


System.out.println( max(0.0, -1.0, -2.0) );

public static double max(double... candidates)
{
   assert(candidates.length > 0);
   double knownMaxValue = Double.MIN_VALUE;
   for(double candidate : candidates)
       if(candidate > knownMaxValue)
           knownMaxValue = candidate;
   return knownMaxValue;
}

What do you think will be printed to System.out? Hint: No, it doesn't have anything to do with autoboxing this time around. Scroll down to read on...

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

Well, I would expect 0.0 to be printed, but instead 4.9E-324 is. That's because Double.MIN_VALUE yields 4.9E-324, the smallest *positive* number. So when we initially assign it to knownMaxValue, thinking it represents the smallest possible value, the net effect is that candidate values less than 0 are not considered at all.
To get the expected behavior, you instead have to initialize with -Double.MAX_VALUE to get the actual smallest number including negative numbers which yields -1.7976931348623157E308.

Justification
You may argue that this is fully specified in the JLS and documented in the JavaDocs, which is true. The JavaDoc for Double states "A constant holding the smallest positive nonzero value of type double". However, I'd consider this to be an extremely easy trap to fall into as it completely defies logic and common sense. Javascript not surprisingly follows the Java definition of Double.MIN_VALUE while more modern languages such as C# defines it the way most people would expect, including negative numbers.

The above puzzler could also have dealt with problems associated with the abnormal signed definition of a java.lang.Byte, or the treacherous scale semantics of a java.math.BigDecimal.equals()or... well you get the idea when I say there are a fair share of puzzlers out there not officially declared so.

Gee... Another one?

2008-03-04T18:56:00.000+01:00

Hey everyone and no one! Like so many others, I've decided to start my own blog.

Up until now I've just been an avid participant in various forums, blogs and communities with all the problems associated with that. It's my desire with this blog to be able to write my opinions without having to conform to established or expected perspectives which sometimes gets me into trouble.

I will also use the blog as a personal wiki, an institutional memory and a communication medium, which may or may not be of interest to others. The content will probably revolve mostly around software engineering and associated technical issues, but I reserve the right to use it as a venting space for whatever comes to mind.