The Problem

I wanted a full screen map. Like this.

But what I got was this.

It only happened when the page first opened. If I resized the window, or panned/zoomed the map, then the map redrew to fill the page.

It didn’t matter if I used GWT-OpenLayers (a Widget that wraps up the OpenLayers library) or just got at the OpenLayers javascript directly. Also, it didn’t matter which browser I used, they all drew the map in the top left-hand corner.

The Solution

The answer is to add a DeferredCommand, which updates the map once GWT has finished doing everything else. Here’s a cut-down example which uses a GWT-OpenLayers widget, but the fix works perfectly for standard OpenLayers too.

public void onModuleLoad() {

   ...

   final MapWidget mapWidget = new MapWidget("100%", "100%", config);

   ...

   mapWidget.getMap().setCenter(new LonLat(lon, lat), zoom);

   DeferredCommand.addCommand(new Command() {

      @Override

      public void execute() {

         mapWidget.getMap().updateSize();

      }

   });

}

You’re welcome to check out my onModuleLoad() method in full here.

If you’re using OpenLayers directly, you need to jump through a little extra hoop (or at least I did, there’s probably a much better way of doing it) in order to get at the javascript redraw method…

   DeferredCommand.addCommand(new Command() {

      @Override

      public void execute() {

         updateMapSize();

      }

      private native void updateMapSize() /*-{

         $wnd.map.updateSize();

      }-*/;

   });

}

CD-LabelPrint isn’t particularly sophisticated software; it just draws two circles (an inner and an outer) on top of your image of choice, showing you which bits of your image will be printed onto the disc. The inner and outer circles can be adjusted to fit your particular printable media, but you can only shrink the diameter of the inner circle down to 33mm (even though the help says the minimum is 17mm).

It turns out that you can hack a registry key to make the inner circle smaller. Just:

1. Start > Run > type regedit and click OK
2. Use the tree on the left to find: HKEY_CURRENT_USER > Software > MediaNavigation > CDLabelPrint > 1.0 > Settings > SizeAdjust > .Standard CD (12cm)
3. Double-click on Inner and change the value…

…Change the value to what? The number is 10 * the number of mm to expand the inner circle’s diameter by. I wanted a 20mm inner circle, which is 23mm smaller than the 43mm circle CD-LabelPrint uses by default, so mine’s set to -230 (note the minus sign). You might want to measure the inner circle of your printable media and adjust accordingly.

So here’s the short story – I want to use allow readers of this blog to use their Twitter credentials to log in and leave comments.

A few weeks ago, Shahid bullied me into getting a twitter account. Up until today, I hadn’t found a use for it, but this morning I wanted to post a comment on Word Aligned, and the Disqus commenting system that Tom Guest uses there lets me log in with my Twitter credentials.

This is really nice. This I like.

Why this is a good idea

Ideally, from a security point of view, you’d use strong, unique passwords for every system/website that you can log into. Of course, in practice this never happens; either you:

1. try to, but end up with so many that you forget them.
2. store all of your unique passwords in one place that becomes [almost] as vulnerable as just using one password everywhere anyway (and then find that you don’t have access to your master password file when you’re away from your home computer).
3. just use the same password everywhere.

The inherent problem with using the same password for everywhere is that every individual website that you log into stores and validates your information themselves. I have to trust every website to hold on tight to that information. I have to trust each website to not go round and try logging into all the other websites that I’ve used the same user/password combination for.

The fact of the matter is that all of those websites that are storing my username and password don’t actually need a username and password from me in the first place. All they really need to know if that I’m that same user that turned up two days ago.

This is where OpenID comes in. The basic idea is this; you have one account with one website, and only that website knows your password. Then, when other websites need to know who you are, they delegate to the OpenID provider. The first website never gets to see your password, they just turn to (e.g.) Google and say “is this joe.bloggs?” and if you’re logged into Google with your joe.bloggs account, Google says “yes”.

Why Twitter is better than Google

