Licensing for this product has stopped working.

After following every suggestion I could find in Adobe’s knowledge base and various online articles, I still couldn’t get any of the applications to start.

As a final act of complete desperation, after many rounds of removal-reboot-reinstall, I finally ran the installer and chose a product that I had not installed before (Contribute). Once that was done I started up the new app, and it asked me for my license key – which I entered and the app started. Then I tried Photoshop and it started up fine!

So – if you didn’t do a complete install int he first place, one of the easiest things could be to add a new app to your install, and get that to reset your licensing for you.

Shopping

I think there are a few ways you could use a web of linked data to make online grocery shopping better – comparing prices across stores, create shopping lists from recipes, and get recipes from lists of goods.

Recruitment

With jobs and resumés available as linked data, recruitment could become much more machine-enabled, giving managers better abilities to find people themselves rather than relying on agents who don’t always understand their clients’ business or industry. It could also help people looking for work in a similar way. Types of skill, training and qualification could also be linked in, as could “linkedin” style personal recommendations.

E-Learning

Serious attempts have been made at making learning materials shareable and reusable. As part of the data web, finding and consuming these materials becomes easier but more than that we could build a development plan generator. Competency can be aligned to skills or training received, something that could be useful to government departments, schools, universities and business.

http://otaqui.com/code/bbc-fisheye/bbc-fisheye.user.js

// ==UserScript==
// @name           BBC FishEye
// @namespace      http://otaqui.com/code/bbc-fisheye
// @description    Make BBC's Fisheye look more like it should
// @include        https://fisheye.dev.bbc.co.uk/*
// ==/UserScript==
var elems = document.evaluate(
    '//select[@name="wbauthor"]',
    document,
    null,
    XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE,
    null
);
var i=0;
var sel;
while ( sel = elems.snapshotItem(i++) ) sel.style.width = '200px';

All my projects live under a single parent directory, and I prefer to share a single users digest file between them all – so ideally I wanted to share a single tracd to run all my projects. This is fairly straightforward on the command line:

tracd --hostname=webhost.com -p 9876 \
--auth="*,/path/projects/people.htdigest,Realm" \
/path/projects/p1 \
/path/projects/p2

That is ….
Line 1 – start tracd for a given hostname and port,
Line 2 – specify auth for all projects (*), the auth file and the “Realm” you specified when creating the file with apache’s htdigest command
Lines 3+ – specify as many projects as you want to run

This is ok with a couple of projects, but gets unwieldy quite quickly. What I needed was a little shell script to open up all projects under a given directory quickly. Here’s what I came up with:

#!/bin/bash

# make / truncate a temp file to store names:
temp=/tmp/tracdpaths
> $temp

# specify base directory:
base=/path/projects/

# output all subdirectories to temp file:
find $base -maxdepth 1 -mindepth 1 -type d \
-exec echo -n "{} " > $temp \;

# now start tracd
tracd --hostname=webhost.com -p 9876 \
--auth="*,/path/projects/people.htdigest,Realm" \
`cat $temp`

Essentially this script uses ‘find’ to get all of the directories exactly 1 level down from your projects directory, and will echo their paths to a temp file (suppressing the newlines). It will then run run tracd, appending the contents of this file to the end of the call.

If you’re using Mechanize through Webrat though, things are a little different. The nice thing though, is that you can do this in a step definition – allowing features to be based on different browser scenarios (this is great if you’re developing across devices).

First off there are two accessors of interest in mechanize, “user_agent” and “user_agent_alias”. The former is fairly self evident and lets you define the user agent at will, the latter gives you shortcut access to a list of common user agents baked into mechanize. You can see that list in the mechanize.rb source. It contains some desktop browsers, the iPhone and the default Mechanize UA strings.

If you’re happy with the default alias list, you can just write a step definition like this:

Given /^I am using the "(.*)" browser$/ do |browser|
  webrat.adapter.mechanize.user_agent_alias = browser
end

And then you can use this in your features:

Given I am using the "iPhone" browser
When I visit the home page
Then I should see "You are using an iPhone!"

If you want to be able to specify your own UA strings, and as I said this is especially likely if you are developing cross-device applications where capabilities are important, then you can just use your own hash instead, and set “user_agent” rather than “user_agent_alias”:

Given /^I am using the "(.*)" browser$/ do |browser|
  UA_ALIASES = {
    "Nokia N95" => "Mozilla/5.0 (SymbianOS/9.2; .....",
    "Palm Pre" => "Mozilla/5.0 (webOS/1.0; ....."
  }
  webrat.adapter.mechanize.user_agent = UA_ALIASES[browser]
