Stuart Miller

Disabling the mouse whilst typing in Linux

2013-03-31T22:17:00.001+01:00

I don't know why this isn't turned on in every distro by now, but the magic incantation to fix the annoyance of accidentally clicking the mouse with your palms while you're typing is:

syndaemon -d -k -i 0.5

The options are: run as resident (-d), ignore modifer keys (-k, so you can still ctrl-click), and wait for half a second before enabling the mouse again (-i 0.5).

Close Shared SSH Connections Manually

2013-01-25T11:56:00.001+00:00

Most of the time shared SSH connections are great. They speed up connecting to your frequent servers enormously.

Occasionally though, you may need to stop it (for example, you need to create a new connection with X forwarding). To do this, use ssh -O stop <hostname>.

Via StackOverflow

Making Mistakes in Git

2013-01-09T16:17:00.000+00:00

I wanted to make a couple of changes to an open source library that was based on GitHub. I had made a contribution to another library before, but I didn't really do it properly. This time, I was definitely going to do it right. Here's what I learnt.

Start and End with a Branch

I thought I was being good with my git branch foo, git checkout foo skills. While I was diligent in committing to my local branch, when I was finished I merged it into my master and pushed from there.

Pro tip: git push foo origin after you've finished working in your branch.

Doing this means you can open a shiny pull request with only your change in it.

Creating Remote Branches from Locally Merged Branches

Firstly; give up on your local branch. Seriously -- delete it using git branch -D foo. Also make sure you haven't got an existing remote branch (if you do, get rid of it using git push origin :foo).

Then recreate your local branch, and use the magic git rebase -i HEAD~5 (where 5 means get the last 5 commits). This opens an editor where you can delete the commits you don't want to appear in the branch.

Once you've done this, you can git push foo origin, and you'll have a beautiful remote branch all set up for a pull request.

Performance Monitoring in Solaris

2012-11-08T11:02:00.002+00:00

If you're unfortunate enough to use Solaris in production, you can at least console yourself with some of the excellent performance monitoring tools the OS supports. We recently had some performance issues which we needed to diagnose on a production server -- i.e. no profiler.

top == prstat

Your first point of call for CPU monitoring is normally top, which doesn't exist on Solaris (of course). Use prstat instead. It's basically the same in terms of information.

Individual Java Thread Monitoring

prstat has another trick -- you can use it to get an individual breakdown of the threads in your process. Use:

prstat -mvL -p <processid>

To get output like:

   PID USERNAME USR SYS TRP TFL DFL LCK SLP LAT VCX ICX SCL SIG PROCESS/LWPID 
  2108 stuart   1.7 0.0 0.0 0.0 0.0  98 0.0 0.0   5   2   5   0 java/52
  2108 stuart   0.0 0.0 0.0 0.0 0.0 0.0 100 0.0 100   0 100   0 java/18
  2108 stuart   0.0 0.0 0.0 0.0 0.0 0.0 100 0.0  50   0  50   0 java/28
  2108 stuart   0.0 0.0 0.0 0.0 0.0 0.0 100 0.0   5   0   5   0 java/21
  2108 stuart   0.0 0.0 0.0 0.0 0.0 100 0.0 0.0   5   1   5   0 java/8
  2108 stuart   0.0 0.0 0.0 0.0 0.0 100 0.0 0.0   1   0   1   0 java/20
  2108 stuart   0.0 0.0 0.0 0.0 0.0 100 0.0 0.0   2   0   2   0 java/85

man prstat will explain what the columns mean. The individual threads are in the last column; you can get out a stack trace from them via pstack. In this case, I could run pstack 2108/52 to see what the top thread looks like:

-----------------  lwp# 2108 / thread# 52  --------------------
 fc829624 * *com/sun/org/apache/xml/internal/dtm/ref/dom2dtm/DOM2DTM.nextNode()Z [compiled] 
 fc2c5bb8 * *com/sun/org/apache/xml/internal/dtm/ref/dom2dtm/DOM2DTM.getHandleFromNode(Lorg/w3c/dom/Node;)I [compiled] +50 (line 1341)
 fca4f1b8 * *com/sun/org/apache/xml/internal/dtm/ref/dom2dtm/DOM2DTM.getHandleOfNode(Lorg/w3c/dom/Node;)I [compiled] +89 (line 1409)
 fca4f1b8 * *com/sun/org/apache/xml/internal/dtm/ref/DTMManagerDefault.getDTMHandleFromNode(Lorg/w3c/dom/Node;)I+219 (line 1135)
 fca1088c * *com/sun/org/apache/xpath/internal/XPathContext.getDTMHandleFromNode(Lorg/w3c/dom/Node;)I [compiled] +6 (line 364)

IO Monitoring

This one is easy -- run iostat -xtc 1 10000 to get refreshes every second for 10,000 seconds. All these devices report how busy they are; of particular interest is the column %b, which will tell you how busy the disk is.

IO Monitoring per process

As far as I can tell, this isn't possible with the built in tools. I believe you can use DTrace and iotop, but as I didn't have enough privileges on the machine I couldn't try it.

GZipping vs Minification of JavaScript Resources

2012-09-05T17:01:00.000+01:00

A debate that pops up every so often in the office is whether minification is worth it when you have GZip available.

The short answer:

GZipping is always a good idea, and better than nothing.
Minification is always a good idea, and better than nothing.

To find this out I looked at JQuery 1.8.1 from the Google Hosted Libraries. The results:

Technique	Size (kb)
Original	256
GZip	76
Minified*	91
Minified + GZipped	33

So — you can reduce your JS (or JQuery, at least) size by three simply by GZipping. If for some absurd reason you can't GZip then you'd best at least minify, but you get the best performance by using both.

*I'm not immediately sure what tool was used for minification

How much space does a Java object use?

2012-07-25T11:36:00.000+01:00

A colleague mentioned in passing today that Java takes 128 bits to represent a 32bit integer. I couldn't believe him -- I had expected some overhead, but a ratio of 4:1? Really?

He turned out to be right. On a 32bit JVM you need 128 bits for an integer, and for a 64bit machine, you need 224 because the class pointers double in size. Ulp.

The increase in class pointer size means that code running in a 64bit JVM generally needs 70% more memory than its 32bit counterpart. There's a switch you can use on Oracle and IBM JVMs to use compressed pointers (-XX:+UseCompressedOops). I haven't found if there are any side effects to using this.

Find all this information on From Java code to Java heap: Understanding and optimizing your application's memory usage.

Deny IFrames with X-Frame-Options

2012-05-03T10:16:00.001+01:00

While researching an issue in which I was trying to prevent our login page from being displayed inside an iframe, I found a great StackOverflow question. The first answer was interesting, but the second was awesome!

Turns out you can prevent anybody using a modern browser from seeing your page in an iframe by using the X-Frame-Options header. Eric Lawrence details the various options here; for us the perfect version would be X-Frame-Options:SAMEORIGIN.

I still needed the frame-busting JavaScript for our issue (the login page was showing on a session timeout) but this header is my new best friend.

Running a webapp on Android

2011-10-22T11:12:00.001+01:00

TL;DR -- it didn't work because of code generation.

Why would you want to run a webapp on your phone?

My job is writing internally facing webapps. Recently we've been working on a fairly large refactoring of one particular one -- gutting it out and replacing it with a different technology stack, whilst ensuring the existing pages still function ok.

We're replacing Wicket with the open-source framework UtterlyIdle, which we're adding functionality to as we need it. Something we added was MD5 hashing of responses for ETag headers.

When we tested this on our production-like hardware, we were a bit upset with its performance (summary: 300ms requests for a no-content response, eventually diagnosed as network troubles). So, on the assumption that our production hardware was terrible, I decided to run the app on my phone and performance test it there.

I-Jetty

