Emergency Use Only


London, August 2014

David Heinemeier Hansson on Ambition

It might sound funny, but I’m not a very ambitious person. When it comes to software and products, I have a very low bar in terms of ambition level. I feel like there is so much stuff that is so poor, where the things you have to do to improve, just have to be just a little bit better.

David Heinemeier Hansson Jellyvision Q&A with DHH & Jason Fried


The gift of attention is perhaps the most valuable. Attention may seem like an easy gift to give, but it is not; it is the scarcest resource available because its quantities are limited and nonrenewable. We can’t produce more attention, and there are ever more things vying for it each day.

Frank Chimero The Shape of Design

The Not-So-Straight & The Not-So-Perfect

The not-so-straight and the not-so-perfect is the lovely thing of life. And there’s somebody out there trying to make the world straight and perfect…When the world will be straight and perfect in their eyes, will that be straight and perfect, or will it be worse?

Analogue People in a Digital Age Twopair Films

Aphex Twin on Smartphones

I don’t have any phones. They’re just not good for anything. They’re handy for loads of stuff, but I can’t think of anything that’s better because you’ve got them. I think there’s a risk of people becoming zombies with Facebook and social media. It’s really awful, that side of things.

Aphex Twin ‘Syro’

Barcelona 2014

14-08_2117_lomo-lca_kodak-colorplus-200_13.jpg 14-08_2117_lomo-lca_kodak-colorplus-200_05.jpg 14-08_2117_lomo-lca_kodak-colorplus-200_35.jpg 14-08_2116_olympus-mju-ii_kodak-gold-200_20.jpg 14-08_2117_lomo-lca_kodak-colorplus-200_09.jpg 14-08_2117_lomo-lca_kodak-colorplus-200_32.jpg

More photos in the Barcelona 2014 set.

Preferences in User Interface Design

Jef Raskin on “Modes, User-Preference Settings, and Temporary Modes”, in The Humane Interface:

Facilities for setting user preferences constitute an example of modes and are a major source of frustration. Ironically, these features are usually touted as a benefit. Present user interfaces are often so difficult to use that a user may feel an urge to rearrange them. Microsoft specifically recommends that such facilities be provided: “Users, because of their widely varying skills and preferences, must be able to personalize aspects of their interface … such as color, fonts, or other options.” [from Microsoft’s Windows Interface Guidelines, 1995]

… By providing preferences, we burden users with a task extraneous to their job function. … Time spent in learning and operating the personalization features is time mostly wasted from the task at hand.

… Customization sounds nice, democratic, open-ended, and full of freedom and joy for the user, but I am unaware of any studies that show that it increases productivity or improves objective measures of usability or learnability. Adding customization certainly makes a system more complex and more difficult to learn. I suspect that if you were to take a user survey, more people than not would be in favor of lots of personalizable features … [but as] has been observed in a number of experiments, an interface that optimizes productivity is not necessarily an interface that optimises subjective ratings.”

See also: Avoid Preferences from Getting Real.

(I’m looking at you, Slack)

Array Controllers in Ember.js

An array controller is a wrapper for a collection of objects, and provides convenient methods for dealing with its contents.

An array controller’s model is typically set in a route, for example:

App.IndexRoute = Ember.Route.extend({
  model: function() {
    return [
      {name: 'red'},
      {name: 'yellow'},
      {name: 'blue'}
// (The Index ArrayController is setup implicitly)

Setting an array controller’s model sets up its content property, which forms the basis for other properties and methods.


arrangedContent is an important property, defined as “the array that the [array controller] pretends to be”. It provides a way for sorted/filtered content to be stored separately from the original content. In this way, sorting/filtering is not destructive, and the content (in its original form) can still be retrieved.

By default, when an array controller has no sortProperties, arrangedContent and content are the same. When sortProperties are added, the sorted content is stored in arrangedContent whilst the original content remains untouched.

It’s important to note that an array controller should be treated just like an array, with its items referencing those in arrangedContent. Accessing items on an array controller itself, is effectively the same as accessing items in arrangedContent (an important difference is discussed in below).

This is best illustrated with some examples. Given the route above, the following #each loops all result in the same output:

index template:

{{#each}} {{name}} {{/each}}

{{#each content}} {{name}} {{/each}}

{{#each arrangedContent}} {{name}} {{/each}}

Setting sortProperties results in sorted output from arrangedProperty and therefore from the array controller instance itself:

App.IndexController = Ember.ArrayController.extend({
  sortProperties: ['name']

index template:

{{!-- Sorted by name --}}
{{#each}} …

{{!-- Not Sorted --}}
{{#each content}} …

{{!-- Sorted by name --}}
{{#each arrangedContent}} …

Item Controllers

Adding an itemController property to an array controller wraps each item in an instance of the referenced controller. However, this only applies when accessing items through the array controller instance itself. Items accessed via arrangedContent or content remain unwrapped. This is the key difference when accessing items via arrangedContent versus accessing them via the array controller instance itself.

The following example demonstrates this concept:

App.IndexController = Ember.ArrayController.extend({
  itemController: 'color'

App.ColorController = Ember.ObjectController.extend({
  isActive: true

index template:

{{!-- Names rendered --}}
  {{#if isActive}} {{name}} {{/if}}

{{!-- Nothing rendered --}}
{{#each content}}
  {{#if isActive}} {{name}} {{/if}}

{{!-- Nothing rendered --}}
{{#each arrangedContent}}
  {{#if isActive}} {{name}} {{/if}}

Nothing is rendered in the loops that iterate over content or arrangedContent because the items are not wrapped in an item controller and therefore isActive is inaccessible.

{{#each itemController='…'}}

{{#each}} helpers, when supplied with an itemController property, wrap each item in a new instance of the referenced controller. This operates entirely independently from the itemController property on an array controller: an array controller will not have access to any item controller created via an {{#each}} helper.

This becomes particularly important when implementing a computed property on an array controller that depends on properties on an item controller. See the example.

For more information:



London, 2014

Don Norman’s Law

If you think something is clever and sophisticated beware—it is probably self-indulgence.

Don Norman The Psychology of Everyday Things

View more posts in the archive