You could use Google to log you into other websites, but I’d rather you didn’t. Your email account is sacred. Keep it so. You can’t buy anything with your twitter account. If you forget your Credit Card PIN, you can’t get it sent to your Twitter account. Many, many websites include a “Forgot your password?” system that emails you your credentials. If someone gets into your email account, then they’re effectively a click or two away from getting into all those places too.

Much better then to use your Twitter (or wordpress.com) account to log you into these places. Sure, it means remembering two passwords (your Twitter one for your trivial stuff, your Google one for Google), but even I can just about manage that.

Enough already, let’s let people log in with Twitter

So we know it can be done, because WordAligned does it. But Tom uses Disqus, and I don’t know if I want to. Although Disqus does more good things than I need it to, it also takes away a few good things that I want to keep; for example I don’t want to lose my WYSIWYG rich-text editor. Yes, I want to outsource my user authentication, but I don’t want to outsource everything else. Yes, there may be 3 good reasons to use Disqus, but there are at least 4 good reasons not to.

I guess I ought to ask Tom what he thinks of Disqus; I mean, he’s been using it on his site for a lot longer than I’ve been looking into this. I had hoped that he’d already blogged about it, but  you (or, at least, I) can’t search his archieves, and Google can’t find anything for me either.

Not only that but Shahid hasn’t even got Twitter integrated into his site, even though he’s the one who made me sign up in the first place! And I thought these MBA-types were s’posed to be ahead of the curve…

Oh well, I guess I’m just going to have to make up my own mind.

So I think I might try Twit Connect, that in the spirit of all good things, does one thing and (hopefully) one thing well (for the record, I found out about this here, which led me to here).

Of course, now that I’m on wordpress.com, I can’t let users log in with their Twitter IDs, and I lost my WYSIWYG editor. So it’s all a bit of a moot point now. Still, at least I don’t have to keep upgrading wordpress…

class ExA extends RuntimeException {}

class ExB extends ExA {}

public class ExceptionTest {

   void doStuff() throws ExA {
      throw new ExB();
   }

   @Test
   public void whichCatch() {
   try {
     doStuff();
   } catch (ExB e) {
      System.out.println("B");
   } catch (ExA e) {
      System.out.println("A");
   } finally {
      System.out.println("F");
   }
}

What do you think the output will be? The original had multiple choice answers, but really you need to decide on two things:

1. Which catch block will catch the exception?
2. Will the finally be called?

Once you’re done thinking about that, here’s the second:

public class CollectionsTest {