Luckily for me, there's a servlet container available for Android called I-Jetty. It installed and started just fine (kudos), but it doesn't support standard war files -- it needs what it called a downloadable webapp.

Downloadable War Files

The developers of I-Jetty have documented how to convert a war file to a downloadable webapp, but to clarify:

Extract all classes (both yours and your dependencies) into a folder. I call this the uber-jar folder.
Run dx over this directory. The arguments on the I-Jetty documentation seem to work ok, but boost the Xmx setting if you have problems.
If dx doesn't run successfully (the end of the output will mention how many errors you have), you'll need to scroll up a bit to find the last actual error. Searching for "unexpected top-level" generally finds the exception section, as it's not always near the bottom. I also had to pass the switch "--no-locals" because of my dependencies.
dx doesn't work if you have a large number of dependencies -- you end up exceeding the dalvik vm's maximum number of symbols.
The output of dx is a .dex file; zip this up and place it in your WEB-INF/lib folder.
If you have resources in your webapp, they must also be zipped up and placed in the WEB-INF/lib folder.
There shouldn't be anything else in the WEB-INF/lib folder; the I-Jetty classloader only reads zip files, so it won't hurt but it will make your war file unnecessarily large.

I had to give up on the app I was using and use a much smaller one instead. Eventually I got this into a downloadable webapp suitable for I-Jetty.

Running it

Everything looked ok to start with; however, this app uses cglib because it needs to proxy classes, not just interfaces. The first problem was java.lang.VerifyErrors -- these are a little bit opaque, as all they mean is the Dalvik VM is refusing to load a particular class. Unless you use logcat, you can't tell why.

I did use logcat, and I found the classes were not being loaded because of NoClassDefFoundErrors -- it's easy to forget the Android API isn't a complete port of Java. So, I grabbed the missing package (java.beans) from Apache Harmony, compiled it, dx'd it along with my other classes, and banished the errors.

Apart from the ones from cglib. Cglib generates bytecode, you see, and it currently doesn't know how to generate Dalvik bytecode. Android doesn't support it.

Conclusion
You should be able to run a war file on Android (and I did) -- but if it needs cglib like mine did, you're out of luck. Oh well.

Introduction to Mercurial

2010-11-17T21:17:00.003+00:00

Hands up if you've been happily using Subversion for many years when some crazy dude comes in and makes you use Mercurial. Anyone? I'm sure it can't just be me.

Anyway, Mercurial is very different to Subversion. I recently found out that Subversion causes brain damage in developers which makes it very difficult to understand how Mercurial works: you try to do things in Mercurial the way you do in Subversion, it doesn't work and you go "ARGH" and rm -rf your repository and start again (being more careful this time).

Well, rm -rf no longer my friends. Joel Spolsky has written a rather excellent introduction to Mercurial which I would recommend you all read if you need to use Mercurial or you're sick of merging in Subversion. I especially appreciated the first page -- Mercurial for Subversion users -- basically a pep talk telling you not to give up on Mercurial just because it's not Subversion.

My take on Mercurial? As far as I can tell, its view of the world is identical to the one I end up drawing when I try to map out how I think Subversion should be working. Instead of representing your codebase as a series of snapshots in time, it represents the changes you make to it. This makes it very easy to merge different branches together, which is pretty much the most painful thing you have to do in Subversion.

Joel explains it very well. Please go and read his tutorial now, if only so you're not surprised when some crazy guy makes you use it.

Ubuntu 10.10 Netbook Edition: Unity

2010-10-11T22:21:00.004+01:00

I wanted to like Unity, the new Ubuntu Netbook interface, I really did. I had seen the screenshots and the promos, and I liked the idea of a dock-like interface for launching my programs. Until I installed it.

It's slow.
I was trying this on a Dell Mini 9. It's not a new netbook, but it's Tier One supported hardware. Ubuntu itself is quick to boot -- I looked away while it was restarting and found it had booted when I looked back. Browsing seems relatively quick. Youtube videos play without stuttering.

