A Facebook engineer has been fired for using Facebook too much at work.

“It was ridiculous”, an anonymous source (who promised he wasn’t the employee’s direct manager) said. “He was on it 24×7. Now, we’re a very tolerant company. You have to be with these Gen-Y types. I use it myself. Well, uh, occasionally”, he added hastily.

“I know the importance of staying in touch with your friends and family, but he was jerking us around.

“He claimed to be researching the user interface, but all I could see was him chatting to his college buddies. When I challenged him on it, he even rearranged his desk so I couldn’t see his screen! Luckily, he was a Facebook friend, so I could see him on Facebook Chat. I, uh, we had to let him go. What? No, I wasn’t his manager, I promise.”

Despite strong protests, James Greaves, 28, originally from Brentwood, Tennessee, was unable to save his job.

This was not the first time Jimmy had had problems with Facebook at Facebook. “I was a bit foolish”, he admitted. “When I was offered the job, I forgot to tell them I was best man for a wedding soon after I was supposed to start. I called in sick so I could go to the bachelor party and then again the day after, but a groomsman checked me in on Facebook Places at Aphrodite Nights and then tagged photos of me half-naked and licking cake off a stripper.

“That was a hard one to explain”, he sighed.

“It’s ironic”, he continued. “I actually pushed an update to the tagging functionality just a couple of days before that – my first piece of useful work. My mate even mentioned how easy it was for him to do all the tagging in one place. He probably wouldn’t have bothered otherwise.”

Jimbo had been at the company 6 months since joining from Google, where he was let go for not using Google enough. “I was searching for information on ‘binary space partioning’ and got to ‘bin’ before Google Instant automatically took me to Bing.com”, he said. “My manager was passing by and fired me on the spot for not being Googly enough.”

“I just don’t understand it. I’m fired for not using a service enough. Then I’m fired for using one too much. There needs to be some consiste”, Jay added in a tweet later on.

Facebook declined to give an official comment, though later in the day Facebook’s own Facebook status briefly changed to “officially has no official comment on Greavsie’s dismissal”. No word on whether that was done on the responsible staff member’s own time or not.

Jim is now using LinkedIn to find a new position, and hopes that they will offer him a role soon.

After, and not in the same league as, The Onion.

My girlfriend Emily Benjamin is something of a special photographer and she is finally putting together a site to show off some of her great pieces. Naturally, I put her onto WordPress. Emily wants the photos to go front and centre, which is a fine idea, so we put together a very simple one-column theme based on QuickPic, which will be uncluttered and allow the photos to shine.

Problems arose when trying to lay out images though. Many of the photos are cropped for emphasis and impact, and being different dimensions, laying them all out on one page can look messy. This can be avoided by cheating a bit and pre-processing them in pairs and combining them into a single image, so that each constituent photos’ heights match. Arty people like because it allows for some cool dynamic looking layout. It also helps reduce the amount of HTTP requests which techy people care about.

How though to generate these tiled images? You could hand-crank one with GIMP, but that gets pretty boring after a couple of times. There are also a couple of commercial products out there that could help, but that seems like cheating. No, Team America said it best – you need a montage! ImageMagick’s montage command to be precise. (I happen to use GraphicsMagick, as ImageMagick was giving me insidious “Bus Errors” on my MacBook, but the same commands will work with both tools.) [Image|Graphics]Magick are some of the finest free tools available, and a shining example of the power of both open source communities and command line applications.

We start with two fine images, a church in Budapest and a view at sunset from the Ponte Vecchio, Florence. They’re both huge, because DSLRs now take photos at up to 20MB in JPEG format (!). So, we need to shrink them down a little bit and glue them together with a bit of whitespace, ensuring that the whole resulting image is 800 pixels wide (our chosen width for the main column).

The montage command makes this simple enough:

gm montage -geometry x800+5 -background yellow lamppost.png bell.png -resize 800 output.png

You’ll notice that I’ve made the background yellow, just so we can see where the borders are here. The geometry parameter says to make sure each component image fits within 800px vertically, leaving a 5px border on each side. We decided that we wanted a 10px internal space between the photos, so 5px on the side of each photo works nicely. The -resize command at the end takes effect after the montage has been created and resizes the entire outputted image to 800px wide, preserving the aspect ratio. This is the size of photos that has been chosen for the host site, but on this site with a narrower main column I’ve forced it to 500px. You can click on the images to see them at full 800px size if you want to. I’ve chosen to output it as a PNG. The image looks like this:

That’s not a bad first go, but there’s plenty we can improve. The sunset photo is narrower than the church photo, so it has been centred within its cell. There’s also an extraneous border around the outside. We handle these with two additional parameters, gravity and trim. Gravity allows us to ‘pull’ each photo in a given direction within its cell, and trim gets rid of a border, whatever colour it is.

For the gravity, we want to pull the left photo rightwards, and the right photo leftwards, so the central spacing is consistent. We do that by specifying -gravity East for the first photo and -gravity West for the second.

gm montage -geometry x800+5 -background yellow -gravity East lamppost.png -gravity West bell.png -resize 800 output.png

That’s looking better, but now we just have to get rid of that outer border. We do that using the -trim command, and at the same time I’m going to make the background colour transparent:

gm montage -quality 100 -geometry x800+5 -background transparent -gravity East lamppost.png -gravity West bell.png -trim -resize 800 output.png

Notice that I do the trim before the final resize. ImageMagick commands are executed sequentially from left to right. I’ve also added a -quality parameter to keep the quality of the final image high. (In this case it’s probably too high, but we won’t worry about that.) Our image now looks like this:

and it’s looking pretty groovy. But what happens if we want to tile two photos of vastly differing heights? The ‘x800′ is a decent enough guess, but if we start off with source images that are smaller than that (but which would still comfortably make a nice component image in a larger montage), we can end up with a pretty crazy result:

Not awesome. The problem is that we are only guessing as to the height of the component images. We can do better than that though, using *Magick’s identify command. This tool gives everything you could possibly want to know about an image, but for now we’re only interested in the height, and that’s relatively straightforward:

gm identify -format "%h"

which gives us a simple single number. Ideally, we only want to initially shrink the component images enough so that they are the same size vertically as the smallest vertical of the two. In practise, this means we are only shrinking the image that is larger vertically in the first stage. Once they are composed at the same height, we can glue them and shrink the resulting image. A little bit of bash scripting gets this done for us in a couple of lines:

#!/bin/bash
HEIGHT_ONE=`gm identify -format %h $1`;
HEIGHT_TWO=`gm identify -format %h $2`;

if [ "$HEIGHT_ONE" -lt "$HEIGHT_TWO" ]
then
    MIN_HEIGHT="$HEIGHT_ONE"
else
    MIN_HEIGHT="$HEIGHT_TWO"
fi

gm montage -quality 100 -geometry x${MIN_HEIGHT}+5 -background transparent -tile 2x1 -gravity East $1 -gravity West $2 -trim -resize 800 output.png

(If you’re copying and pasting that, ensure you paste as backticks on lines 3 and 4, not quotes or apostrophes.)

Save that as ‘you-need-a-montage’, then make it executable and you can do:

./you-need-a-montage left-image.jpg right-image.jpg

to end up with something like this:

Be sure to check out more of what ImageMagick and GraphicsMagick can do for you – this is just scratching the surface. And keep an eye out for Emily Benjamin too, once the site is up and running!

I was using Amazon’s Reading List application on LinkedIn and writing short reviews there, but I quite like the idea of having a history of what I’ve read on my own site. There are a couple of “now reading” plugins for WordPress, but none of them really did what I wanted, so I decided to scratch the itch and put something together. 30 minutes later and you can see the results in the sidebar on the homepage! Writing plugins for WordPress hasn’t really changed much since I was active in that area a few years ago, but the main posts table now seems to be used for all kinds of content. In that spirit, I just created a custom post type of ‘book’, inserted some data into the database and wrote a little widget to extract it. Reusing the guid column for ISBNs lets me make use of the wonderful Open Library for covers and the post content just becomes the text. I suppose I could have monetised it with Amazon links, but I’m sure I can live without the 5 bucks that would bring in a year! There’s a little more to do yet, like flesh out a main library URL, and introduce a simple backend page for adding books, but for now it does what I want.

Now I only wish I’d done this years ago, as the list appears pretty thin at the moment! I’ll just take that as yet another incentive to read more!

Erlang perhaps isn’t the best language for dealing with matrices, with its ‘one-time’ mathematical approach to assignment, however the existing methods all seemed to make use of tuple_to_list(), list_to_tuple() conversion and excessive list copying. Below I present a simple module which is at least more efficient than the above, and relies on a list of lists, using lists:nth() to retrieve elements. Perhaps in the future this will be superceded by new array syntax, but for now it suits my needs.