   @Test
   public void listSet() {

      List<String> list = new java.util.ArrayList<String>();
      Set<String> set = new HashSet<String>();

      list.add("hello");
      set.add("hello");

      System.out.println(list.equals(set));
      System.out.println(list.contains(set));

      set.add("hello");

      for (String s : set) {
         System.out.println(s);
      }
   }
}

Again, I’ll leave out the multiple choice answers; all you need to do is work out one or more of whether:

1. The list and set are equal.
2. The list contains the set.
3. The second set.add() throws a runtime exception.
4. The set, when printed,  has one or two strings in it.

Catching exceptions

Time for some answers. The short answer is:

1. The first catch block will catch the exception
2. The finally will be called

And so the output is “BF” (except on multiple lines, obviously).

What’s your point?

If the first catch block catches the exception, then the exception type is being checked at runtime; all the compiler knows is that an ? extends ExA is going to be thrown. But that implies that exception-catching relies on mechanisms like instanceof, which we know are junk (where junk is indicative of poor software design, poor runtime performance, and probably a whole bunch of other stuff). This in turn implies that throwing exceptions is bad, and should be avoided, right? But I’ve seen people much more knowledgeable than I am post examples of exception usage that in turn allows exceptionally clean code.

I guess the bottom line, for me, is that I’d never really thought of exception handling as sharing attributes of the instanceof mechanism, and assuming that I’m even correct, I don’t think I’ll let it get in the way of me trying to write good, clean code that makes intelligent use of exceptions. The key word there being trying…

Sets of Lists and Lists of Sets

I did slightly worse with this one. The correct answers are:

1. The list and set are not equal. Lists are only equal to objects that (a) are lists and (b) have the same contents in the same order, so whilst the set passes (b), it won’t pass (a).
2. The list does not contain the set. The list contains String objects; the set is a Set. list.containsAll(set) would’ve returned true, but that’s not what we called.
3. The second set.add() doesn’t throw a runtime exception. As this set already contains the element, the call leaves the set unchanged and returns false.
4. The set, when printed,  has one string in it.

So the output is “false false hello”, although again separated by newlines and not spaces…

You’d better have something interesting to say now

I imagine that was at best light revision for most of you, and more likely tediously trivial. Putting aside the fact that I’d forgotten that lists are only equal to other lists, what I want to know is why does list.contains(set) compile? This is a post-Java 5, generic-enabled Collection. Surely the signature of contains is the same as add, and that our Set can only have Strings added to it, and therefore contain only Strings?

It does compile, and run, and I’m sure that there’s a good reason why the Java 5 creators kept

boolean contains(Object o)

when add is

boolean add(E e)

but I can’t think of one. Certainly not at this time on a Friday evening. Then again, that’s probably why I wasn’t in charge of putting generics into Java 5 in the first place.

It also crossed my mind that, if contains() were strongly typed, then we wouldn’t need a containsAll(); we could just overload contains() with a method that took a Collection. Of course, that’s a stupid idea; I’ll leave it as an exercise as the reader to work out why.

All I needed to do was open a terminal and execute this command:

defaults write com.apple.Safari TargetedClicksCreateTabs -bool true

I’m not entirely sure why Safari have chosen to make it so difficult to set an option that’s a checkbox in Firefox, but, meh, it’s done now.

Setting up Eclipse on Snow Leopard

So first things first, I need the Eclipse IDE (I use the version “for Java Developers”). Whilst there’s only one version for Windows and two for Linux, there are three for Mac (because it’s three times more awesome than Windows, right?). Which one to choose? According to the very aptly named Either You Succeed Or You Explain blog, Snow Leopard users should choose the 64bit Cocoa version. So I have.

If you haven’t used Eclipse before, you might be surprised to find that the .tar.gz file you’ve just downloaded doesn’t contain an installer, just the program itself. Just drag the folder to somewhere suitable, then drag the eclipse program from there to the dock and you’re done.

Installing the Subversive plug-in

If you’re using subversion (which you should), you’ll want to install the Subversive plug-in. In Eclipse, go to Help > Install new software, and search the Galileo update site (top of the pull-down list) for Subversive. Install the Team Connector (but not the optional “for Mylyn projects”, unless you need it). Eclipse will restart, then right click on your checked-out-from-svn project, Team > Share Project, and a box will pop up for you to configure your connectors (you only have to do this once). I’m using “SVN Kit 1.3.0″. Eclipse will now get a bit confused, as the installation of the plug-in happens in parallel to your earlier attempt to Share [your] Project. Eclipse will restart once again (provided you click on “yes”), then you can have another go at right clicking on your checked-out-from-svn project, Team > Share Project. The rest should be fairly self-explanatory; post a comment if these instructions suck…

Linking your Check-in comments to your Issues on Google Code

Whatever you’re doing, you’re hosting the code in version control, right? We use subversion and trac in work, and can add comments to our svn check-ins that appear in our trac tickets. It turns out that you can do exactly the same thing with google code, and if anything, their check-in messages are even more powerful. I look forward to trying them out on my jade-oo project.

I helped Matt put together this map, which gives the locations and URLs for the various software companies that we know of.

We’d love it if you could contribute updates. Just log in with your Google account and click the “edit” button on the left. If you have any problems or questions, please post a comment.

Well, almost.

Unfortunately, it turns out that the original poster used less…

Still it’s nice to know that I’m not the only one for whom this is such an annoyance.

Fumbling in the dark

My old car had two buttons on its remote; lock and unlock. Whilst they were both the same size, the lock button had a picture of a key embossed on its surface. On a dark night, or even with the key in your pocket, it was easy to just brush the buttons with your thumb, and immediately tell which button would unlock the car, and which would lock it.

My new key-fob has three buttons, and whilst the middle one (for opening the boot) is raised, the top and bottom buttons (for locking and unlocking) are identical. Not only that, but the fob itself is symmetric, and so there’s no way of telling which button is which without taking it out of your pocket and squinting at it under the nearest streetlight. Urgh.

Balancing Act

Like many cars, my old car had a metal flap that covered the fuel filler cap (the flap being the bit of metal that was the same colour as the rest of the car; the cap being the bit you’d unscrew and hold to one side whilst you put fuel in). On my old car, the cap had two grooves in the lip round the edge, and you could hook the cap on the edge of the flap so that you didn’t have to hold onto it (or have it scrape your bodywork) whilst you filled the tank.

My new car still has a metal flap that covers the fuel filler cap, and still has grooves in the cap to hook it over the edge of the flap whilst filling the tank. So what’s the problem? Well, the flap on the old car was square, but the flap on my new car is round. How am I supposed to balance a fuel cap on a rounded edge? What’s the point of having two grooves in the back of the filler cap, when it’s only possible to hook one of them over the edge of the flap? Urgh.

What has this got to do with regression tests?

Back in 2000 when my old car was being made, someone came up with the great idea of embossing the lock button on the remote, and someone else came up with the equally useful proposal of being able to hook your filler cap on the filler flap so that it was out of the way when you filled up. Those were great ideas, but they’ve been lost. Could this have been avoided? Sure; the manufacturer could’ve kept a list of all the great ideas they had for all the individual parts of the car, and when it came round to designing and manufacturing a new model, someone could go through that list of ideas and make sure all of them got implemented on the new design.

For all I know, they already do this, but either ideas get forgotten, or by the time it comes to check whether good old ideas have made it into the new model, it’s too late to make drastic changes like redesigning the filler flap or key-fob.

With software, we can be much more thorough. We can have a whole bunch of automated regression tests, like shouldBalanceCapOnFlap() and shouldDifferentiateKeyfobButtonsByTouch(), and we can run these tests all the time. We don’t even have to wait for the design team to give us a prototype; we can start with the tests and then design the prototype to ensure that the tests are passed.

Even better, once we have our software for a well-tested fuel flap or key-fob, we can reuse that element everywhere. So long as our interfaces are good (and we can even adapt them if they aren’t) then every car can use the same type of key-fob. Add continuous deployment into the equation, and not only can you improve your key-fob for every new car that you ever make from now on, you can improve it for every car that you ever made before too.

I should probably say something about DRY, and dependency management, and open source libraries. I should also probably say something about how to write good regression tests; how to write good unit tests. But I won’t; it’s too late on a Friday, and I’m not even sure I’d be qualified to talk about it anyway.

All I will say is this:

• Writing good tests is hard.
• Continuous deployment is worth it.
• Favour other people’s code over your own (but make sure you adapt their interfaces).
• Read some books.

There you go. That’s four more posts that I won’t get round to writing.

–

*It wasn’t.

**It’s not.

Having come to the conclusion that actually, yes, it is rather nice if Apple just sorts all of my music collection for me, I’ve been left with a bunch of previously-elsewhere, unlocatable, unplayable files with little exclamation marks next them.

It turns out that it’s really simple to flush them out; I just followed the instructions right at the bottom of this article, which says:

1. Make a static playlist called “All Live Files” and copy your entire library into it.
2. Make a smart playlist called “Missing Files” with the rules set as “ ‘Playlist’ ‘is’ ‘Music’ ” and another rule set as “ ‘Playlist’ ‘is not’ ‘All Live Files’ ”
3. The broken songs will not transfer and “Missing Files” will contain all those broken songs.
4. Select all the songs in “Missing Files” and press Shift-Delete on Windows, Option-Delete on Mac.