end

With a little tweaking you could use both the included list and, if the string from your feature isn’t there, look in a custom list too.

Waha, a user on the chromeplugins.org site posted a much more complete list of URL schemes that Chrome uses. Waha was looking at the url_constants.cc source file, along with some other stuff, to work this list out.

I’ve ignored the virtually universal set of protocols that are in just about every browser: http, https, ftp, file, data, feed and javascript, and also the URLs that cannot be entered into the address bar (not using Chrome 5 on OS X Snow Leopard anyway).

Without further ado, here’s the list:

• about:blank – the empty page
• about:cache – disk and memory cache information
• about:net-internals – network information including Proxy, HostResolver, URLRequest, HTTPCache and SocketStream
• about:crash – the page shown when a tab process crashes
• about:credits – list of libraries and other code used in Chrome, with links
• about:hang – this seems to kill a tab for me (I haven’t linked for that reason – use at your own risk)
• about:memory – memory usage of the various processes
• about:shorthang – see about:hang above
• about:terms – Google Chrome Terms of Service
• about:inducebrowsercrashforrealz – not many lolz here
• chrome://extensions/ – installed extensions
• chrome://history/ – your browsing history
• chrome://newtab – the new tab page
• chrome://thumb/http://www.google.com/ – thumbnail for a page you’ve visited
• chrome://favicon/http://www.google.com/ – favicon for a page you’ve visited
• view-source:http://otaqui.com/blog/539/complete-list-of-special-google-chrome-urls – view the source of a web page