Matrices are generally stable, by which I mean unchanging in dimensions. Of course matrices can be different sizes, but the majority of matrix operations that return a matrix result return one the same size as at least one of the inputs. Given that we know the matrix dimensions, in theory this makes tuples a suitable choice for implementation, but in practice the immutability of tuples (even more immutable than lists) make them unwieldy and involve a lot of overhead when building them. And with Erlang’s binding there will be lots of rebuilding.

The main approach is to accept that we will be rebuilding the matrix in full each time and generalise to a standard matrix building function that takes matrix size and cell content generator function parameters:

new(Columns, Rows, ContentGenerator) ->
  [
    [ContentGenerator(Column, Row, Columns, Rows)
      || Column <- lists:seq(1, Columns)
    ]
    || Row <- lists:seq(1, Rows)
  ].

which reads roughly “for each row, for each column on that row, call the content generation function for that cell”.

Each content generator function has the following spec:

fun((pos_integer(), pos_integer(), pos_integer(), pos_integer()) -> any()

where the four parameters are current column, current row, number of columns, number of rows. A simple identity function is as follows:

fun(Column, Row, _, _) ->
  case Column of Row -> 1; _ -> 0 end
end

which will generate the identity matrix:

[[1 0 0]
 [0 1 0]
 [0 0 1]]

A sequential matrix might be generated with the following function:

fun(Column, Row, Columns, _) ->
  Columns * (Row - 1) + Column
end

giving:

[[1 2 3]
 [4 5 6]
 [7 8 9]]

while a matrix composed of pseudo-random numbers 1 to MaxValue could be:

fun(_, _, _, _) ->
  random:uniform(MaxValue)
end

where MaxValue is bound in a closure, giving (for example):

[[3 9 6]
 [1 1 4]
 [6 2 1]]

With this general mechanism, matrix operations such and addition or multiplication become a lot simpler. All that is required is to define a generator function that sets each cell correctly according to whatever operation you are performing. Matrix addition is defined thus:

% Adds two matrices together.
-spec add(num_matrix(), num_matrix()) -> num_matrix().
add(A, B) ->
  new(length(lists:nth(1, A)), length(A),
    fun(Column, Row, _, _) ->
      element_at(Column, Row, A) + element_at(Column, Row, B)
    end
  ).

Performance isn’t great for modification of a single cell, as it rebuilds the entire matrix. A future optimisation could include recognising that an entire row hasn’t changed and simply rebinding that. However, for my current use cases, I haven’t needed efficient single-cell manipulation. There are specs for the functions, but very little in the way of error checking. There are no checks for the addition of matrices of two different sizes, for example.

Future extensions will include the ‘Hungarian’ approach to the assignment problem, retrieval functions for entire columns or rows, some unit testing code, and confirmed support for NxM matrices. (Non-square matrices currently work in theory, but not all functions have been tested to work with them.) Check out the code on GitHub. It’s freely available to use and fork, and if you do, be sure to send a pull request!

This is a different kind of flood to those in Toowoomba. Whilst they were flash floods, caused by super storms dropping hundreds of millimeters of rain in a matter of hours, this is a more subtle, deceptive approach. Like the T-2000, which walks because it has no need to run, the impending deluge will get here in its own sweet time. The opening of the Wivenhoe floodgates necessitated by its 190% fill, combined with the winter King Tide and a river swollen with weeks of rain ensure the inevitable. A regular Perfect Storm, it is being said. Blue skies over much of Brisbane today belied the fact that tomorrow, water levels will reach their highest points in nearly 40 years, and may go higher. And there is nothing to do but wait for it. Not so much the calm before the storm, but in the eye of it. With the severest weather apparently over, there is only the aftermath to come. This may be the hardest thing to reconcile; that there can be such a delay from the event to the impact.

The supermarkets looked post-apocalyptic yesterday, with scenes typically assumed more appropriate for Soviet Russia, as people queued for bread and other staples. The irony of having to purchase bottled water was lost on no-one, but concerns about the continued functioning of the water treatment plant meant people were leaving nothing to chance. There were no queues today, with the cupboards already bare, but for some canned goods, and a single solitary pineapple.

With valuables safely stowed and sandbags in place, people stepped out, curious and keen to survey the newly-aquatic scenery. Brisbane is a river city, not a beach city, and it is to here that people are drawn. Amazement as ferry terminals and river restaurants slip their moorings and are deliberately sunk, to prevent them turning into tremendous torpedos.

Wandering around near Milton station, people appeared dazed and confused, with the same shocked expression resonating on every face as the scale of the sprawl became apparent. Unlike Atlantis, which conjures visions of grandeur, we are instead treated to the mundane made novel. Submerged street signs, an inundated McDonalds and debris floating lazily down new rivers contribute to the disbelief. The commonplace becoming surreal, as water is juxtaposed with traffic lights and KFC. No glorious Venice this, no grand cathedrals or Bridge of Sighs, though many sighed as all but one of the bridges closed.

No fear though, not here. Unlike our colleagues in the North, we at least have had the warning and time to make preparations. Excitement is the wrong word. That is too glib for the tragedy that has ruined and will ruin so much. Anticipation perhaps. A sense in the air. Not quite foreboding, but the biding of time. Deserted city streets, as people heed the warning to leave their cars at home. No public transport, no hum of industry. Quiet and somewhat menacing.

An hour ago, the rains returned briefly. The power is out in much of the town. There is the smell of salt in the air. And the water continues its inexorable ascent.

The open source world has enriched my life significantly, both professionally, in providing the databases, languages, operating systems and IDEs that are my livelihood, and personally, in providing communications tools, entertainment and even this blogging platform. Over the course of my career, I’ve tried to give back to these communities, both in time and code submissions, and I’ve contributed in some small way to a number of projects. The challenging nature of my recent full-time employment has unfortunately meant that more recently I’ve only been able to do this in limited ways.

With my impending hiatus and upcoming travels, I hope to have more time to dedicate to the various online communities I follow. This might be through forums such as stackoverflow where I’ve received answers to numerous difficult questions, or simply helping people in chatrooms. It might be answering questions on Quora. It will certainly involve code contributions, though to which projects I’m not sure. No deed is entirely selfless, and regular development will ensure I stay sharp and widen my employment opportunities, but primarily this is about passion for development, which I’m certain I couldn’t live without for any length of time. I’m very excited about CouchDB, which would also develop my capabilities in Erlang. I value Zend Framework very highly, which would deepen my expertise in PHP. Perhaps it will be both, or others instead. But as the new year begins, I will make this my manifesto – that I will give back to those people and projects that have made my life, and many others’ lives better.

My job title from January 22nd – Open Source Contributor.

Allowing ISPs to charge different amounts for access to different content is abhorrent. It is clear that large businesses will be able to pay the subscription fees which ensure that their content is delivered to the widest number of people at the fastest speeds. The little guys, the independent bloggers and the startups won’t have access to the capital required to pay additional dues. Remember that content providers already pay access fees to ISPs. These scale naturally with the size of the company. The more popular you are, the more bandwidth you require and the more you pay. Expecting newly formed companies to pay additional fees on top of that, just to ensure that consumers receive a high-quality service will stifle innovation, reduce creative output and reduce the economic benefits that Ed Vaizey is so keen to champion.

It will also lower the value proposition for releasing an Internet product to the UK.

Other countries have already enshrined Net Neutrality in law. If you had a new and innovative, but bandwidth-hungry product, would you release it in a country where everyone was guaranteed reasonable access, or a country where only those subscribers who could afford to see it would? Social products in particular, which thrive on the basis that everyone is connected, would suffer. You’d never start a Facebook in a country where there was a possibility half of the available audience wouldn’t see it or have high-quality access.

Companies will have to pick which countries they choose to pay for access in, which could leave the UK behind in terms of access to content at reasonable speeds. The UK already languishes behind the US in terms of release dates for media and services (c.f Netflix, Spotify, Google Voice) and this would compound the issue with slower speeds when and if they are finally made available.

For the same reason that companies go overseas to avoid taxation and find cheaper manufacturing options, the UK could become a country where Internet products are only released as an afterthought, and only if the access fees are acceptable. For the few lucky companies that are popular enough to survive, but who don’t want to pay the access fees, It is the subscriber who will inevitably end up subsidising the payments through higher rates.

More insidiously, it will chill dissenting voices. Aside from the massive economic benefits that governments love, the key innovation of the Internet has been to democratise ideas, knowledge and the power to influence. The wild nature of the Internet means you can find supporting or dissenting opinions on every subject you care to think of. The Conservatives conflate “lightly-regulated content” in terms of freedom of expression, which is A Good Thing, with “lightly-regulated access”, which allows ISPs to pick and choose which content you get to see, which is A Very Bad Thing.

Once you remove the principle of Net Neutrality, there is no barrier to a filtered Internet. The paradox of “lightly-regulated access” is that it inevitably leads to heavily-regulated content. How long do you imagine it will be before ISPs, under pressure from various governments, choose to slow or deny access to important sites like Wikileaks? They may not pay the ISPs to do so, but they have considerable leverage in terms of taxation and licensing. How long before evangelical groups pressure ISPs to do the same to porn sites? From there, it is a small but definitive step to a filtered, sanitised Internet, where you can only see what you should be allowed to see.

Does this sound paranoid and ridiculous? Consider the trialled “Net-Filter” in Australia, designed to prevent access to illegal content. When the blacklist was leaked and published (by Wikileaks, no less), plenty of sites were found to be on it that weren’t illegal, but were simply outside the mainstream tolerance for fetishes and the like. Even some legitimate businesses were excluded. Abuses like this happen even in systems where everyone involved honestly tries to enforce the rules fairly. Introduce a profit motive like “pay for access”, and human nature sadly dictates that freedoms will be impugned.

The only way to ensure those freedoms is to enshrine in law that ISPs have a duty to deliver all content equally, regardless of source.

There is a reason we don’t allow people to pay politicians to ask leading questions or enact legislation (let’s leave aside the iniquities of the extremes of lobbying for now). We expect our politicians to behave in a manner that is good for the people they were elected to represent, and we recognise that allowing them to take money for favours colours their judgement. The analogy holds for ISPs. If we allow them to take money from content providers, they are going to prioritise those providers’ needs first, above other providers, above subscribers’ needs and above the general good.

Free markets are not perfect and are not a universal panacea. See the current state of US healthcare for a cautionary tale.

Expecting market forces to manage the fallout is naive. Rest assured, the ISPs will all take the opportunity to extract more money, if only because they have a fiduciary duty to act in the best interests of their shareholders, and, sadly, that is wholly equated with profit. New ISPs offering net neutral services will not magically pop into existence. For a start, many consumers won’t even know what’s going on. The Internet is a utility, like water, gas and electricity. You turn on a tap and water comes out. You plug in a toaster and start making toast. You connect that funny little cable into the wall and Google appears. How many people actually think about how that all works? It’s a service, it’s there and it works. Do people complain when their lightbulbs flicker? Issues with the Internet are even more subtle. If you can’t get to Twitter, the default response is “Twitter is down”, not “My ISP is broken”. Expecting a mass-revolt from the non-technosavvy people due to poor access is credulous.

Even assuming there was the demand for a Net Neutral ISP, starting such a business is an expensive and complex proposition. With low margins, the only way to survive is to have a large user base. The market approaches saturation in the UK and the costs and hassle for users involved in switching providers are prohibitively high.

Large amounts of startup capital are needed to start an ISP, and they won’t even be playing on a level playing field because the other ISPs will be working from a larger revenue base with the additional dues they are extracting from the content providers.

Once non-neutral ISPs are here, they’re here to stay. Denying a revenue stream from forming is one thing, but ISPs and shareholders will cry foul when you try to take it away again and “lower shareholder value”.

The only solution is Net Neutrality, and it needs to be enshrined in law now. Ed Vaizey must be convinced that he is on the wrong track and that his current thinking represents a clear and present danger to the future of the Internet.

In a recent post, I outlined a method to abstract away the complexity of creating an encapsulated jQuery plugin. However, as was pointed out in the comments, there was a missing piece that didn’t allow for arguments to be passed through. More seriously, there was an issue with the binding of the facade function, which meant that only the last defined public function in the class could be called.

As an aside, if you need to bind a variable at the time that it is defined, it isn’t enough to define an anonymous function with a reference to the closure, as that can change by the time the function is called. The bug in my code was in the piece that bound the facade function to the set member functions.

	for ( var i in template) {
		if (typeof (template[i]) == 'function') {
			result[i] = function() {
				this.each(function() {
					this[i]();
				});
			};
		}
	}

By the time the inner function is called, “i” has already been re-bound to the final function name in the template. The solution is to bind the inner function name to the outer function name at the time of definition, which we can do by wrapping it in (yet another!) function.

	// Iterates through the set calling the specified function.
 	function makeIteratorFunction(f, set) {
		return function() {
			for ( var i = 0; i < set.length; i++) {
				set[i][f].apply(set[i][f], arguments);
			}
		};
	}

and then calling that function:

	if (template) {
		for ( var i in template) {
			if (typeof (template[i]) == 'function') {
				result[i] = makeIteratorFunction(i, result);
			}
		}
	}

At this point, although “i” will continue to change as the loop continues, the function call is bound through the closure on “f” in the auxiliary function, which remains fixed. Google Chrome’s developer tools certainly make following all that a lot simpler! I’ve updated the plugin with these improvements, which also enables us to pass arguments through, finally allowing:

$('#foo').myplugin().publicMethodWithArguments('hello');

You can get the updated plugin here. Feedback welcomed!

Update: As pointed out in the comments, the first version of this code didn’t allow for methods with parameters. Although the code in the main post below is unchanged, the code linked at the bottom of the page and here has been updated to reflect some improvements, that now allow this and some other niceties. The main body of the post should still be worth reading for the derivation though!

I’ve recently begun the process of porting some javascript library code from Prototype to jQuery, and on the whole it hasn’t been too problematic. I really like the element-centric nature of jQuery, whereas Prototype is more like a excellent set of useful static methods. There were only a couple of things I found myself really missing, and they were enumerables, and elegant plugin encapsulation. The first problem was solved with Xavier Shay’s nice enumerables plugin. The second one was more of a challenge.

The lack of encapsulation for jQuery plugins seems to be a common frustration, and there are lots of queries on the web along the lines of “how do I add public methods to a jQuery plugin”. The best solution I found came from Hector Virgen, which allows you to do something like this:

var pluginInstance = $('#foo').data('myplugin');
pluginInstance.publicMethod();

That’s pretty neat, but I didn’t really like the idea of having to go through the data object each time. A couple of other people in the comments felt the same way, but there didn’t seem to be any solutions forthcoming, so I had a crack. What follows is largely based on Hector’s code, so you should go and read that first before you go through this.

We start off with a basic plugin shell, slightly modified from Hector’s, per my taste:

(function($) {
	var Celsus = Celsus || {};
	Celsus.MyPlugin = function(element, options) {

		// Private members
		var elem = $(element);

		var settings = $.extend({}, options || {});

		// Private methods
		function _privateMethod() {
			console.log("This is a private method!");
		}

		return {
			publicMethod: function() {
				console.log(elem);
				_privateMethod();
				return true;
			}
		};
	};

	$.fn.myplugin = function(options) {
		return this.each(function() {
			var element = $(this);
			if (element.data('myplugin')) {
				return;
			}
			var myplugin = new Celsus.MyPlugin(this, options);

			// Store the new plugin definition in a data object.
			element.data('myplugin', myplugin);
		});
	};
})(jQuery);

This is a pretty good start. However, as Hector points out, the main issue is that the plugin returns a jQuery object to enable chaining. In many complex instances, chaining isn’t necessarily something you’re going to want to do, so we make a small sacrifice and forego that convenience. Instead, we are going to return a set of plugin instance objects:

$.fn.myplugin = function(options) {
	var result = [];
	this.each(function() {
		var element = $(this);

		if (!element.data('myplugin')) {
			// Initialise
			var myplugin = new Celsus.MyPlugin(this, options);

			// Store the new functions in a validation data object.
			element.data('myplugin', myplugin);
		}
		result.push(element.data('myplugin'));
	});
};

At this point, it’s not looking too great. We’ve broken chaining because we no longer return a jQuery object, but if you try and call

$('#foo').myplugin().publicMethod();

it still doesn’t work. This is because, although each plugin instance has the publicMethod() function, they are contained inside a bare array. At this point we could actually do:

($('#foo').myplugin()[0]).publicMethod();
($('#foo').myplugin()[1]).publicMethod();

Or something similar with each(), but this is very messy. We need a bit of syntactic sugar. To achieve this, the next step is to take that array, turn it into something we can work with, and add a facade, so that every public function we’ve just mixed in is presented as an option on the plugin instance set. We do that by adding the following to the plugin definition:

result = $(result);
var template = result[0];
if (template) {
	for ( var i in template) {
		if (typeof (template[i]) == 'function') {
			result[i] = function() {
				this.each(function() {
					this[i]();
				});
			};
		}
	}
}

Firstly, we convert the array to a jQuery object. Then, we look at the first instance in the set and use that as a template. It should contain all the public functions we’ve defined in our definition class, and all the instances are of the same type, so we can safely use the first entry’s template for all of them. We then enumerate through all the public functions and create a proxy or facade function on the set, which simply calls the closure of that function for each element in the set. This ensures that when you call

$('#foo').myplugin().publicMethod();

it is functionally equivalent to:

$('#foo').myplugin().each(function(instance) {
	instance.publicMethod();
});

So that’s pretty cool. We’ve avoided namespace pollution, we can mix in any number of public methods, and private members and methods behave as you’d expect them to. It isn’t possible to access public variables in this manner of course, but that is easily remedied by using public getters and setters. We can even add in a reference back to the jQuery object, so we can get chaining back in in some form:

result.$ = this;

Which lets us do:

$('#foo').myplugin().$.addClass('bar');

This is useful when you’re doing plugin initialisation, but thereafter it’s a bit redundant as the actual plugin call simply returns an object which you then ignore. The only final point is that there’s quite a lot of boilerplate going on here just to get set up. In actual fact, the actions are pretty generic, so we can extract all that code and put it in its own plugin. A plugin to generate a plugin!

(function($) {
	$.fn.encapsulatedPlugin = function(plugin, definition, objects, options) {
		var result = [];
		objects.each(function() {
			var element = $(this);

			if (!element.data(plugin)) {
				// Initialise
				var instance = new definition(this, options);

				// Store the new functions in a validation data object.
				element.data(plugin, instance);
			}
			result.push(element.data(plugin));
		});

		// We now have a set of plugin instances.
		result = $(result);

		// Take the public functions from the definition and make them available across the set.
		var template = result[0];
		if (template) {
			for ( var i in template) {
				if (typeof (template[i]) == 'function') {
					result[i] = function() {
						this.each(function() {
							this[i]();
						});
					};
				}
			}
		}

		// Finally mix-in a convenient reference back to the objects, to allow for chaining.
		result.$ = objects;

		return result;
	};

})(jQuery);

With this little plugin, our plugin initialisation code is a lot lighter:

	$.fn.myplugin = function(options) {
		return $.fn.encapsulatedPlugin('myplugin', Celsus.MyPlugin, this, options);
	};

Not too bad! The actual code that specialises a plugin is tucked away in a neatly encapsulated object, we have access to all the public methods defined on it and multiple instances can happily live side by side and be invoked separately without trampling on each other. You can grab a copy of the plugin generating plugin from here. This is still new cod and there might be the odd glitch, so if you spot any, or have other ideas, be sure to leave a comment!

A typical use-case of the new syntax is to lazy-load static variables in inherited child classes, which offers you the choice of avoiding the overhead of object-instantiation to provide class differentiation. Unfortunately, it is not quite as straightforward as you might think. Consider the following piece of code:

class BaseClass {

	static $_value = null;

	public static function getValue() {
		if (null === static::$_value) {
			static::$_value = get_called_class();
		}
		return static::$_value;
	}
}

class ChildAClass extends BaseClass {}

echo BaseClass::getValue() . "\n";
echo ChildAClass::getValue() . "\n";

What’s going on here then? When I look at that piece of code, I expect the output to be:

BaseClass
ChildAClass

Instead, it appears the call to ChildAClass::getValue() fails the conditional test and returns the static value of BaseClass, giving the following output:

BaseClass
BaseClass

Not very helpful. How can we work around this? The answer is to ensure you declare the static variable in each of your child classes as well as the parent. It’s straightforward enough, but a pain to remember every time. The following example demonstrates:

class ChildBClass extends BaseClass {

	static $_value = null;
}

echo BaseClass::getValue() . "\n";
echo ChildBClass::getValue() . "\n";

BaseClass
ChildBClass

So it appears (at least for PHP 5.3.3 (OS X)), that static only really means static if you declare it yourself each time. This might be expected behaviour, but I consider it a bug, and it can certainly lead to hard to debug situations. It doesn’t seem to be documented clearly in any standard location that I could find.

Short story – if you are looking to lazily-populate static variables using the new syntax, be sure to declare the variables in all of the child classes you are going to use!