Arjan van der Gaag's tumblelog

Attention Deficit Disorder by Ricardo (via gamesdaypodcast)

Wed, 10 Mar 2010 21:49:54 +0100

Attention Deficit Disorder by Ricardo (via gamesdaypodcast)

Test apache configuration syntax

Wed, 10 Mar 2010 10:33:25 +0100

Recently my Mac OS X stock install of Apache failed to launch properly. The regular system preferences interface stopped and started Web Sharing without complaining, but I could not find httpd actually running using ps -ax | grep httpd in the terminal.

I was at a loss to explain why, until I found this little gem that you can use to syntax-test your configuration files with: apachectl -t will report on any errors in httpd.conf or any of your other included files.

It appeared that some time ago when I was attempting a manual upgrade of my Subversion install to 1.6.9 some Apache modules were corrupted. As I have no use for them I disabled them.

That did the trick, and now I’ve got my local development environment up and running again.

Javascript: typeof NodeList

Fri, 05 Feb 2010 11:50:17 +0100

Beware of Javascript’s quirky typeof:

typeof document.getElementsByTagName('p')

This will return 'function', which I did not expect. What is returned is a NodeList, which behaves like an array, identifies itself as a function, but really is neither.

If you want to detect a NodeList you’re better off with feature detection:

var isNodelist = (typeof myvar.length != 'undefined &&
  typeof myvar.item != 'undefined')

Do note that this makes it probable you’re dealing with a NodeList — but you can’t be sure.

Getting Things Done with Rituals

Wed, 16 Dec 2009 09:44:39 +0100

In order to achieve real productivity you need to get into the zone. Context switches take you out of the zone and should therefore be managed carefully. Get rid of multitasking.

I’ve found the mental overhead of context switches can be reduced with a clear start and end for a tiny break from work. A ritual provides such clear boundaries. I use several rituals throughout my day: reviewing my to do’s, drinking a cup of coffee while skimming through the news, getting a cup of water, and so forth. Even the daily commute between home and work helps ‘switching off’ at the end of the day.

I’ve grown used to them over time. I think I now get why people are so resistant to change…

"In retrospect, all revolutions seem inevitable. Beforehand, all revolutions seem impossible."

Tue, 08 Dec 2009 09:19:56 +0100

“In retrospect, all revolutions seem inevitable. Beforehand, all revolutions seem impossible.”

- Michael McFaul

loveallthis: Inspired by jeannr, I flowcharted the Beatles...

Tue, 03 Nov 2009 23:55:34 +0100

loveallthis:

Inspired by jeannr, I flowcharted the Beatles classic, ‘Hey Jude.’

jQuery custom selectors

Wed, 14 Oct 2009 09:52:42 +0200

I like writing jQuery plugins, so I can separate functionality into distinct units. But applying the plugin sometimes requires some logic I’d rather have in my plugin itself.

Example code

Say I want to create a plugin that creates a lightbox-style image zooming effect. I want to apply it to all links pointing at an image:

Here’s how I might call my awesome plugin in my main javascript file:

$(function() {
    // One option: create complex inline selectors:
    $('a[href$="jpg"], a[href$="png"]).awesome_plugin();

    // Second option: filtering
    $('a').filter(function() {
        $(this).attr('href').match(/\.(png|gif|jpe?g)$/);
    }).awesome_plugin();
});

These both might work, but they move typical plugin logic to my javascript initializer. That’s not what I want.

Custom selector

The solution is so obvious I wonder why I did not think of it before: write a custom jQuery selector:

$(function() {
    $('a:to_image').awesome_plugin();
});

Awesome: concise and with clear intent. Here’s one way to implement it:

// Somewhere in my plugin
$.expr[':'].to_image = function(obj, index, meta, stack) {
    return $(obj).attr('href').match(/\.(png|gif|jpe?g)$/);
};

Now all the logic is nicely tucked away in my plugin.

GTD with OWA

Tue, 22 Sep 2009 10:31:43 +0200

Relying on Microsoft Outlook Web Access without Internet Explorer can be tiresome — being served a static web application that would have annoyed even in 1996 — but it is kind of relaxing too: the effort of constantly logging in and taming the horrible interface to get to your mail is a real motivator to get some actual work done.

via thisishistorictimes.com

Sun, 20 Sep 2009 21:34:14 +0200

via thisishistorictimes.com

"Your request to not receive promotional emails about your subscription has been received and will be..."

Wed, 16 Sep 2009 14:59:19 +0200

“Your request to not receive promotional emails about your subscription has been received and will be processed within the next 10 working days.”

- FT.com customer service: 10 working days to unsubscribe from your mailing list? That’s crazy fast! They must be using some kind of “computer”. Amazing…

Attractive piracy

Wed, 09 Sep 2009 10:09:04 +0200

The problem with internet piracy is obvious: downloading illegal materials is easier, cheaper, faster and the acquired content is more portable, than with any legal alternative. The solution would be to close the gap between the desirability of illegal versus legal content distribution from the consumer’s perspective.

Too bad then, that the music and movie industries take the producer’s perspective, trying to make illegal downloading less attractive, rather than legal downloading more attractive. That is why they get so little public sympathy, I reckon.

Subversion branching

Tue, 08 Sep 2009 11:28:40 +0200

The main reason why developers should use Git for versioning is cheap, cheap branching. But in Subversion it isn’t so hard that you shouldn’t use it. Here’s a basic bugfix branch workflow. First, create your branch:

svn copy /path/trunk\
         /path/branches/my-new-branch\
         -m "Create my new branch"
svn switch /path/branches/my-new-branch

Of course, /path/ is easy enough to find:

svn info | grep URL

Hack away, make some commits, and when you are ready to merge to branch back into trunk:

# Note the revision that started this branch
# assume this tells you '4362'
svn log --stop-on-copy

# Get back to trunk and merge in your changes
svn switch /path/trunk
svn merge -r 4362:HEAD /path/branches/my-new-branch

Inspect your changes, resolve conflicts and make sure everything is alright. Commit your changes…

svn commit -m "Merge in branch 'my new branch'"

…and then clean up after yourself:

svn delete /path/branches/my-new-branch\
           -m "Remove obsolete branch"

The trick is knowing where your branch started. You can note the revision number when you create the branch, or use svn log to find out.

Beware of changes to trunk before merging in your branch. If trunk has changed since you created your branch (and chances are it has) you should first merge those changes back into your branch, so it stays in sync.

Newer versions of Subversion should make this process a little easier, but this works. Be sure to check out the Subversion manual on branching patterns.

"In many ways, history should be regarded as a globalizing mass medium in the nineteenth century."

Sun, 06 Sep 2009 13:32:08 +0200

“In many ways, history should be regarded as a globalizing mass medium in the nineteenth century.”

- P. Fritzsche, Stranded in the Present

Distribution of Academic Literature

Fri, 04 Sep 2009 10:42:07 +0200

Here’s how I get my academic literature these days:

Let a teacher e-mail me a Microsoft Word file with references.
Print the file
Go to the library, look up the titles and wait an hour before fellow students return them.
Copy the required pages on dead tree (single-sided).
Go home and scan in the dead tree.
Archive the digital article on my computer, ready to read from screen.
Throw away the copied articles.

Now, I know insisting on reading articles from screen rather than from paper is considered overly geeky, but the solutions for tagging, zooming, searching, portability and annotations make this a no-brainer for me. Regardless, it seems to me this whole process could be a lot simpler, cheaper, quicker, less frustrating and above all consume a lot less paper.

Here’s what I propose:

Teacher copies links to works to a course website, rather than manually adding them to a Word file.
Through the University’s volume discount program students purchase the articles in PDF for a small fee from the publisher.
Those that want to read stuff from paper print it themselves, saving the rest of us a lot of time and money.

It doesn’t sound ridiculous to me.

Snow Leopard Web Development Configuration

Sat, 29 Aug 2009 12:20:28 +0200

After installing Snow Leopard on my iMac I found I had to tweak some settings before I could continue my daily web development workflow. First, you should note Snow Leopard now comes with PHP 5.3 and it will overwrite your custom Apache configuration.

Here’s what I did to get up and running:

Moved /etc/php.ini.default to /etc/php.ini.
Edited php.ini (using search/replace) so that display_errors = On and mysql.default_port = /tmp/mysql.sock.
I also set a default timezone (search php.ini for ‘timezone’) to suppress warnings about server timezone being unreliable.
Restored my vhosts.conf file from a back-up to bring back my various *.dev virtual hosts.
I replaced all my PHP short tags with their longer equivalents ( to ) as these are deprecated in PHP 5.3.


After these rather simple steps I was back up and running, although they took a a little time and googling. Overall, I was surprised how little installing Snow Leopard messed up my system.



Internet Explorer, Javascript and base elements
Fri, 21 Aug 2009 10:03:08 +0200
Internet Explorer treats the base element a bit diffently from other browser. I ran into the issue when trying to change the current page’s hash through javascript:

window.location.hash = 'some_value';


Internet explorer took the entire base URL and prepended it to the hash, resulting in an URL like http://domain.tld/http://domain.tld/#some_value. That’s clearly not my intention.

The trick lies in the href attribute for links. This actually points to the faulty long url, while its actual attribute value is only the hash:

...
// IE: http://domain.tld/#some_value
// other browser: #some_value
$('#link').attr('href'); 


The trick is to replace anything before the pound when reading the href value, like so:

$('#link').attr('href').replace(/^.*(?=#)/, '');


And when trying to find links pointing at #some_value to not be too restrictive with your selector:

// finds 1 in other browsers, nothing in IE
$('a[href="#some_value"]')

// works like expected in all browsers; Note the *
$('a[href*="#some_value"]')


Tricky stuff!


Removing deleted files from the Git index
Mon, 17 Aug 2009 14:03:13 +0200
When working with Git it can be cumbersome to have to remove files from the index (marking them deleted rahter missing) if you did not delete them using git-rm. Here’s bash one-liner for that:

git rm $(git ls-files -d)


I’ve got that aliased to grd (Git Remove Deleted).


Argument-specific memoization
Thu, 13 Aug 2009 12:48:47 +0200
There is another way of memoizing expensive operations in JavaScript, which is also fit for argument-specific results:

base._fooCache = {};
base.foo = function(arg) {
    if(base._fooCache[arg] === undefined) {
        base. _fooCache[arg] = ...expensive operation... 
    }
    return base. _fooCache[arg];
}; 


This just keeps a local key/value cache of the result of the expensive operation for the given argument. This only works for a single argument right now, but I guess it could be extended to multiple arguments.


Awesome JavaScript memoization
Thu, 13 Aug 2009 09:05:00 +0200
Here’s an easy way to memoize expensive Javascript functions. It introduces slightly obscure code and an extra function call, but if your operation is expensive enough to memoize, it is probably worth the extra overhead:

this.foo = function(){
    var foo = expensive_operation();
    return (this.foo = function() { return foo; })();
};


What this function does is redefine itself, so on subsequent calls it only returns a static value. Neat.


Science & Religion
Tue, 21 Jul 2009 09:03:08 +0200
Science and religion are not as incompatible as many seem to believe. The scientific method implies the use of logic and reason towards falsifiable theories. When you weigh pros an cons, and take into account all available evidence, there is nothing wrong with believing in a supreme being. I personally don’t believe that, bu to each his own.

I do have a problem with people who reject science as if it were anti-religious. Such people choose to only hear the story they like best, not which one they think describes reality best.