For months now, we’ve had regular games of the Agricola board game at work. It’s a real gem of a game, and in my opinion perfect for “thinkers” – like programmers usually are.

The application helps you with calculating the score for each player in the game, which is done at the end of each game. While far from a necessity when playing, it provided me with an opportunity to create and release an application of limited size and complexity.

You can find the application on the Android Market, just search for “Agricola Buddy” or scan the QR-code to the right.

In the future, I hope to add lots of cool features to it – a way to store results over time, submit to a webservice, easily share the results with others, occupation/minor improvement reference and so on. If you have an Android phone, give it a go

Here are some screenshots:

A popular one in Europe is the X10 Mini, from Sony Ericsson which has a QVGA resolution.

When you are creating Android applications, you should make sure that it works well on various resolutions, which the emulator helps you with. However, the built in QVGA skin is rather ugly, so I decided to try and whip up a skin based on the X10 Mini. Here’s what I ended up with:

I quite like it, and it also works fairly well on low-resolution monitors, such as on netbooks (at least it does on mine). I zipped it up and put it up for download. To use it:

1. Extract the zip file into your Android/platforms/android-<version>/skins folder.
2. Create a new AVD with the AVD Manager and select X10Mini from the skins dropdown.
3. If you want to get as close to the X10 Mini software, use the 1.6 image (android-4, I believe).
4. Enjoy!

Note: I forgot to include the hardware.ini file required for 1.6+. Should work better now

Integrating Silverlight into a rich, Javascript-driven website, I found myself wanting to call Javascript functions from Silverlight. A quick Google search told me this was possible, using the HtmlPage.Window.Invoke method. You could also use the Eval method, but it feels like a dirty hack,
so let’s not go there.

1
2
3
4

private void displayDialog(string message)
{
	HtmlPage.Window.Invoke("showSomeDialog", message);
}

Easy, right? But like a good Javascript-coder, I like to “namespace” my methods, instead of leaving lots of global functions around. The invoke method seems to call global objects only, so I can’t do Invoke(“Rexxars.showSomeDialog”, “message”) – which is a shame. So I thought to myself, I’ll just create a “proxy” function which calls methods in my namespace. Simple:

1
2
3
4
5

function slBridge(method, arg) {
	if(Rexxars[method]) {
		Rexxars[method](arg);
	}
}

Now I can do: HtmlPage.Window.Invoke(“slBridge”, “showSomeDialog”, message); – cool. But what if I want to call a function with more than one argument? I further improved my Silverlight-Javascript “bridge” to support a variable number of arguments:

1
2
3
4
5
6
7
8
9
10
11

function slBridge() {
	// Turn the arguments object into a regular, usable array
	var args = Array.prototype.slice.call(arguments);
	// Method name is the first argument and should not be included
	var method = args.shift();
	// Make sure the method exists inside our namespace
	if(Rexxars[method]) {
		// Call the method with the arguments passed
		Rexxars[method].apply(null, args);
	}
}

Simple, eh? Now I can use the slBridge function to call any method inside my Rexxars namespace, with different number of arguments in each. Sweet!

It’s now online at codenameeagle.net – I suggest you check out the unofficial multiplayer demo – it’s a real blast at any LAN party. Definitely worth a try!

A couple of months ago I came across Nick Zakas’ YUI approach to this problem, and recently I found Paul Irish’s jQuery plugin which was based on Nick’s work.

This is my attempt at creating a Mootools class that uses the same approach. Quite simply, it fires a timer that activates a callback after a given amount of time. The timer is reset if the user moves the mouse, presses a key, scrolls using the scroll wheel or clicks any mouse button. This has to be done over the active document, obviously.

Key features:

• Can be attached to a single element on the page or the entire document/window.
• Lets you set up multiple instances with different timeouts and events.
• Easily retrieve the idle status from the instance using the isIdle property.
• Find the number of milliseconds since the user was last active.
• Allows you to call the active() method to manually reset the idle state – useful for Flash and other overlays that lets you communicate with Javascript.
• Easily retrieve an IdleTimer instance using element.get(‘idle’, { options });
• Free and open source. MIT-licensed.

Check out the demo page for more details. The source is available on Github as well as in the recently opened MooTools Forge.

“Ønsker Seg” is a service that lets you create and share wishlists with people you know. Each user gets a simple and easy to remember URL, x.onskerseg.no. For now, the service is only available in Norwegian, but if I have enough time it would be fun to make it “international”.

It’s not often I have the time or dedication to finish a project like this, so I’m very happy to see it online and I’m going to keep adding features to it. So if you’re Norwegian and you’re looking for a simple way to create and share wishlists, take a look!

My latest project, ØnskerSeg.no