This gem was originally designed to work with Cucumber, and initially was intended to just validate pages against the XHTML Strict doctype that BBC pages are usually required to use. Since it uses Nokogiri for validation – against the XML Schema rather than the Doctype for what it’s worth – the testing is a) strict and b) *fast*. There are no external webservice calls, so it is fine to test all page loads within Cucumber, even testing the same URI many times over (since the bottleneck will almost certainly be your app by some margin.

I’m currently working on a post about using the gem for the BBC Web Developer blog, but I thought I’d point any interested parties at the code here and now.

[NB: I always have an external cake core directory, for easy swapping. The code examples all assume you have done this, or at least created an alias in your terminal to point to the core cake directory with something like: alias cake='../cake/console/cake'

First off, to find out about the current console applications you are running jump into a terminal and cd to your app directory, then simple run the “cake” command to see what you have available:

app_dir $ cake

This will output a list of available shells in the core cake library and the two “vendors” directories.

So how do you go about creating your own? The CakePHP documentation on creating Shells & Tasks is a good place to start.

An application I’ve needed to automate with a cron-job, and also have available as an in-app, on-demand function is the sending of emails. I’m not talking about writing a mass mailer here, but rather just sending out course information to users who are booked to attend – and doing so both automatically and on-demand when an administrator decides it is necessary. This is an obvious instance where you don’t want to duplicate the code in the controller and the shell.

In my case, I have several kinds of email I want to send, so I set up a generalised Task, used by several different Shells. The advantage of doing things this way around is that any other Shells can also make use of the emailer Task in the fututre.

Here’s some simplified code from one of the Shells, a “booking reminder” for delegates:

// file app/vendors/shells/booking_reminder.php
<?php
class BookingReminderShell extends Shell {
  var $uses = array("Booking","User","Course");
  var $tasks = array("Emailer");
  public function main() {
    // use $this->Booking etc as if we were in a controller
    // use $this->Emailer for the task
  }
}

And then we have the Task:

// file app/vendors/shells/tasks/emailer.php
<?php
class Emailer extends Shell {
  public function execute() {
    // this method is called when the task is instantiated,
    // gives you a chance to setup
  }
  public function send($to,$from,$subject,$message,$attachments=null) {
    // called from shell with: $this->Emailer->send();
  }
}

Note how both Shells and tasks extend from the base “Shell” class. Also note how Shells use a method called “main()” when they are run, whereas Tasks use “execute()” when they are created.


When /^I am on (.+)$/ do |page_name|
webrat.adapter.mechanize.set_proxy('proxy.host.com',8080)
visit path_to(page_name)
end


I’m sure there’s a tidier way to do this, but it’s quick and it works with the following gem versions:

Cucumber 0.3.11
Webrat 0.5.3
Mechanize 0.9.3

In order to circumvent this add this to your “app_controller.php” file (which sits directly inside the “app/” dir, rather than in “app/controllers”):

<?php
class AppController extends Controller {
  var $components = array('RequestHandler');
  var $helpers = array('Html','Form','Ajax');
  function beforeFilter() {
    if ( $this->RequestHandler->isAjax() ) {
      Configure::write('debug',0);
    }
  }
}
?>

Note that while this will disable the debugging output, it will also have other affects too (for the life of the Ajax Request) like extending the length of time that the “schema” is cached. This should make little or no difference, but is worth remembering.

I think almost regardless of it’s performance improvements the real game-changing potential here is the inevitable swathe of add-ons and extensions that will be, and in some cases such as NoScript already are, available.

I don’t think that any web developer who has used it would want to go back to a world without Firebug and I also think that it’s influence on WebKit‘s developer tools is fairly clear to see.

So I really hope that support for Fennec spreads beyond the Nokia 810 soon, and that it’s as instrumental as Firefox was in re-igniting browser development, especially from a developer-tool perspective.

This is usually considered to mean “before the user has to scroll down” but can also just mean “the stuff they look at first” even if they have a really big monitor. This gives us a slightly more useful thing to think about – the first “batch” of content that will be at the top of the page, and incidentally will be the entirety of what a considerable portion of our users see first.

So, I have a suggestion to all the web *designers* out there to mull over: introduce the idea of “Two Rows” in your design. By having a single row that is for content “above the fold” and a second one for everything below, we can get the absolute minimum “perceived load time” of the page.

Let’s have a look at a fairly standard wireframe of a page:

Normal three column page layout

This will be more or less as you expect, a header and footer with 3 (or however many) columns in between.

Now let’s have a look at a wireframe designed for the fold:

Optimised For the Fold Layout

As you can see, I’ve changed the structure to split the main content completely into two distinct rows.

The advantage here is that we developers can do several things to make the first row appear as quickly as possible:

1. Firstly we don’t have to do anything. The source order itself will mean that the content of the first row is loaded first, meaning that you won’t have that all-to-common “pause for the right-hand-column” to load.
2. Place all styles at the top of the page, and all required scripts between the two rows – this will make the page appear correctly styled and have javascript-driven functionality available.
3. Taking the point above to a further degree, we could in fact *split* the javascript (and possibly even css) files, which is normally a abad idea, to provide only the functionality required for the “first row”, and then load other resources afterwards. This is a rather extreme approach, but could help if your site really needs the content “above the fold” to be absolutely as fast as possible even at the cost of overall page performance.
4. With a dynamic site, we can flush the buffer after the first row, and leave any further processing overhead to happen after that much of the page has been sent to the browser.

There is no real need for the actual design to exagerate the rows in the same way that the wireframe does – but you would need a horizontal split of the content at that point to make things as easy and flexible as possible. This limitation can be overcome with CSS, and possibly javascript, but this will rapidly become fiddly and hard to maintain.

To demonstrate what I mean, I took the Guardian’s homepage, and reworked it (as a graphic) to have the horizontal split required for Two Rows, without really appearing much different to the current, pure-column structure.

Before:

Original Guardian Homepage

And after (with the “second row” being slightly greyed out):

Modified Guardian Page

This example worked fairly well in terms of “hiding” the row lines since some things are bumped right up to them and others have varying amounts of whitespace either side.

I must admit that I’ve never implemented this technique, but I certainly believe that it could have significant impact for a site like the Guardian that has a large amount of content “below the fold”.

<?php
require_once (LIBS . 'model' . DS . 'datasources' . DS . 'dbo' . DS . 'dbo_mysql.php');
class DboMysqlEx extends DboMysql {
   var $description = "MySQL DBO Driver - Extended";
   // Override resultSet to allow for Model__field type aliases
   function resultSet(&$results) {
		if (isset($this->results) && is_resource($this->results) && $this->results != $results) {
			mysql_free_result($this->results);
		}
       $this->results =& $results;
       $this->map = array();
       $num_fields = mysql_num_fields($results);
       $index = 0;
       $j = 0;
       while ($j < $num_fields) {
           $column = mysql_fetch_field($results,$j);
           if (!empty($column->table)) {
               $this->map[$index++] = array($column->table, $column->name);
           } else {
               if (strpos($column->name, '__')) {
                   $parts = explode('__', $column->name);
                   $this->map[$index++] = array($parts[0], $parts[1]);
               } else {
                   $this->map[$index++] = array(0, $column->name);
               }
           }
           $j++;
       }
   }
}
?>

This code, which overrides the default MySQL DBO, allows you to SELECT something AS Modelname__Fieldname (with a double underscore) and will end up populating your result set as you would like it to ($results['Modelname']['Fieldname']).

In order to use a custom datasource, copy the code and save it as “/cake_dir/app/models/datasources/dbo/dbo_mysqlex.php” and edit your “/cake_dir/app/config/database.php” file so that it uses the “mysqlex” driver instead of plain old “mysql”.

This all came from a discussion on the excellent CakePHP Google Group

Grigri posted a copy of his modified MySQL Extended DBO online if you want some more of his nice features like backtracing.

I have a particular setup where values across two tables – a course table and a schedule table which relates to it – can be effectively “overridden”. The idea is that for any given course, one can set “default” values, and then these can be overridden every time a course is actually scheduled to happen.

The courses table looks something like this:

COURSES
id INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY
title VARCHAR(255) NOT NULL
subtitle VARCHAR(255) NOT NULL
description TEXT NOT NULL

SCHEDULES
id INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY
course_id INT(11) NOT NULL
subtitle VARCHAR(255) NULL
description TEXT NULL

Hopefully you can see what I would want during a SELECT – to get the values from the schedules table if they aren’t null, or otherwise get the value from the courses table if they are.

This is achieved with the IFNULL built in function in MySQL. IFNULL takes two arguments, and returns the first argument if it (the first argument that is) is not null, or the second argument if it is. The actual SQL for my example looks like this:

SELECT courses.title, IFNULL(schedules.subtitle,courses.subtitle) AS subtitle, IFNULL(schedules.description,courses.description) AS description FROM schedules LEFT JOIN courses ON schedule.course_id=course.id;

This will give you the “subtitle” and “description” values from the linked table (schedules) if they exist, or the default values from the original table (courses) if they don’t.

/Library/Application Support/living-e/MAMP PRO/db/mysql

I had been looking in my User directory’s version of the same path (which is where MAMP Pro stores config files), but it makes perfect sense in this context that databases are shared while configuration isn’t.

Having just downloaded and installed MonoDevelop for OS X I can say that the process of getting up and running is an absolute breeze – only involving the normal mac ‘download, unpack and drop into Applications’ routine.

MonoDevelop (and indeed Mono itself) allows you to build several types of application – C++, C#, ASP.Net and the like. You can build cross-platform executables – either console-based or with a GUI (the application comes with quick-start project templates for the Gnome# and GTK# tookits) – and also web-based projects. MonoDevelop comes with the xsp server built-in so the code-compile-debug cycle is only a single click away (as a bonus it even opens your browser for you).

MonoDevelop is a Gnome application, so a minor annoyance when using it with OS X is the key-binding setup which requires you to use Ctrl over the Apple key for things like copy, paste and save.

I’m hoping to do some work on a mono-driven ASP.Net application, so I may be posting more on that in the future. For now though – I’d like to give a big thanks (and say congratulations) to the MonoDevelop team.

• Dojo: The Definitive Guide
• Mastering Dojo
• Dojo: Using the Dojo JavaScript Library to Build AJAX Applications

All three books cover the core dojo library and dijit gui controls and also associated tools like the build system.

Dojo: The Definitive Guide

If I ever want to get a book on a subject and there is an O’Reilly Definitive Guide, I will choose that one – mostly based on having the Javascript and Actionscript equivalents. I have to say though that I felt a bit let down with this version, as DTDG isn’t as comprehensive as I’m used to from the series. While the coverage is broad (more so than the other books in this review), it isn’t all that deep in some key areas – missing out on some of the gotcha’s that I have found indispensable when working with Dojo.

I should make it clear that book is very clearly written with clean and helpful examples. It is also written with the clear intention of readers people build solid web applications beyond using Dojo.

DTDG does go into excellent detail about the Dojo environment – bootstrapping, the build system, the dijit life-cycle, browser utilities, OOP with Dojo, Event management and the Publish / Subscribe mechanism, Ajax / JSON / JSONP / JSON-RPC, and more besides. I think few people who aren’t Dojo committers could read and grok the book without gaining considerable insight.

This puts the book in context – it isn’t really for the average developer who wants to get an application up-and-running with Dojo. I would say it is for someone who wants a deeper understanding of the structure of the library, rather than how to hack something together with it. A good example is the explanation of dojo.byId(), a clear detailing of the vagaries of document.getElementById() – and why the former is more useful (however I’ll leave you to go and buy the book to find out the specifics ;).

Mastering Dojo

I would recommend this book without hesitation. I found it informative, helpful and really on-point while trying to create a fairly heavy application on top of Dojo. Written in the usual Pragmatic Programmer style, it is as easy to read through a chapter as it is to dig into for a specific answer.

Perhaps one omission is the DOH (which the book incorrectly refers to as the Dojo Object Handler) – perhaps correctly citing the fact that it is out of it’s own scope. Given that DOH is dojo agnostic (your project does need to use Dojo to be tested with DOH) I suppose that is fair enough, but I would love to have seen even an introductory chapter on it.

Mastering Dojo is structured in a slightly confusing way – confusing at least if you are used to The Book Of Dojo and it’s well worth searching for terms in the index (unless you’re reading a PDF!) when the chapter titles don’t look as though they contain what you need.

Dojo: Using the Dojo JavaScript Library to Build AJAX Applications

I’m afraid to say that I wasn’t especially enamored of this book – from its tongue-tangling and strangely-chosen title onwards. I felt that it missed a considerable amount about the basics of dojo – which is understandable given its title – without really giving enough detail or insight into building an RIA – which is not.

Using Dojo (the best shortening I can come up with) does give a reasonable introduction to dojo, and covers some of the fundamental forms of usage, but it really isn’t comparable to either of the previously covered titles.

Update 2008-07-03 : Alex Russell, one of the core dojo committers has also reviewed these books.

There were several parts to the problem:

• Iframe Transparency in IE
• Targeting the containing div node, the editor’s iframe tag, and that iframe’s body node
• Ignoring the weird default content that Dojo, or possibly the browser itself, adds to the Editor (a <br /> tag, but with a special attribute in Mozilla browsers)
• Removing the class once the user makes a change to the content

Ignoring all the rest, and a lot of the specifics (since I’m sure there are better ways to achieve all this) I’m just going to note how to get use dojo.connect to respond to a ‘click’ inside the editor area. It’s worth noting that using the normal method’s you would expect sort of work – but only when you click on the Editor’s toolbar rather than the inside the editable area. That being said, here you go:


<textarea dojoType="dijit.Editor" id="dijitEditor">Click Me</textarea>
<script>
dojo.addOnLoad(function() {
 var dijitEditor = dijit.byId('dijitEditor');
 var eBody = dijitEditor.iframe.contentDocument.body;
 dojo.connect(eBody,'click',onEditorClick);
});
function onEditorClick() {
 alert('you clicked the editor window');
}
</script>


NB – Not IE-friendly. This won’t work in IE because of the contentDocument property, which it doesn’t support – but you could use the document.frames[] array instead. Note that the iframe’s id is widgetid+’_iframe’ in all except Mozilla. So something like this:


dojo.addOnLoad(function() {
 var dijitEditor = dijit.byId('dijitEditor');
 var eBody;
 if ( dojo.isIE ) {
  eBody = document.frames['dijitEditor_iframe'].body;
 } else {
  eBody = dijitEditor.iframe.contentDocument.body;
 }
 dojo.connect(eBody,'click',onEditorClick);
});


I really went down the rabbit hole for while chasing ‘ondijitclick’ and the ‘events’ / ‘captureEvents’ properties of the Dijit.Editor, but ended up using this fairly straightforward custom method.

<iframe src="iframe_source.html" id="iframe_id" allowtransparency="true" />

However, if you want to set the transparency with Javascript via the DOM, you must camelCase the property:

document.getElementById('iframe_id').allowTransparency = true;

Note – you must also make sure that <body> tag in the document contained by the iframe is also transparent in order for the parent’s colours to show through.

I had tried running Firefox 2 and 3 in parallel on my macbook, but found that 3 would always try and become the default browser, which annoyed me enough to get rid of it. Now though I’ve gone the whole hog and, while I do have FF 2 hanging around, I’m using 3 full time. The upshot is that I’ve been poking around at what extensions are available for average everyday webmonkey (btw – did you see that webmonkey is back?) and have been updated to work with FF 3 RC 1. Here’s my current list of installed extensions.

Update: 7th May 2008: these all work for Firefox 3 RC 2

AdBlock Plus

A pre-requisite for surfing the public web. Ads are so 20th century!

ColorZilla

Advanced Eye Dropper, Colour Picker and more. Brilliant stuff.

Delicious Bookmarks

Plugs your browser nicely into your delicious account.

Firebug 1.2 Beta

Indispensable. Nuff said.

Googlebar Lite

Ahhh, so much nicer than the big G’s own attempt.

Scrapbook

Sort of like your bookmarks, but actually saves the pages down to your hard drive for offline viewing. You can edit-before-capture and even spider whole sites (or sections thereof). Really quite nice.

TamperData

TamperData is to HTTP what Firebug is to the DOM.

Web Developer Toolbar

An oldie but a VERY goodie! Manage CSS, find stuff and another hot tip – until MeasureIt is updated for FF 3, it also has it’s own ruler system (in the Miscellaneous menu).