Of course there are other alternatives in the Desktop Linux scene; offerings such as XFCE, LXDE and KDE all have their place. I personally don't have the time to familiarize myself with yet another desktop environment, especially given that my goal is to be running a Mac at work and at home. I had grown quite fond of GNOME 2 in previous releases of Ubuntu, so my next logical step was to use GNOME 3.

The problem with GNOME 3 is that of immaturity. It's still pretty rough around the edges (it crashes at least a couple of times a day for me under regular use), has very poor display driver support, and doesn't quite have the community momentum for themes and plugins like its predecessor had.

I've been using GNOME 3 for the past few months (at work and home) with the hopes that my gripes with it would be addressed shortly but unfortunately I'm yet to observe even incremental improvements in stability or performance. My work machine (which I'm using 8 hours a day) constantly needs gnome-shell restarts, and sometimes it locks up so bad I actually have to kill the whole session and lose everything I had open. Recently my patience has worn thin enough that I started conspiring to try something (anything, really) new on my machine at work. The proverbial straw was broken when somehow my NVIDIA display drivers (custom installed in order to address a host of issues with gnome-shell) was broken so badly by an Ubuntu update that I had to boot into recovery to fix it. But wouldn't you know it, recovery console isn't working with my setup for some reason - it wouldn't detect my keyboard!

I had read about the MATE project on the Linux Mint blog a few months back, so today I wondered how it had come along. The prospect of a pure GNOME 2 environment running in the latest Ubuntu sounded very promising indeed. I decided it was finally time to make the jump.

With a small amount of tinkering, I had a fully functional MATE session up and running in Ubuntu 11.10. It took a whopping 10 minutes to get MATE fully operational. All I had to do was the following:

• sudo bash -c 'echo "deb http://tridex.net/repo/ubuntu/ oneiric main" >> /etc/apt/sources.list'
• sudo apt-get update
• sudo apt-get install mate-archive-keyring
• sudo apt-get install mate-core
• Logout, select MATE from the session list and log back in

The thing that struck me immediately is HOW INSANELY FAST IT IS. Especially compared to GNOME 3/Unity. After getting Compiz up and running and using the desktop for an hour or two, I suddenly realized just how sorely I'd missed the polished and refined awesomeness that is GNO- er, MATE.

I am in the process of installing MATE on my home machine now so I can get as much exposure to MATE as possible over the coming weeks. I will be documenting my experiences here, and sharing all the gotchas I find as I go.

A quick rundown on how Grails 2 logging works:

• SLF4J is used to handle logging
• By default Grails uses Log4j as the logging provider.
• Jakarta Commons Logging (JCL) is redirected to SLF4J using jcl-over-slf4j
• java.util.logging is redirected to SLF4J in dev mode, but disabled in production environment by default

With this default setup, you'll quickly discover that Grails logging ends up in standard out in Glassfish, which means that you can't use Glassfish admin to configure log levels at all with your deployed application. This is obviously not an ideal situation.

Glassfish only supports java.util.logging, so we need to tell Grails to log to this in order to play nicely with Glassfish.

Previously in Grails 1.3.7, we were using the technique Reiney Sadder outlined in his excellent blog post to remove log4j and install slf4j-jdk14 to redirect all logging to SLF4J into JUL. Unfortunately this technique no longer works in Grails 2, as Log4j support in Grails no longer comes from slf4j-log4j, but rather a core Grails plugin called "grails-plugin-log4j".

So, how do we achieve this in Grails 2? Simple! Just add the following to your BuildConfig.groovy:

// Inside your grails.project.dependency.resolution closure:

inherits("global") {
	Environment.executeForCurrentEnvironment {
		production {
			excludes "grails-plugin-log4j", "log4j"
		}
	}
}

dependencies {
	Environment.executeForCurrentEnvironment {
		production {
			runtime "org.slf4j:slf4j-jdk14:1.6.4"
		}
	}
}

This will disable log4j entirely in production environment and add the slf4j-jdk14 JUL bridge.

NOTE: Make sure you definitely have the following line added to your Config.groovy:

grails.logging.jul.usebridge = false

You really should have this disabled for production anyway, as it's not very performant.

The BuildConfig.groovy change above completely disable log4j, so any log settings you have defined using the Log4j DSL in Config.groovy will not be recognized at all. This is why I only enabled it in production environment, it's still nice to be able to easily tweak logging settings for your development environment. If you really want to though, you can configure your own JUL logging.properties and just enable the SLF4J JUL bridge permanently.

Have fun!

Haven't updated my blog in a while, but I had a fun little win tonight that I thought I'd share with the lovely readers of this blog (you know I love all 3 of you).

I am currently working fulltime at Wotif.com in Brisbane, and I'm extremely fortunate to be immersed in the weird and wondrous world of Groovy/Grails for the majority of application development I'm involved in. To make things even more awesome-er we're currently working a on a project that uses CouchDB/ElasticSearch as our primary data provider. Life is bliss. Well, mostly.

The Problem

I still have work come in occasionally from a long-time client I respect enough to give some time to on the weekend. Unfortunately this work is in the form of PHP4 code most of the time. And no, the pain doesn't just end there, usually the work is on a fairly large production Joomla 1.0 site. Needless to say, the technical debt flows freely.

Anyway, this particular site is a real pain to work on, as it's not really in a state where it can be run up locally without a fair amount of pain and misery. I haven't done much work for this particular client in the last few months, and thus I didn't really have a proper LAMP stack running on my machine at home (nor do I really want to). A more recent project I'd done for this client last year was a Joomla 1.5 site, where I had the luxury of "doing it right" - I had set the project up to easily be run up locally using some bash scripts, UnionFS, and a little bit of voodoo. But no such win was to be had for this Joomla 1.0 site.

The work I needed to perform on the Joomla 1.0 site was considerable enough that the prospect of firing up Filezilla and manually FTPing changes was unbearable. In the past I've used Eclipse with an obscure plugin called ESFTP to push my changes to the server as I develop. However this still has an obnoxious required manual step of clicking a button every time I want to push a file to the server.

I figured there had to be an easier way. Then I remembered seeing some cool inotify stuff in Node.js a while ago.

The Solution

I thought to myself: "Wouldn't it be cool if I had a little Node app running that monitored my project on the filesystem and FTP'd changes to the codebase as I made them?".

So I decided to cook something up. A couple of hours later I came up with this:

https://gist.github.com/1652663

I didn't end up using the libinotify bindings for Node.js, as it was a little too low level for a quick prototype. The main pain point was the fact that inotify isn't actually recursive, so you actually have to put together your own code that recursively creates watch descriptors for the directory structure, glue in new watch descriptors as new directories get created, and delete old descriptors as directories disappear. I instead opted to use the awesome inotifywait tool (which comes from the inotify-tools package in Ubuntu) which handles all the un-fun parts of inotify and instead sends nice little status updates on stdout.

Oh, and I was getting bizzare issues with the node-ftp library from NPM, so I just grabbed the latest from the git repo and threw it in with the script.

So now I just fire up this script with the FTP details and paths. It just sits there patiently and creates/deletes directories as needed, and pushes file changes/deletions as they occur.

Now this could definitely have easily been done using pretty much any language, but I think it's a pretty neat and elegant little CoffeeScript/Node solution

Speaking of Node/CoffeeScript, I've been working on a little project in all the spare time I can get. I'm excited to blog about some of the cool stuff I've found/done in that regard in the coming weeks!

That's all for now, internets.

An issue I ran into was I wanted to reduce the boilerplate on handling requests, so I wrote a quick route middleware in Express to create a client connection to Redis, assigning the connection to the request object for easy use . I also wanted to be clever and have this same middleware clean up after itself when the request ended. That is, I wanted the middleware to QUIT the Redis connection when the response had been sent.

Consulting the Express/Connect/Node docs yielded no clues as to how to do this, the closest hint I found was from the Node docs indicating that a http.ServerResponse is a WritableStream. I noticed WritableStreams had a "close" event that is supposed to be called when the Stream is no longer writable. I assumed that if you call .end() on a response then it should trigger this event, so my initial middleware looked like this:

setupRedisClient = (req, res, next) =>
	req.redisClient = require("redis").createClient()

	cleanup = =>
		console.log "it worked!"
		req.redisClient.quit()

	res.on "close", cleanup
	res.on "error", cleanup

	next()

I tried using this middleware in a route, and was sad to see that the event was not being triggered.

As a last resort I started digging through the Node source, and lo and behold! I found what I was looking for in lib/http.js. Turns out when you .end() your http response, it will emit a "finish" event.

Now my Redis middleware looks like so:

setupRedisClient = (req, res, next) =>
	req.redisClient = require("redis").createClient()

	cleanup = =>
		req.redisClient.quit()

	res.on "finish", cleanup
	res.on "error", cleanup

	next()

Incoming routes that need a Redis connection simply add this middleware, and hey presto! They can use req.redisClient to their hearts content. Once a response is sent back to the client, or an error occurs with the request, the Redis connection will be cleaned up automagically! Hurrah!

The fun part of this is that the Open Graph specification states that OG metadata should be embedded on the page like so:

<meta property="og:title" content="The Rock" />
<meta property="og:type" content="movie" />
<meta property="og:url" content="http://www.imdb.com/title/tt0117500/" />
<meta property="og:image" content="http://ia.media-imdb.com/images/rock.jpg" />

The stupid thing is this is actually invalid HTML5. The HTML5 spec states that meta tags must use the name/content attributes, and because OG is based off RDFa, an XHTML draft, OG mandates that its metadata uses the property attribute instead of the name attribute. After Googling around a bit I came to the "conclusion" that the only way to get a page to validate with Open Graph tags was to switch to XHTML.

Screw that.

Instead I tried just changing the property attributes back to name and run it through the Facebook URL Linter tool. Turns out, Facebook will grumble at you, but they will still parse OG data out of standard meta tags, and Like Buttons will use that metadata just fine.

So, in summary, if you're authoring a straight HTML5 (non-XHTML) site, you have a choice between pissing off W3C, or pissing off Facebook. It's your call.

I've put up two examples for reference, one uses meta property (non-standard), the other uses meta name (standard).

Got my no.de coupon in the mail a couple of days ago.

Now I just gotta figure out what I wanna host at http://sammeh.no.de/....

Let's say you have some binary data you want to provide to Node Javascript. No problem, Node has Buffers for that. Digging through the Node.js source code, you find node_buffer.h, which promises a utopia of an ObjectWrap goodness; you can even memcpy your binary data directly to it using Buffer::Data(bufferObject).

"Fantastic! I'll rock one of those buffers and simply return `bufferObject->handle_`!", I hear you exclaim. Not so fast stud.

If the client were to use this Buffer, they'd get a nasty surprise. It's not a Buffer. You see, Node.js has re-implemented Buffers since 0.2. The Buffer you're playing with from node_buffer.h is actually a SlowBuffer. As the name implies, it's working directly on the heap-allocated memory chunk, so alot of operations on it are quite inefficient. Worse still, the interface provided on SlowBuffer is actually different to the Node.js documentation. Allow me to explain.

The Buffer you're used to dealing with from Node.js user code actually originates from buffer.js. These Buffers are actually just "views" on a proper SlowBuffer, so operations like slicing are literally as quick as allocating a new Buffer object that views the SlowBuffer at a different offset and max length.

So how do you create one of these badboys from C++ to pass directly back to JS calling code? Glad you asked. Like so:

	// Some data we want to provide to Node.js userland code.
	// This can be binary of course.
	const char *data = "Hello world!";
	int length = strlen(data);

	// This is Buffer that actually makes heap-allocated raw binary available
	// to userland code.
	node::Buffer *slowBuffer = node::Buffer::New(length);

	// Buffer:Data gives us a yummy void* pointer to play with to our hearts
	// content.
	memcpy(node::Buffer::Data(slowBuffer), data, length);

	// Now we need to create the JS version of the Buffer I was telling you about.
	// To do that we need to actually pull it from the execution context.
	// First step is to get a handle to the global object.
	v8::Local<v8::Object> globalObj = v8::Context::GetCurrent()->Global();

	// Now we need to grab the Buffer constructor function.
	v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(globalObj->Get(v8::String::New("Buffer")));

	// Great. We can use this constructor function to allocate new Buffers.
	// Let's do that now. First we need to provide the correct arguments.
	// First argument is the JS object Handle for the SlowBuffer.
	// Second arg is the length of the SlowBuffer.
	// Third arg is the offset in the SlowBuffer we want the .. "Fast"Buffer to start at.
	v8::Handle<v8::Value> constructorArgs[3] = { slowBuffer->handle_, v8::Integer::New(length), v8::Integer::New(0) };

	// Now we have our constructor, and our constructor args. Let's create the
	// damn Buffer already!
	v8::Local<v8::Object> actualBuffer = bufferConstructor->NewInstance(3, constructorArgs);

	// This Buffer can now be provided to the calling JS code as easy as this:
	return scope.Close(actualBuffer);

And that's all folks!

Currently I'm completely immersed in the weird and wondrous world of Node.js. If you are even remotely interested in anything related to web development/engineering, you should already know about Node. Briefly, it's a server side JavaScript (SSJS) implementation built on top of Google's V8 JavaScript engine. It's blisteringly fast, and has already been employed in some big projects to solve some pretty insane scaling problems engineers are facing in large websites.

Currently I'm just getting myself acquainted with Node.js, I've written some random libs that are on my Github. Currently I'm writing a native Node extension called node-gitteh, which provides bindings to the excellent C library libgit2. I'll be using these bindings to manipulate Git repositories from Node as part of a little project I'm going to undertake (more on that later).

Writing these bindings has been interesting, given that I'm writing C++ code for the first time in years, and having more trouble remembering how to use an STL map<> than I am wrangling the bizarro V8 API. I think this definitely warrants a tip of the hat to Google, the internals of V8 are pretty accessible; my only gripe with V8 is a pretty painful lack of hand-holding documentation, however there were plenty of examples of stuff on Github from other kindred Node spirits who've written bindings for things like GD, Mysql, libxml2 and the like.

The thing that has impressed me about Node the most is the amount of talent the community is comprised of. Node is only just over a year old and there is already a mass of quality libraries and frameworks. One I particularly love is Vows, which has made TDD an absolute breeze in Node. If you're just starting out with Node, I thoroughly recommend you get into the habit of using Vows to test your code, ideally writing the tests before you even launch into your next Javascripty wet dream. Seriously, it's worth it.

Of course, Node is not without it's faults. The biggest one currently is lack of threaded-ness, or any kind of concurrency control from JavaScript. Many will argue this is a Good Thing, as it abstracts away the misery that is semaphores, locks, re-entrancy and other goodies that come with thread-safety. However I still think there should be first-class support for concurrent operations in Node user land (read: JavaScript code).

There are some solutions out there that utilize nodes ability to spawn child processes and communicate/control them effectively, to the effect of running a pool of Node processes. However I view these as a kludge, as Node processes do have a pretty decent memory footprint on initialization. Given that Chrome has a way of running completely sandboxes JavaScript execution contexts in parallel (that is, a blocking script in one frame wouldn't block other frames), I'm sure there's an elegant solution to be found.

That's all for now!

I have a page accepting uploads (using Yahoo UI uploader) for large files. I had it working a while ago but then I modified the whole design quite alot recently. All of a sudden when testing the uploader would randomly stop uploading after a couple of seconds, with absolutely no warning. I went so far as to trace the Flash logging output coming from the YAHOO uploader.swf to see what was going on - sure enough, it was spamming to the console the current upload status, and then randomly stopping out of the blue. No error messages. No warnings. No nothin'.

So it turns out I had the browse button sitting in a div with some text, and when the upload button was clicked, I was calling jQuery("#browseContainer").slideUp() to hide the text and browse button. Boom, that's what was causing it. No shit.

Turns out jQuery's slideUp() will put display:none on the animated element when it's done ... slideUpping it. Awesome story though - Flash plugins decide they shouldn't be running anymore when their parent element has display:block on it. No shit. This might be documented somewhere, but I'll be damned if it's common knowledge. Maybe I'm a total retard ...

Hope this helps someone.

I'm a little slow on the uptake here, the blog update I'm referring to is now 10 days old. I haven't been in the Facebook dev world of late, so I hope you'll forgive me for regurgitating old news.

The big update for me is in the 4th paragraph:

We are also moving toward IFrames instead of FBML for both canvas applications and Page tabs. As a part of this process, we will be standardizing on a small set of core FBML tags that will work with both applications on Facebook and external Web pages via our JavaScript SDK, effectively eliminating the technical difference between developing an application on and off Facebook.com.

This is excellent! I have actually been holding my breath for something like this for a while now. The restriction of FBML only content for tabs has been extremely restrictive, here are a handful of reasons why:

• Very strict HTML parsing - because the Platform was rendering tabs inline previously, it of course had to be VERY careful in how it handled offsite data, to protect users from all manner of scams/attacks. Now full flexibility is available because your iFrame is yours to control.
• Insanely strict JS parsing - same as first point, application tabs could only leverage basic Javascript and the unwieldy, poorly documented FBJS (Facebook Javascript). Now, you're free to access manipulate your IFrame document/window objects, DOM manipulate, include third party JS libs, etc, all to your hearts content.
• Embedded media was a pain - Granted, the tab FBML *did* allow you to embed Flash and AIR apps etc, but there were countless threads on the forum outlining issues they were having interacting with the host page, etc.
• Tab activation policies - There were some extremely frustrating rules with the way tabs were allowed to be "activated". No JS/FBJS was allowed to execute until the user had interacted with the tab in some manner, such as focusing a form element or clicking somewhere. This made it very cumbersome to implement any meaningful interactions with the user; alot of obnoxious boilerplate code had to be written for various ways in which you may actually start doing anything meaningful from JS, like AJAX requests.
• ... and lots more Everything from CSS parsing to the occasional time where the tab would just sit in an endless loading display when clicked. When I was writing a tab page I remember bashing my head against the wall trying to get some content to sit nicely in a cross browser fashion... it would have been easy under normal circumstances, but the Platform tab flavour was refusing to accept the *display: inline IE hack in the CSS. Joy.

This is going to really open up some great possibilities for interactive, rich web applications. I really cannot wait for this feature to be rolled out.

This news does come with some disappointment however; the sixth paragraph on the developers blog states the following:

Finally, due to low usage rates, we will remove application tabs from user profiles in the next couple months. Application tabs will continue to be supported on Facebook Pages.

There are plenty of great use cases to have application tabs on a user profile page. My personal Facebook profile has a tab that displays my latest last.fm scrobbles, my latest blog posts, etc. Personally, I believe that if the adoption rate for user profile tabs is low, the Facebook team should be coming up with ways to increase user acceptance of this feature, rather than removing it all together. Besides, the functionality in Facebook Page tabs is pretty much identical to the user profile equivalents... Why not support both?

There's other goodies in the developer blog update too, such as cleaning up the REST API considerably.

All in all, exciting changes coming to the Facebook platform in the coming months!