Fairly common..?

How many times have you had to do one of these things? A group of items, each with a checkbox. You want a button/checkbox to select all the checkboxes within that group.

I ran across this again today, and making the javascript to do the work I was once again reminded why I love Mootools so much:

With just three lines of code (1 line to do the actual checking/unchecking), I had this up and running. It couldn’t have taken longer than 30 seconds to write. I love quick snippets

Obviously, this wouldn’t be hard to do in jQuery or any other JS framework, but I love how elegant and intuitive Mootools does it. I shudder when I think of how many times I’ve done things similar to this in plain old Javascript.

Anyway, there’s a demo page available, and here’s the code I ended up with, for anyone interested:

1
2
3

$$('li.head input[type=checkbox]').addEvent('click', function() {
	this.getParent('ul').getElements('input[type=checkbox]').setProperty('checked', this.checked);
});

I downloaded a utility from Samsung that lets you run a disk diagnostic, which would hopefully give me an answer to that question. However, I had to choose between a bootable CD and a floppy, neither of which works for me since I don’t have an optical drive or a floppy drive in the fileserver. So! Here’s how I made a bootable USB thumb drive:

Note: This will only give you a bootable MS DOS drive.

1. Download the “HP USB Disk Storage Format Tool” from bootdisk.com (it’s under “method 2″, first link, currently version 2.0.6)
2. Install the app.
3. You will need the files from a MS DOS boot floppy. You can get plenty of different versions from bootdisk.com. I chose the Windows 98 OEM version.
4. Most of these will want to write straight to a floppy (to get the boot sector right). If you’re like me and a don’t have a floppy drive anymore, you can download and run an awesome little app called Virtual Floppy Drive. This will emulate a floppy drive on your windows box. Pretty awesome for stuff like this.
5. Create the floppy using the downloaded boot disk creator.
6. Insert an appropriate USB thumb drive into the system. I’ve tried different drives and it handles most of them just fine. This time I used a simple MicroSD => USB adapter and a small memory card.
7. Run the HP USB Disk Storage Format Tool thingy, select your USB device, select FAT as the file system, choose a quick format and to create a DOS startup disk. Browse to your (virtual?) floppy drive and click OK, then Start.
8. When it’s done, feel free to copy any applications you want to run from it over to the thumb drive. I downloaded the bootable CD diagnostics from Samsung, opened the ISO file and extracted the application files onto my thumb drive.
9. Plug it into whatever system you want to boot, be sure to set the BIOS to boot from it and you should be good to go

Hope this helps someone, it took me a little while to figure this out a while ago and figured I’d write a small howto.

It gets rather tiresome to look at the same fake phone all the time though, so I decided to take a break and see if I could create a skin based on the upcoming Samsung i7500 (I believe they’ve named it Galaxy now, at least in Germany). The screen position and such may not be spot on, but it has the right resolution at least. I mapped most of the buttons too, but the zones had to be cut off a little due to the emulator not supporting weird button shapes (afaik).

Should anyone be interested in downloading it, feel free to get it. Just extract this to your Android/platforms/android-<version>/skins folder and you should be good to go. Run the emulator with the flag “-skin Galaxy” (or if you’re using Android 1.5 or upwards, just select Galaxy as your skin in the AVD Manager). Here’s a screenshot of how it looks in action:

Samsung Galaxy Android Emulator skin

Let’s say I’m writing an application that retrieves a list of notes from a web service. The URL for retrieving the XML data would most often look something like:

http://whatever.webservice.com/feeds/latest.php?since=timestamp

Which is fine, except one little aspect: it doesn’t tell me if I am getting data back as XML, JSON, CSV or in some other format. I would much rather prefer to have this specified in the URL. Examples of good, clean URLs would be any of the following:

http://whatever.webservice.com/feeds/xml/latest.php?since=timestamp
http://whatever.webservice.com/feeds/latest.php?format=xml&since=timestamp
http://whatever.webservice.com/feeds/latest.xml?since=timestamp

I personally think the last one is the prettiest. There are reasons why the two first might be “better” from a code and performance perspective though:

• The subdirectory method could handle outputting of the data in that format and only that format, not needing any if-checks.
• The query parameter method could handle a lot of different formats in the same file, and would simply call the correct function to retrieve the data in the correct format.

The last one was what I went for in the end. The problem with that is making Apache understand that this “XML” file is really a PHP file. I solved this easily with this simple  .htaccess file, which forces every XML file within the directory you place it in to be run through PHP:

<Files *.xml>
ForceType application/x-httpd-php
</Files>

Sending the correct headers is also a bonus:

<?php
header('Content-Type: text/xml; charset=utf-8');

Worth the effort? You tell me