Yet, the Unity interface has got to be the slowest way of launching programs on my netbook. When I click them, I'm never sure if I did it successfully because it takes so long to load them.

Weirdly, it's worse for the built-in parts of the interface. Want to launch a program that's not in the dock? Click the Applications button, and wait while it populates the list of all your applications. Want the 'hub' (the menu that launches when you click the Ubuntu logo)? That's not instant to launch either. Overall, it's lacking the speed I would expect from a final release.

It's inflexible

The 'dock' (they don't want you to call it one) is always there. You can't hide it. You can't resize it. It's a permanent fixture of your screen, so you'd better learn to love it.

One of the ideas of the dock placement down the size is that it saves vertical space, which on a netbook is more precious than horizontal (more vertical space means less scrolling). Unfortunately, it also means you have less horizontal space, meaning the space available to my browser is less than the 1024 pixels most websites have come to expect. That means I permanently now have horizontal scrollbars which means: less vertical space. Urgh. How many netbooks have a screen resolution wider than 1024 pixels? Doesn't that mean that everybody will have this problem?

It's buggy

Once you push an application into full screen (perhaps you're sick of scrolling), the dock helpfully animates itself out of the way. When you leave full screen mode though, the icons are now halfway down your dock. Why's this? Dunno. You have to drag them back up to the top if you want to see them all.

When you open an application that's not already on your dock (and you want to put it there), you're meant to be able to right click it and add it. At least, that's what happens with the built in apps, like Solitaire. But if you install Chrome or Skype and want that? Nope, it won't work. You can't drag the icon from the Applications folder, so don't be trying that either.

And when you launch an application, its title is meant to go to the top frame. In my experience, the title just disappears, leaving you with a mysterious File menu up there instead. Lucky I can tell what application is open by looking at the little arrow indicators on the dock, eh?

In Summary

Unity is not ready for the prime time -- at least not on my Dell Mini. The version of Ubuntu that came with it worked fine, albeit anciently. The latest version also ran acceptably, although it chewed the battery like nothing else. The netbook version of 10.10? Well, it's barely usable. It lasted one evening before I wiped it off.

On the Oddness of javac

2010-09-22T14:07:00.003+01:00

At work recently, we had a strange problem: one of our jars was not being loaded in Tomcat. Some closer investigation revealed the all too familiar error message instructing us to See Servlet Spec 2.3, section 9.7.2. Normally I see this when the servlet api jar makes its way into lib directory by mistake (usually a poorly configured pom.xml file). However, this was in one of our jars -- and we certainly don't check in the servlet api in our codebase. What gives?

It's always Maven's fault, right?

Well, usually it is. First of all, we (rather densely) configured Maven to realise the servlet api was a provided library. About two seconds of thought showed this wasn't the problem -- the servlet classes must have been actually in our jar file.

We knew they weren't checked in, so we whacked Maven into verbose mode (mvn -X for those of you playing at home) and scanned the output, line by line. No clues there. At this point my coworker began pushing for a manual compile using javac, and after about an hour of me saying "no, it can't possibly be javac" but not being able to find the problem, I relented. (The verbose output proved helpful to get the classpath out, even if Maven doesn't print it out in the standard format.)

Et tu, javac?

We did a manual compile, and I was gobsmacked when the servlet files were in the resulting output directory. javac, which I had considered a close personal friend (except when it exhibited this bug), was the culprit. There must have been a reasonable explanation, and I was out to find it.

I headed to the javac documentation page, and it didn't take too long to find this part:

Note: Classes found through the classpath may be subject to automatic recompilation if their sources are also found.

What?! Lemme get this straight: if there are java source files in the classpath, they can be compiled and placed into the output directory? Alas, it is true. This meant that somewhere, we had the servlet source code in our classpath, and that it was newer than the regular servlet api.

GWT: Gee, What Twits

Some spectacularly 1337 searching found that GWT distributes the servlet api and sources inside its jars (note that we were using version 1.7.1. Maybe it's fixed now?)

Including somebody else's library inside yours is a really bad idea. Sure, it's convenient -- junit distributes hamcrest matchers -- but unless you also provide a version that doesn't include them (like junit-dep), your users are in for a world of hurt. If they need a different version of the library from the one you're distributing, well, they'll have to rely on the magic of the classpath to find the one they want before they find yours (and good luck with that if you're using Tomcat, which doesn't define the jar order when it loads jar files).

Lessons

Here are the lessons I learnt that day:

javac has some interesting features that you might not come across on a day to day basis.

GWT is evil.

In the end, we hacked the build file to exclude anything in the javax directory from being jar'ed up. That solved the problem, and I went home to take a long shower.

Footnote

Why didn't we RTFM and use javac -implicit:none? Cos we were using Java 1.5, that's why.

Signs your recommendations could use some work

2009-11-19T22:43:00.003+00:00

Facebook likes to recommend friends for you, and recently it started recommending actions as well. Quite often it's recommending I poke someone, but yesterday I got this:

A recommendation for Facebook: you probably don't need to remind people to catch up with their partner.

Log4J Null Pointers

2009-11-01T13:10:00.002+00:00

Sometimes you may get a strange error message in your logs coming from Log4J. Depending on what version you're using, you may get odd messages like
LogMananger.repositorySelector was null likely due to error in class reloading, using NOPLoggerRepository

If you're using an older version, you may get a NullPointerException somewhere in the Log4J bowels.

So what's happening? Basically, it's Tomcat being helpful. When you redeploy a webapp to Tomcat (perhaps by using Eclipse in debug mode, or by using the Manager webapp), Tomcat goes and clears out any static fields by setting them to null before reloading. This helps to prevents memory leaks in your webapp.

However, the order in which it does this can't be specified, and if it happens to Log4J before it does another class which uses Log4J somewhere, you can run into the situation where Log4J is essentially broken but other classes are still trying to use it. This can happen on a shutdown hook, but more commonly it'll happen because Tomcat has to use reflection to find out about fields. The associated bug for this issue has more information.

So, what can you do about it? It's actually quite easy to solve: ensure your Log4J jars aren't in your webapp's lib folder -- you could either move them to tomcat/shared/lib, or if you want Tomcat to use Log4J too, move them into tomcat/common/lib. If you're using commons-logging, move that in there too.

The issue is supposedly resolved (ie you could put Log4J in along with your webapp) with Tomcat 5.5.25+ and Log4J 1.2.15+, but I could still reproduce it with 5.5.27 and 1.2.15. I'd recommend you move them into tomcat/common/lib, if only because then you can control Tomcat's logging with Log4j.

NOTE: when you move the jar files, you'll also have to move your log4j.properties or log4j.xml. This has the (possibly welcome) side effect of having one central configuration file, rather than one per webapp.

On the Importance of Scope

2009-10-05T21:20:00.007+01:00

Those of you who know me may think I'm going to harp on about JavaScript again. No, this time it's about Spring.

Spring is good for wiring up your beans with any services it may need. You do this in XML traditionally, by declaring beans:

You can then use this bean inside other beans:

The problem is that with this bean declaration is that Spring, by default, will only make one instance of the lieschke bean. This is a problem if you need your bean to not be a singleton; perhaps if you give it a database connection which you wouldn't want it to hang onto for a long time.

The solution is the scope property. Using this property, we can say that we want a new instance every time:

All very easy and all, but why isn't it this by default?

Jonathan Coulton Playing London in November

2009-09-26T13:20:00.003+01:00

Jonathan Coulton, everybody's favourite troubadour, is playing London on 13 Movember.

I've booked my tickets, but if you want some you'd better get them soon -- there are 24 available today, but there were 49 this time yesterday!

Alan! Alan! Al! Al!

2009-08-12T21:43:00.001+01:00

Profiling in Eclipse

2009-07-04T10:08:00.000+01:00

Recently I had to analyse some code I'd written to work out why it was running so slowly. And it was running pig-in-the-mud slowly too, not just little-old-lady-going-shopping slowly. This thing was almost going backwards.

So I decided to bust out the profiler. It's my fervent belief that you shouldn't optimise code just because you think something might be slow; you have to know that it's slow. This is what a profiler excels at, and it sure beats System.out.println.

I'd previously had some exposure to JProfiler, which is excellent. Unfortunately though, it has a non-zero pricetag, which is often a barrier. I instead decided to investigate Eclipse's profiling solution.

The official one seems to be the Eclipse Test and Performance Tools Platform Project (there are others, but this one is officially hosted). This is also not a solution, because it is awful. It ran out of memory when I naively ran it with the default settings, and still ran out as I filtered the settings back to only profiling a few particular classes. In the end, the only way I could get it to work was to pare it back to only a handful of classes, which wasn't very useful.

The best solution out there is actually in NetBeans. If you hate the IDE, don't worry, you don't have to use it. Under the profiling menu, there is a command to attach to a remote process. Just fire your process up with the correct arguments -- NetBeans gives you these -- and your app will obediently wait until the profiler is started. Then you get profiling goodness in NetBeans (which works with the default settings), and the luxury of Eclipse. It's pretty much the best of both worlds, and unlike JProfiler it's free. Give it a try.

Standards

2009-06-30T22:07:00.000+01:00

I'm somewhat of a mobile network junkie. I'm on my third one now, and this is only my fourth month in the UK. This last move is due to a unfortunate situation where we had to take out another contract to get a stolen phone replaced, but that's another story.

I could never have done this back in NZ. Aside from the fact that there were only two networks when I left, they were both completely incompatible with each other. So, if I wanted to jump ship, I had to get a whole new phone.

In the UK, all the networks use GSM or one of its successors. This means that as long as I'm not tied into a lengthy contract, I can flit around them and choose whoever has the best deal. And there are plenty of deals out there; you can pay £10 and get a rolling contract that will give you 100 mins and 300 texts (you can get slightly more of one and slightly less of the other depending on which network you choose).

I can't help but wonder what the mobile situation would have been like in NZ if the networks were compatible with each other. A rumour I've heard was that when Telecom NZ were setting up their network, the government of the time forced them to use CDMA because they thought it would be better for consumers if there was more competition -- ie if they used a different technology to BellSouth's GSM.

Unfortunately, that reasoning has been shown to be wrong. The most competition occurs when there is a level playing field, as players must differentiate themselves on other grounds. This is actually a better situation for companies; they are flexible, innovative, and up for a challenge. If consumers don't like what they get from you, they can always jump to a competitor.

What I'd like you to remember is that standards, and a homogeneous culture, is a very good thing for consumers. It lowers the barrier of entry for you, the producer, and for you, the consumer. The World Wide Web is another pertinent example; it's difficult to see how it could have taken off if everyone wasn't speaking HTTP and HTML, and if consumers couldn't easily switch between browsers.

There are risks; some people like to complain about the Microsoft culture: in particular, how having a massive install base of Windows is harmful as it is easier to attack. Companies may also see locking consumers into their own proprietary technology is an advantage. While these are both true to some extent, I would argue that the benefits of standards outweigh these. Please use standards. They're good for you!

PS Some of you may be thinking "why, CDMA is a standard just like GSM". This is true; but perhaps GSM was just a little more standard than CDMA :)

What is a Browser?

2009-06-20T11:12:00.003+01:00

When you work in technology, it's sometimes hard to remember that most people don't speak the same language as you. This is a good reminder of what regular people think a browser is.

Via Mauricio Freitas

On SSDs and battery life

2009-05-03T19:25:00.000+01:00

Some time ago, the gadget websites posted a link to some empirical testing of netbook batteries. The observant reader will note that my netbook, the Dell Mini 9, fits in about halfway down the list. What's interesting about these results is that the Mini has the smallest battery capacity of all the netbooks on the list.

The Asus 1000H has double the battery capacity of the Mini, but it also has a regular hard disk. It only gets an extra 20 minutes or so of battery life (the other specifications are mostly the same as the Mini).

From this I think we can conclude that solid state drives are more power efficient than their regular counterparts in laptops. This was a common belief before an article in Tom's Hardware claimed they weren't; if we believe the results in this test, which might be a little bit more indicative of real use, rather than the tests used by Tom et al.

Late to the Party: Google App Engine

2009-04-30T20:38:00.000+01:00

One thing I always meant to try out was the Google App Engine. Now that I have a bit of time on my hands, I thought it would be an excellent time to give it a go.

If you're not familiar with GAE, it launched quite a while ago with solely Python support. Recently they added experimental Java support, with mixed feelings from Simon Phipps. I wasn't interested in the Java support -- I wanted the Python!

For a simple test case I wrote a twitter spammer -- it will ping my twitter account every time I write a new blog post. This will hopefully encourage traffic to my blog, and will hopefully be complex enough to let me try out all the main features of GAE.

One of the things I enjoyed most was the persistence model. Instead of having to define a database structure to accompany your objects, you just define your object with appropriate database strings. Your object is magically persisted when you go object.put().

Another thing I enjoyed was the templating. While the example starts you off by manually writing data out into the response, it's fairly easy to start using a template, and not that much more complex to start automatically creating things like forms.

The thing is though that these features are both provided by Django (well, the persistence model is more inspired by it). Given that the two main features I like aren't really features of GAE, what does it have going for it?

It's free
The most compelling reason to use GAE is that it's free and always available. Instead of having to pay for hosting for your Python (or Java) app, you get to run it on Google's hardware (until your app becomes too popular, when you'll have to start paying).

It has elegant cron
Cron jobs aren't really that difficult to set up in Unix, but Google's implementation is particularly elegant. You define a URL to hit, and then specify your cron pattern. I really like how they used a regular URL to implement this rather than making you define a script you want to run -- it's simple, and it works.

It's Google
Not much of a reason, I know, but while I had heard of Django I never got around to using it. GAE got me to use something I had wanted to play with not by virtue of the technology, but by its brandname. Who knows what else I'll come across in the course of developing my app that I wouldn't normally.

If you haven't had a chance to give it a whirl, I'd recommend you give it a try. Let me know what you think of the Java support.

Face Recognition in Flickr

2009-04-25T10:15:00.005+01:00

It is a truth universally acknowledged that Flickr has a load of APIs. Recently, a website named Polar Rose has emerged, which offers to run face recognition over your Flickr photos.

Note that I'm not calling it face detection, which is merely being able to find a face, but face recognition -- it should be able to know who the face is. This is quite a tough problem: I remember coding face detection at University wasn't that easy.

So, I added my photos and gave it a go. There's a processing time delay as it sucks everything out of Flickr (they estimated 30 mins for my 700 odd photos). After it's done, you get to start naming people: it pops up a face, asking who it is. When you tell it, it shows you similar faces and asks if these are also the same person.

My experience started smoothly. The first picture it chose was one of me, wearing sunglasses. Adding my name was easy enough, but then the subsequent pictures were all of my girlfriend, also wearing sunglasses. Not a good start overall.

As I kept tagging faces, I was generally impressed by the face detection. It seemed to be picking most faces, even partly obscured ones. I was less enamoured by the recognition, which seemed to find at most maybe two other photos of the same person.

Eventually though, it all got a bit silly. It kept asking me to identify people I had already said I didn't want to, and started showing faces that weren't even faces. I suggest the threshold for what is considered a face might need to be adjusted a bit higher, as by the end I was getting almost an even ratio between faces and non-faces.

Although I read it would tag my original Flickr photos with the names of the people I'd chosen, I checked the originals and couldn't see any. While I can understand this -- if you can browse pictures of people through tags on Flickr, why would you use Polar Rose -- it's a little bit sad in this era of openness.

Overall, I'd recommend Polar Rose as an entertaining way to spend a rainy afternoon. I don't think I'll be coming back frequently though; the face recognition gimmick quickly wears thin, and its accuracy deteriorates quite rapidly.

Update: if I was friends with William Shatner, I'd be in more luck.

A Keyboard Conundrum

2009-04-02T15:06:00.003+01:00

One thing you very quickly notice about life in the UK is the difference in keyboards. Although I've been here for over a month now, I still don't remember that the @ symbol is down by the semicolon instead of up above 2 (that's where you'll find the double quotation mark).

The other change I notice is that the # symbol has its own dedicated key instead of being above 3, which is where the £ hangs out (which is fairly amusing if you think about how our American friends refer to # as "pound"). This is obviously sensible, though I do wonder why they simply didn't replace $ with £ and move the former to be a secondary key, like the Euro symbol.

But I really don't understand the logic behind @ and ". My usual answerer of tricky questions, Wikipedia, is exceedingly knowledgeable about the differences between the British keyboard and what I would call 'the normal one', but is surprisingly quiet about the reasons behind the key-switcheroo.

I suspect this will remain a mystery unless I decide to fork out £32 for a copy of BS 4822, but I would love it if somebody out there could tell me why the @ symbol is in a different place on the British keyboard?

Dell Mini 9 Quick Review

2009-03-23T10:43:00.005+00:00

When Leah and I arrived in the UK, we didn't have a laptop. This made it quite hard to apply for jobs, so one of the first things we did was order one.

Our requirements were fairly simple. I didn't want to get a full-blown beast with Vista etc because Windows 7 is just around the corner, and Vista is sometimes painful to use (the observant reader will recall I have had a good experience with Windows 7). I also didn't want a desktop because we're not planning to be too settled over here, and we don't want to have to lug it around.

That pretty much left netbooks, and it just so happened that Dell had a special on. We bought the model with an 8GB SSD and 1GB RAM with Ubuntu for £189, which was £70 off. It took its sweet time arriving, but eventually a shiny new Dell Mini arrived in the mail. You can check out the unboxing pics.

The first thing you notice about the Mini is not the size -- you expect it to be small. The first thing you notice is that it's completely silent. It doesn't have any fans, and the silence is lovely.

After using it for a while, the next thing you notice is how cramped the keyboard is. The keys on it are really close together, and while the alphabet characters are ok, the punctuation keys really suffer. The apostrophe key is right next to enter, and when I go for it I often get enter instead. This makes me look really stupid on Skype. The 10" model probably won't suffer from such problems (the HP Mini has a keyboard that's 92% the size of a normal one), and eventually you do get used to it. It means though that when you use a regular sized keyboard it feels giant.

The Mini comes with a Dell custom launcher that gives you easy access to common apps. I turned it off fairly quickly; there was plenty of razzle dazzle in it, and it looks ok, but I'm quite happy with the default layout. I might turn it on again once I've finished exploring and I know which apps I normally use.

The battery life is meant to be pretty phenomenal; Ubuntu is estimating I have 4h of battery time remaining on a full charge. I'm using the wireless connection, but just surfing the web (no video or anything). So far it looks accurate.

The one really annoying thing was the trackpad. It has tap to click enabled by default, and if you don't know the magic to disable it after you press a key, you end up accidentally clicking when you go for the space bar. You can disable tap to click temporarily by using syndaemon.

Other than that, there's nothing really wrong with this netbook. It supposedly comes with a slot for a SIM card, so I'm going to pop the battery out and check if mine has one. If it does -- internet anywhere, baby!

Not Dead

2009-02-27T09:57:00.002+00:00

Just a quick note -- I know I haven't posted for a while, but it's not because I've been hit by a no. 74 bus. I've just moved from Auckland to London (via a one week holiday in San Francisco).

Leah and I have started a travelling blog to update everybody -- this is also suffering from some neglect as we're using the internet at the library -- but the address is http://leahandstuart.spmiller.net. We'll update it when we can.