We also aren’t talking about arbitrary URLs here. Modern well-designed applications use clean, semantic, and probably RESTful urls. These are urls which are human-readable, have a natural hierarchy to them, and intuitively reflect the underlying data to which they relate.

So, what’s the problem?

Problem: Routers Are Designed for Stateless Servers

Historically, url routing systems are designed for web servers which maintain little to no state about the client which is making the request¹. A typical request/response lifecycle would look something like the following:

1. A url is requested.
2. The server loads all resources corresponding to the url.
3. A response is rendered and sent back to the client.
4. All server-side resources are released.

By not maintaining state, the server is able to drastically reduce its memory-footprint. With this scheme in mind, it makes sense for routing systems to be nothing more than a mapping from url patterns to actions, an example of which is represented in the diagram below:

Here there are four different actions: index, show, edit, and comments, with corresponding url patterns. When a url for one of these actions is requested, the application must load the resource or collection, ensure that the current user has the required permissions to view the page, and render one or more templates.

These days, however, many applications are moving away from the server and into the realm of the client-side single page javascript application. Views are no longer being rendered on the server, pages are no longer being refreshed on each request, and urls are being manipulated through hashes and HTML5’s pushState method. Javascript MVC frameworks such as Backbone and Ember have also arrisen to make these types of applications more pallatable to develop.

State is Ridiculously Cheap on the Client

Most client-side javascript applications probably have access to more memory than the virtual machines that serve them. Much like programming for the desktop, one of the great benefits of single-page javascript apps is that you can freely maintain as much state as you want.

Despite this, javascript routing system are still beholden to the same approach used by stateless servers. Routes are still nothing more than a primitive map from patterns to functions, and the above diagram still applies. This is barbaric. In the context of a client-side application, the url-triggered actions of loading models, checking permissions, and rendering shared layout have become extremely redundant.

Solution: Stateful Routes

A solution for this is to incorporate a more stateful approach to routing. Common state between actions can be extracted into additional states. Consider the following re-factorization:

The above diagram still captures that same url structure as the first diagram, but an intermediate state has been created which encapsulates some common logic. The show, edit, and comments actions all share a parent item state. The item state has some common concerns inside of it that are shared by all its children. Namely, the loading of the resource corresponding to the id, checking read permissions, and loading a common layout.

The idea here is that each leaf state corresponds to a route and as a route is loaded, each state along its path from the root is entered. Edges between states correspond to optional url fragments. Thus, when the url is changed to items/1, both the item and the show states are loaded. Similary, when the url is changed to items/1/comments, the item and comments states are loaded.

So far you might be relatively unimpressed. Sure this is a nice declarative approach to moving some cross-cutting concerns into a better location, but it could be argued that something like controller inheritance could accomplish the same thing. Bear with me.

Stateful Transitions Are Awesome

This becomes really cool when you take into account transitioning from one state to another. For instance, consider the transition on the client from the url items/1 to items/1/edit. This corresponds to a transition from the show state to the edit state. This is captured in the diagram below:

Since both the show and edit states share a common parent state, there is no need for it to be re-entered. All of the concerns inside the item state have already been addressed and it is trivial for the client to know to just change the view.

Transitions between states can also be dicated by more than url fragments. States can be defined by whether a user is logged in, if a post has been published, if the user is an admin, etc. This makes it extremely easy to turn off or provide alternate behavior for entire groups of routes based on application state. Just for fun, here is a diagram for such a case:

Here, there are different routing trees depending on whether the user is logged in or not.

Ember.js RouteManager Plug

This is the part of the blog post where I shamelessly plug a project, Ember RouteManager, which is routing system for Ember.js built with the design I have given in this post. I’m not going to include any code samples here, but I recommend you check it out!

1. Computed Properties and .cacheable()

This one has actually been fixed in the lastest build of Ember, but I’m putting it here since it is still present in the latest 0.9.5 release. Consider the following object:

1
2
3
4
5

var object = Ember.Object.create({
  tags: function() {
    return [];
  }.property()
});

It turns out that if you try and bind to the tags property of the above object, you will encounter an infinite run loop. Any computed property which does not return a primitive value will suffer from this, the underlying cause being due to failing equivalence tests. This fix is to add a call to cacheable() to the end of the computed property:

1
2
3
4
5

var object = Ember.Object.create({
  tags: function() {
    return [];
  }.property().cacheable()
});

Even though the infinite loop issue has been fixed, making computed properties cacheable is generally a good idea and will be more the rule than the exception.

2. firstObject and lastObject

These properties of enumerables are not bindable. Although this was intentional for performance reasons, this is quite unexpected and I hope this to be fixed in the future. For now, you can create a custom computed property as a substitute:

1
2
3
4
5
6

var myController = Ember.ArrayController.create({
  ...
  firstItem: function() {
    return this.getPath('content.firstObject');
  }.property('content.@each').cacheable()
});

3. Combining Static and Dynamic CSS Class Names

It will often be the case that you want an element inside a handlebars template to have both a static css class name as well as class name that is the result of binding to a property. In order to do this in version 0.9.5, use the code below:

1

<div {{bindAttr class="myProperty:dynamicClass alwaysTrue:staticClass"}}></div>

This code will add the dynamicClass class to the div when myProperty is true. The alwaysTrue property is a property you define that always evaluates to true; this will ensure that the div always has the staticClass class.

In the latest build of ember, a shorthand has been created for this:

1

<div {{bindAttr class="myProperty:dynamicClass :staticClass"}}></div>

Specifying just :staticClass (without the alwaysTrue property) will have this same effect.

4. Bound Handlebars Helpers

As it currently stands, handlebars helpers inside of Ember are just normal helpers. They do not have any of the secret sauce which makes them automatically update when the properties they depend on change. In order to make helpers bound to properties, you must add the magic in yourself.

Fortunately, I have created a gist which packages this functionality up into a convenient syntax that is similar to computed properties:

To define a bound helper this way, do something like the following:

1
2
3
4

Ember.registerBoundHelper('currency', function(value, options) {
  if(!value) return ""
  return "$" + value.toString().replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1,")
});

Now you can use this inside of any of your handlebars templates:

1

<span>{{currency myProperty}}</span>

The helper output will auto-magically update when the value of myProperty changes.

5. Each Blocks, Indices, and Metamorph

This one can be very inconvenient at times. Ember’s {{#each}} helper does not provide access to an index property. This can make things such as styling cumbersome. The situation is also compounded by the fact that the DOM-binding library that Ember uses, Metamorph, also adds html metadata (in the form of script tags) to the dom that can break certain CSS selectors.

Consider the following handlebars template:

1
2
3
4
5

<ul>
{{#each myArray}}
  <li>{{this}}</li>
{{/#each}}
</ul>

This template loops over the enumerable myArray and outputs its contents into list item elements. One would intuitively expect to be able to use the :first-child CSS pseudo-selector to give the first element in the list a particular style, but this is not the case. Upon inspecting the DOM, it will be noticed that there is a <script> tag before the first element. In order to work around this, use the nth-of-type pseudo selector.

In some cases, however, using a CSS workaround will not be sufficient and having access to the item array indices will be required. Ultimately, I hope an eachWithIndex helper makes it into Ember’s core, but for now the underlying data must be altered to contain the indices. One easy way of doing this is to create a computed property to this end:

1
2
3
4
5

  myArrayWithIndices: function() {
    return myArray.map(function(i, idx) {
      return {item: i, index: idx};
    });
  }.property('myArray.@each')

The above template could now be rewritten to include indices:

1
2
3
4
5

<ul>
{{#each myArrayWithIndices}}
  <li>{{this.index}}. {{this.item}}</li>
{{/#each}}
</ul>

6. Object Default Value Initialization

The way default values for properties work in Ember is somewhat different from many other languages/frameworks. This will be especially unintuitive for people coming from more traditional object oriented languages such as Java.

Consider the following snippet:

1
2
3
4
5
6
7
8
9
10

var Category = Ember.Object.extend({
  tags: []
});

var animals = Category.create();
var reptiles = Category.create();

animals.get('tags').pushObject('warm-blooded');

console.log(reptiles.get('tags')); // unexpectedly outputs ['warm-blooded']

In the above example both animals and reptiles share the same tags array. In Ember, object property initialization only runs once per class definition. To get around this, you must either move default value initialization into the init method or just re-define the entire array for each instance:

Fix #1:

1
2
3
4
5
6
7
8
9
10
11
12
13

var Category = Ember.Object.extend({
  init: function() {
    this._super();
    this.set('tags', []);
  }
});

var animals = Category.create();
var reptiles = Category.create();

animals.get('tags').pushObject('warm-blooded');

console.log(reptiles.get('tags')); // outputs []

Fix #2:

1
2
3
4
5
6
7
8
9
10
11

var Category = Ember.Object.extend({
});

var animals = Category.create({
  tags: ['warm-blooded']
});
var reptiles = Category.create({
  tags: []
});

console.log(reptiles.get('tags')); // outputs []

Everything I just said also applies to any non-primitive property, such as objects.

7. Metamorph Metadata

Ember plays nicely with other frameworks. For the most part. Sometimes Metamorph gets in the way. For instance, any framework which reliess on cloning DOM elements will probably have some issues (such as jQuery UI’s draggable).

A workaround for this is to clone the element with all of the Metamorph metadata removed. Fortunately, once again I have a gist for this:

8. Run Loop Debugging With Chrome

This one is somewhat more obscure and particular only to Chrome. Ember has the concept of a run loop which batches bindings and does some other neat stuff. Generally speaking, you won’t have to know much about it, except when you do.

When inside the run loop, Ember wraps everything in a try/finally statement (with no catch). In theory this should not affect anything, but Chrome has a particularly nasty bug where the console will swallow uncaught exceptions if they go through a finally (and will also not call window.onerror).

The easy workaround for this is to set Chrome to automatically break on uncaught exceptions, but worth mentioning since there is nothing worse than having to discover exceptions through side effects.

The most recent evolution of the debate, however, has resided around performance. An animation benchmark comparing the two frameworks was posted on Hacker News yesterday. Despite being a contrived example, the results of the benchmark are undisputable: Backbone.js is significantly faster than Ember.js - and by a visible margin. The reason for this is the computational overhead incurred by Ember’s view binding system. A core feature of Ember is a rich, bindable and composable view system which has been designed to simplify common programming tasks. Simply put: Ember.js has been built to make development easier.

Of course Ember.js could be optimized and the gap in the benchmark could be narrowed, but that is moot. What is really happening here is the age old dispute of developer productivity versus application performance. New technologies are constantly being introduced which make the lives of developers easier and encumbent technologies will always defend their trenches. The easiest thing for existing technologies to point at is performance - as grander abstractions naturally incur larger overheads. These might be a little more stark than the Ember vs. Backbone debate, but here are some examples that immediately come to mind:

1. Assemby vs. C: When I was younger, our family computer had a great operating system installed called GEOS). It was a really nice piece of software. Only later in life did I learn that it was written almost entirely in 8086 assembly language. Despite being written in the ultimate low-level language, it ultimately became a slower product than its competitors and part of its demise was due to system complexity.

2. Java vs. C++: When Java was first introduced, it was ridiculed for being extremely slow. Over time, especially in the post-JIT era, it has gained the opposite reputation. In today’s landscape, the JVM is considered one of the faster platform choices, even exceeding C++ in some benchmarks.

3. Static vs Dynamic: Among other things, dynamic language skeptics have always pointed a finger at performance. Even today, lanuages like Ruby and Python are still an order of magnitude slower than some of their static counterparts. Despite this, frameworks like ROR and Django are industry norms. Javascript itself has also defied people’s beliefs and expectations as projects like V8 have taken it to the next level.

There are two things going on here:

The first is summarized succintly by Steve Yegge: “Global optimizations always trump benchmarks.” Even if a framework/language is slower at a granular level, a system with an overall reduced complexity will still run faster. I would much rather live a world where I can do more faster while at the same time benefitting from global optimizations introduced transparently by the framework itself than one where I consciously chose to sacrifice convenience for performance.

Second, slow is relative. It is important to know when performance matters and when it doesn’t. Databases, real-time systems, and heavily trafficked servers clearly benefit from saved cycles. Apparently it makes sense for CouchDB to move to C/C++ from Erlang, but there are also a lot of situations where performance just simply doesn’t matter that much.

The realm of client-side development is a perfect example of this. Where else do you have essentially unbounded access to a modern CPU in order to scale an application to all of a single user? If anything, in most cases there is a glut of CPU resources that are under-utilized. In the case where you absolutely need to ensure a complex animation runs smoothly, any good framework will allow you to break away from its shackles and apply some manual optimization (you should probably be exploring something like WebGL in this case anyways). There are very few reasons to prematurely optimize for performance in client-side web developement.

In all fairness, Ember.js still does have work do to in the performance area and is actively being developed. Backbone.js is also a great framework and a good choice for a number of applications. At the end of the day, however, to fundamentally criticize a javascript framework for being slow is really to suggest that we have reached the limits of front-end web development. I sincerely hope that is not the case. We should all be striving as developers to make our lives as easy as possible. I personally hope that Ember is just the tip of an iceberg and that even more feature-rich, abstracted, and *gasp* possibly slower frameworks are on the horizon.

Due to the recent origins of Ember, one of its biggest shortcomings is a serious lack of documentation. Its website and some related blog posts focus only on the basics and hello world type examples (read todo in the js mvc world). A major reason for this is that the patterns required for a complex application have not yet been added to the core Ember.js codebase. That is not to say, however, that complex Ember.js applications are not already being built.

With that in mind, I have decided to write a series of posts detailing some of the libraries and patterns I have been using for Ember development. In this post, I cover creating a multi-page application: all that is required to swap out different pages and sub-pages as well as tieing everything in to the browser location and the HTML5 history API. Specifically I discuss two libraries that I have written, Ember Layout and Ember RouteManager. You can also skip ahead and see an example application in action.

Meet The State Manager

A core construct inside of Ember is the notion of states managed by a state manager. This is used in many places inside the Ember.js codebase, including managing view render states. Thus, it is only natural for this construct to be used to manage the composition of views as well.

In fact, Ember already has primitive support for managing views inside it’s core. You can do the following:

1
2
3
4
5
6
7
8
9
10
11
12
13

App.stateManager = Ember.StateManager.create({

  rootElement: '#content',

  section1: Ember.ViewState.create({
    view: App.section1
  }),

  section2: Ember.ViewState.create({
    view: App.section2
  })

});

Setting the stateManager’s state to section1 will automatically append the App.section1 view to the element selected by #content. If the state is then set to section2 the old view will be removed and replaced by App.section2.

This is sufficient for extremely basic applications, but breaks down when the demands are more complex. This method is restricted to view hierarchies that are only a single level deep - most often not the case. The canonical example of this is a page with a primary navigation and a sub-page that has its own tabbing system. What is really needed here is a way to dynamically nest views arbitrarily deep.

Layouts

Ember Layout adds an intuitive layout mechanism on top of Ember.js. You can see it in action here. It adds the concept of a handlebars {{yield}} helper which can be used to indicate insertion points of dynamically replaceable content. This should be extremely familiar to anyone with a rails background, but with the added notion of being dynamically replaceable.

Here is a code snippet extracted from the example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

App.main = Em.LayoutView.create({
  templateName: 'main'
});

App.routeManager = Em.RouteManager.create({
  rootLayout: App.main,
  ...
  layoutNesting: App.NavState.create({
    ...
    viewClass: Em.LayoutView.extend({
      templateName: 'layout-nesting',
    }),
    section1: App.SubNavState.create({
      ...
      viewClass: Em.View.extend({
        title: 'Section 1',
        templateName: 'section'
      })
    }),
    ...
  })
});

And the corresponding template code:

1
2
3
4
5
6

<script type="text/x-handlebars" data-template-name="main">
  ...
  <div class="container">
    {{yield}}
  </div>
</script>

1
2
3
4
5
6

<script type="text/x-handlebars" data-template-name="layout-nesting">
  ...
  <div class="sub-container">
    {{yield}}
  </div>
</script>

When the routeManager (i.e. StateManager) goes to the layoutNesting.section1 state, a view instance specified by the viewClass property of the layoutNesting state is inserted into the {{yield}} location in the main template. This newly inserted view also has its own {{yield}} location, which is replaced by the view from the section1 state. Switching to a different state will then automatically reconstruct this view hierarchy.

Routing

At the crux of any single-page web application is a routing system. Although Ember doesn’t natively include/endorse any particular routing system, it plays well with almost anything out there. Options include SprouteCore Routing and Sammy.js.

Ideally, however, due to Ember’s proclivity towards states, a state-based routing solution seems like the most natural fit. This makes even more sense when taken in the context of the view composition system already being state-based.

Ember RouteManager is exactly that, a state-based routing solution. It introduces an extension of StateManager called RouteManager. Consider the following code (irrelevant parts snipped) from the example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

App.routeManager = Em.RouteManager.create({
  rootLayout: App.main,
  home: App.NavState.create({
    ...
  }),
  layoutNesting: App.NavState.create({
    path: 'layout-nesting',
    ...
    section1: App.SubNavState.create({
      path: 'section1',
      ...
    }),
    section2: App.SubNavState.create({
      path: 'section2',
      ...
    }),
    ...
  }),
  routeParameters: App.NavState.create({
    path: 'route-parameters',
    ...
    items: Em.LayoutState.create({
      ...
    }),
    item: Em.LayoutState.create({
      path: ':itemId', // specify the path to take a parameter
      ...
    })
  })
});

I’m not going to go into detail here, but suffice it to say that each possible route is captured as a leaf node in the state tree. State’s can have an optional path property which dictates how the routes map to states in the routeManager. Paths can consist of dynamic parameters (:parameterName), wildcards (*), regular expressions, and static paths. For example, from the above code: setting the browser location to #/routeParameters/5 would map to the routeParameters.item state with the :itemId parameter being populated by 5. Since these states are also layout states, this will also automatically update the view hierarchy as well.

The beauty of this approach is the de-coupling of application state from absolute routes. For some reason, many frameworks enforce a holistic view of the routing system, treating it as a list of mappings from routes to actions. With RouteManager’s approach, state definitions are agnostic to the parts of the route corresponding to their parent, and instead only focus on their local part.

Much of the code inside RouteManager is originally based on SproutCore routing. Thus, it can also use the HTML 5 history api by setting the wantsHistory property.

Caveat

The caveat here is that what I am describing is likely to change as Ember.js evolves. The libraries I have presented are still immature and more conceptual than fully formed. Ultimately Ember’s core will have a solution for this and I will update this post when that is the case.

Stay tuned for the next post in this series where I cover data persistence.

In case it’s not obvious, I spent some time migrating this site over to Octopress.

Over the last several months I have been in a constant search for the perfect javascript MVC framework. Driven by a dire need for the right level of abstraction and features, I have tried out - some more cursorily than others - every framework I could get my hands on. Here lies a brief synopsis of each framework. Lastly, I share the framework which I ultimately decided on.

Specifically, the following four features are very important to me:

• UI Bindings - I’m not just talking about templates, I’m talking about a declarative approach to automatically updating the view layer when the underlying model changes. Once you have used a framework (such as Flex) that supports UI bindings, you can never go back.
• Composed Views - Like all software developers, I enjoy creating modular reusable code. For this reason, when programming UI, I would like to be able to compose views (preferably at the template layer). This should also entail the potential for a rich view component hierarchy. An example of this would be a reusable pagination widget.
• Web Presentation Layer - We are programming for the web here people, the last thing I want are native-style widgets. There is also no reason for a web framework to create it’s own layout manager. HTML and CSS are already the richest way to do style and layout in existence, and should be used as such. The framework should be centered around this concept.
• Plays Nicely With Others - Let’s face it, jQuery is pretty amazing. I don’t want a framework which comes bundled with a sub-par jQuery clone, I want a framework which recommends using jQuery itself.

The Contenders

Here is a table showing all of the frameworks support for the above features. Click through the title for more detail.

1. Backbone.js

Backbone.js is the web’s darling framework. You can’t go anywhere without hearing about it and they have an impressive list of brands using it. This was naturally one of the first frameworks I tried. I used it to build some of our internal administrative features at GroupTalent.

Pros: Strong community and lots of momentum. Underscore.js (which it uses heavily) is also a great framework.

Cons: Lacks strong abstractions and leaves something to be desired. The entire framework is surprisingly lightweight and results in lots of boilerplate. The larger an application becomes, the more this becomes apparent.

2. SproutCore 1.x

SproutCore is what Apple used on its iCloud initiative. Despite having a horrible name, it is actually an extremely well thought out framework. It is also one of the largest frameworks.

Pros: Bindings support. Solid community. Tons of features.

Cons: Overly prescriptive. Hard to decouple from unneeded features. Forces a native-like paradigm. I have a serious problem with any framework which discourages using html for layout.

3. Sammy.js

Sammy.js was a smaller framework that I stumbled upon. Due to its simplicity, it almost didn’t make this list. It’s core feature is a routing system to swap out areas of an application with AJAX.

Pros: Simple learning curve. Easier to integrate with an existing server side app.

Cons: Too simple. Not sufficient for larger applications.

4. Spine.js

Based on the name, Spine.js is obviously heavily influenced by backbone. Like backbone, it is very lightweight and follows a similar model.

Pros: Lightweight with good documentation.

Cons: Fundamentally flawed. A core concept of spine is “is asynchronous UIs. In a nutshell, this means that UIs should ideally never block”. Having built a serious non-blocking realtime application in the past, I can say this is entirely unrealistic unless the backend has something like operational transformation.

5. Cappuccino

Cappuccino is one of the more unique frameworks, coming with its own language Objective-J. Cappuccino tries to emulate Cocoa in the browser.

Pros: Large thought-out framework. Good community. Great inheritance model.

Cons: Out of all the languages you could emulate in javascript, Objective-C would be my last choice. This is coming from an iOS developer. I simply can’t get past the idea of programming Objective-J in the browser.

6. Knockout.js

Knockout.js is an MVVM framework that receives lots of praise from its supporters. It stresses declarative UI bindings and automatic UI refresh.

Pros: Binding support. Great documentation and amazing tutorial system.

Cons: Awkward binding syntax and lacks a solid view component hierarchy. I want to be able to reuse components easily. I also feel like identifying as an MVVM framework is deleterious. Hardly any of these frameworks are MVC, but are of the MV* variety (MVP, MVVM, etc).

7. Javascript MVC

Javascript MVC, in the interest of full disclosure, is a framework that I didn’t spend very much time evaluating.

Pros: Solid community and legacy.

Cons: Awkward inheritance model based on strings. Controllers are too intimate with views and lack bindings. The name is way too generic - the equivalent would be if RoR was called “Ruby Web Framework”.

8. Google Web Toolkit

GWT is a serious client-side toolkit that includes more than just a framework. It compiles Java to Javascript, supporting a subset of the standard java library. Google used it internally for Wave.

Pros: Comprehensive framework with great community. Solid Java-based component inheritance model. Great for behemoth client-side applications.

Cons: Despite what Google says, GWT is not going to stand the test of time. With initiatives like DART its clear that Java is not the future of the web. Furthermore, the abstraction of Java on the client is slightly awkward.

9. Google Closure

Google Closure is more of a toolkit than simply a javascript framework. It comes bundled with a compiler and optimizer.

Pros: Use by Google for many of their major apps. Nice component-based ui composition system.

Cons: Lack of UI-binding support.

10. Ember.js

Ember.js (formerly Amber.js SproutCore 2.0) is one of the newest contenders. It is an attempt to extricate the core features from SproutCore 2.0 into a more compact modular framework suited for the web.

Pros: Extremely rich templating system with composed views and UI bindings.

Cons: Relatively new. Documentation leaves lots to be desired.

11. Angular.js

Angular.js is a very nice framework I discovered after I originally posted this review. Developed by Googler’s, it has some very interesting design choices.

Pros: Very well thought out with respect to template scoping and controller design. Has a dependency injection system (I am a big fan of IOC). Supports a rich UI-Binding syntax to make things like filtering and transforming values a breeze.

Cons: Codebase appears to be fairly sprawling and not very modular. Views are not modular enough (will address this in more detail in the cons of Batman.js).

12. Batman.js

Batman.js, created by Shopify, is another framework in a similar vein to Knockout and Angular. Has a nice UI binding system based on html attributes. The only framework written in idiomatic coffeescript, it is also tightly integrated with Node.js and even goes to the extent of having its own (optional) Node.js server.

Pros: Very clean codebase. Has a nice simple approach to binding, persistence, and routing.

Cons: I very much dislike singletons, let alone the idea of enforcing singleton controllers. Suffers from the same ailments as Knockout and Angular with regards to nested components. I want to be able to declaratively reuse more than just templates. What Ember has over these frameworks is a way to declaratively re-use entire components that are backed by their own (possibly controller-level) logic.

The Winner

At the end of the day, Ember.js is the only framework which has everything I desire. I recently ported a relatively small Backbone.js application over to Ember.js and, despite some small performance issues, I am much happier with the resulting code base. Being championed by Yehuda Katz, the community around Ember.js is also amazing. This is definitely the framework to watch out for.

Of course this list is far from comprehensive. Almost all of these frameworks here were discovered by sheer notoriety, word of mouth, or by being mentioned on Hacker News. I am also not reviewing proprietary frameworks (or frameworks with disagreeable licenses - ExtJS anyone?).

What MVC framework do you use?

For some reason, however, when it comes to front-end web development - meaning javascript - the stack is extremely shallow. Most websites are built on top of native browser functionality with a sprinkling of jQuery and little else. Moreover, this is true even to the extent that it is embedded in the developer culture itself. Javascript frameworks are lauded for their small sizes and even smaller feature sets. Sites exist exclusively to categorize and compile lists of these “micro-frameworks”, exacting requirements of less than five kilobytes.

This is not to say that significant value can’t be created by a framework with a small codebase. However, given the choice between two frameworks with equally well-written code, I would probably opt for the larger framework¹. Choosing a framework for its small size is a premature optimization. Taking this a step further, given a choice between tying together two unrelated “micro-frameworks” and one larger framework, I would definitely opt for the latter.

Tom Dale begins a similar post with the following:

Why does it take big teams, big budgets, and long timelines to deliver web apps that have functionality and UI that approaches that of an iPhone app put together by one or two people?

Although I’m not going to comment on the number of people required in either case, I completely agree with the implicit assertion that mobile development is more efficient. As a developer who has been building desktop, web, and mobile applications for years, I have always felt that, specific to web development, a larger amount of energy goes towards dealing with the frameworks involved, rather than the problem being solved. There is also an uncomfortable, almost nauseating, feeling that my code is not as modular and reusable as I would like and have come to expect from other development stacks.

The reason for this is that javascript frameworks are simply too small and unstructured. Client-side web developers are not building atop strong enough abstractions to bring their efficiency up to par. Even backbone.js, the web’s darling client side javascript framework, weighs in at a mere 4.6kb. Having built an application against backbone, I can attest to the fact that it more closely resembles a philosophy or set of guidelines to develop against rather than a full fledged UI framework.

Yes, I know larger javascript web frameworks exist. SproutCore, Cappuccino, and Google Web Toolkit come to mind. I hear good things about all of these frameworks. However, none of them have come to the level of ubiquity that one would hope. They all suffer from similar ailments: being constraining and forcing a particular native-like paradigm. For instance, there is no reason for a web framework to implement it’s own layout manager. HTML 5 is probably the richest layout system in existence and most modern heavily-designed web applications prefer direct access.

I am constantly searching for a modern client-side javascript framework that has the right level of abstraction. Today, I am extremely excited about Ember JS (formerly SproutCore 2.0). It adds some deep layers of functionality without the constraints and bloat of the original SproutCore. I think it will continue to evolve into an amazing framework. For the future, I am excited about initiatives such as DART. Despite receiving a lot of negative criticism, DART looks promising as a new language for the web (although I would have preferred a raw VM). Particularly, I feel that the awkwardness around implementing packages and re-usable code in Javascript is partly to blame for the current state.

In any case, as web applications continue to become increasingly complex, the emergence of larger and richer frameworks is inevitable - and it’s about time.

My first Android creation was a game called Vocabulary Builder. The gameplay is simple: match words with definitions and vice versa. It has multiple skill levels, tracks your progress, and has a built-in dictionary.

Today, it is the number one Google search result for Android Vocabulary Builder, has a 4/5 star rating, and has around 100k installs. It is monetized with ads and a 99 cent ad-free pro version. Being as this is Android, this translates into me having made roughly $100 dollars from it throughout its entire lifetime. No, seriously. Despite cleverly sneaking ads in between definitions, it’s CPM is practically nothing (an order of magnitude less than some of my iOS games) and of the 100k installs, a whopping 82 have converted to pro users.

But that is neither here nor there. What is interesting (and hopefully worth sharing), is the analytics data that has been collected. Using a free Google App Engine account, I have collected the anonymized result of every single question (within the free account quota). This equates to over a million data points. Ironically, due to the size of the data set, in order to bulk download all of this data in a timely fashion, I had to temporarily upgrade to a paid account. Here I share the toughest and the easiest vocabulary words.

The 25 Toughest Words

To qualify this data, the dictionary used in the game is based on a well known list of difficult GRE-style words. It is not based on the entire English dictionary.

Interestingly, most of these words are not that uncommon, but are clearly used in the context of their 2nd or 3rd definition.

The 25 Easiest Words

For contrast, here is the other end of the spectrum:

If you are reading this and you are interested in word games, check out some of my other titles: Beworded (Android Market, App Store) and Word Topple (App Store).

Today I am launching Misunderstood Pigs (iTunes Link). The gameplay is simple: place objects to save the pigs from an impending onslaught of projectiles.

I had been sitting on this game at 90% completion for at least 5 months, and decided to bite the bullet and spend a few days finishing the last 10%.

The game shares a lot of code from my previous release, Word Topple, including a level editor/framework which is tightly integrated with Adobe Fireworks (which I am debating open sourcing).

Enjoy!

HTML and CSS has always been filled with frustration when it comes to being able to intuitively create layouts and designs. Web developers have long since sacrificed ease of implementation for accessibility and semantic purity. Basic layouts and simple aesthetics frequently require very non-trivial implementations. This is especially apparent to developers who have tasted the forbidden fruit of other platforms such as Flex, Android, et al.

Until the near future. Two CSS 3 features in particular are finally solving this in a major way, making web design palatable to the code minimalist in all of us.

Flexible Box Layouts

The CSS 3 spec has introduced a new module which is supported by all major non-IE browsers as well as the IE 10 preview. This module is the Flexible Box Layout.

Gone are the days of forcing a layout into a float-based implementation. No more negative margins, excessive floating, and clear fixes. This also eliminates the added complexity of having to take into account margins, padding, and border when creating layout styling.

Anyone coming from a Flex or Android background will immediately see the value of this. In Flex and Android, vertical and horizontal box layouts are the backbone of any application. For layouts which aren’t flow based, this is much more intuitive.

For example, consider the following layout:

With the associated markup (styling and browser-specific markup removed):

1
2
3
4
5
6

<div style="display:box;">
  <div>Child One</div>
  <div style="box-flex: 1;">Child Two</div>
  <div>Child Three</div>
  <div>Child Four</div>
</div>

I’m not going to go into detail as to what the code for this layout would look like today, but suffice it to say that any web developer should be intimately acquainted with such code.

There are other new layout modules as well (such as Grid Layout), but none that will play as big of a role in the micro-layout of small items on any website as the flexible box layout.

Nine Grid Backgrounds

I had previously created a jQuery plugin which enables 9-grid scaling support for javascript/css. This plugin has been made obsolete by the border-image style that is finally gaining widespread browser support. Similarly, 9-grid backgrounds have also been supported by frameworks such as Flex and Android for years.

Consider the following image:

Using the border-image style, the following background can be created:

With the associated markup:

1
2
3
4

<div style="border-width: 25px; border-image: url('/old/uploads/2011/11/aqua_bg.png') 25 25 25 25 repeat;
  width: 500px;
  height: 100px;">
</div>

This allows for beautiful raster based backgrounds to be easily applied to fluid width elements. The one caveat here is that additional calculations will be required to take into account the additional border widths (which will be eventually mitigated by the border-image-outset property). In fact, the grid background (only visible on higher resolution screens) on the current theme for this blog is styled using border-image.

Game Changing

Having developed on platforms where these two features are standard, I can say that having these available as tools for web design will enable a new class of beautiful designs. Although nothing here was previously unrealizable with a lot of complex markup and styling, this will go a long way towards HTML becoming a much richer language for user interface.

Having lived through the era of table-based layouts, the era of accessibility driven div hell, and now the onset of CSS 3, I envy the next generation of programmers who take these types of tools for granted.

Spending lots of time both coding and designing has given me an acute awareness of how poor design tools are. Design itself has come a long way, but the design process has not. As a disclaimer, most of what is about to be said applies to user interface and graphic design, as opposed to illustration and the creative process.

The culture around design is primarily focused on the end product and not the process behind it. Photoshop, the industry standard for user interface design, is pixel-centric (limited vector support being a later addition). Trivial things such as rounding corners or changing resolutions are often non-trivial to accomplish. Re-usable assets, such as those found on Smashing Magazine, often consist of static images, hopefully in multiple resolutions. Cascading stylesheets, the lifeblood of web design, are exceedingly repetitive and usually degrade into an unmaintainable soup.

For comparison, the culture of software development largely evolves around getting things done cleanly, efficiently, and maintainably. Entire programming frameworks and communities arise around the idea of making the process of doing something developers are already able to do (e.g build websites) simpler. Existing bodies of code are re-factored entirely to be cleaner, despite having less features. New languages emerge with the goal of making software easier to develop. Re-usable libraries exist for almost every language and programming task imaginable.

The stereotypical developer is horrible at graphic design, but much of this is due to an impedance mismatch between software development and design practices. From the perspective of a good developer, many of the techniques that are required to create good design are appalling and contrary to their core philosophy.

Massive Violation of DRY

From Wikipedia:

Don’t Repeat Yourself (DRY) or Duplication is Evil (DIE) is a principle of software development aimed at reducing repetition of information of all kinds…

A rule of thumb for this is if you find yourself doing the same thing often, there is probably/should be a better way to do it. Whether I am writing CSS or creating layouts and graphics in Fireworks or Photoshop, I repeat myself all the time. As a response to this for CSS, developers have created tools such as SASS and LESS. The elephant in the room, however, is graphic design. Accomplishing commonplace visual effects such as curved drop shadows and glossy buttons usually requires following multi-step rote processes every time they are needed.

Poor Extensibility and Reusability

Perhaps causally related with the violation of DRY principles is the lack of ways to extend graphics design tools and reuse existing graphical designs.

In the case of software development, common design patterns and features can easily be modularized and re-used in various projects and components. Existing frameworks are also designed with plugin architecture’s in mind. The prevalence of rails extensions, for example, has made creating web applications with Ruby on Rails amazingly easy, far beyond what the original framework intended.

Graphic design tools are quite the opposite. One could imagine things like glossy buttons, advanced shadows, and other effects being easily scripted or packaged into custom filters, but it’s not so in reality. Despite having limited scripting support, the really useful plugins for tools like Photoshop and Fireworks were all built years ago in native code. These tools are used by thousands of programmers and designers, but the ecosystem around extending and contributing to these products is almost non-existant. I have personally put immense amounts of effort towards scripting Adobe Fireworks, but this has simply made the limitations more apparent.

CSS3 has actually made great strides in this area, but it will never be a complete substitute for graphics design. I can imagine a future ecosystem consisting of a robust open source graphics editing program(s) accompanied by a plethora of plugins, filters and assets freely distributed and written in a modern scripting language.

Immutability

Finished designs are often immutable and hard to change (and this has nothing to do with the good type of immutability). Source .psd files often consist of layers of flattened pixels, the exact combination of actions which created the layer lost forever. In many cases, this starkly contrasts with the underlying software being designed, which is in a constant state of flux and improvement.

The software equivalent of this would be software development tools which produce raw binaries without source code, the only possibility of change through a finite number of parameters. The natural solution would be to have graphics software which preserves the entire process by which an image was created. For this reason, I personally tend towards Adobe Fireworks, which is slightly better at this, dealing with items at the object level rather than the layer level.

Another solution would be to have the underlying format for the source of an image be an imperative graphics description language, e.g. Degrafa. SVG is theoretically nice, but is poorly implemented and monolithic, but still might ultimately be the answer.

Lack of Version Control

Binary source files don’t mesh well with version control. Merging conflicts is near impossible. Viewing and understanding the history of a file is not easy. I have seen workflows where all the design assets are passed around in shared folders with no version control at all. In the developer world, this would be almost unheard of. This also translates to the web, where design assets are clumsily distributed and the techniques used to create the asset are usually lost.

Reliance on Proprietary Tools

Almost no one would argue with the fact that Adobe Photoshop is the industry standard for graphic design, supplemented by Illustrator and sometimes Fireworks. Other open source tools such as GIMP and Inkscape are slightly sub par and suffer from the same lack of innovation. This state of affairs has been relatively the same for the last decade or more.

Not only does this restrict innovation, but it also restricts the platforms able to do graphics design. This prevents many developers and designers from using operating systems like Ubuntu as their primary OS. Moreover, I would argue that this has contributed to poor design in many OSS applications. Witnessing open-source software transforming the landscape of software development, one can only hope that the same will eventually happen to design.

My hope throughout this was that I might be able to come to some insight or achieve a revelation about the significance of always being connected. Perhaps by depriving myself of something I had grown to take for granted, having a powerful computer in my pocket, could inspire me as a (mobile) developer. Unfortunately, the best I could come up with is this: having a phone doesn’t really fucking matter. For people who work in front of computers, in this day and age, your phone is a luxury device, and not having one is no big deal.

Sure, I definitely did miss out on a few candid photos of my friends, some of my amazing lunches went undocumented, and I definitely could have benefited from Google Maps from time to time, but fundamentally nothing about my life changed for the better or for the worse. I am still wired to a computer majority of the day, my brain is still synced to my GMail inbox, and aside from short periods of commute, the internet is still readily accessible if needed.

I was also hoping that I could write about how not having a phone could reduce stress. The physical constraint of not being able to check your email several hours a day does relax your attitude, but I still felt no perceptible difference in my stress level. Instead, for the rest of this post I will share some random tidbits I gained from this experience:

Google Voice is the Shit

For $0.00 dollars a month I have the same mobile phone number I had before as well as unlimited calls and domestic texts. This is all done through Google Voice after porting my phone number. From the perspective of all of my contacts, I still have a phone and nothing has changed. Of course, I need access to a computer to return calls, but this is not a problem for me, especially with a MacBook Air slung over my shoulder for most of the day. It really is only a matter of time before mobile VOIP clients usurp voice and text plans entirely.

Moreover, using Google Voice for calls and texts is actually a lot better than the traditional phone counterparts. Voicemail transcription definitely helped screen recruiters. I am also doing myself a favor by typing out texts in an instant message-like interface rather than constantly using a touch keyboard. In retrospect, it is actually slightly amusing to think of myself responding to texts on my phone while sitting in front of a full keyboard, as I often did. The same goes for email. Even if you have a phone, it is worthwhile to go through the cumbersome porting process, effectively making your phone and computer interchangeable.

Touch Interfaces Are Sexy and Easily Forgotten

While not having a phone, there wasn’t a single app that I longed to use over it’s desktop equivalent. Desktop apps aren’t quite as sexy, but they definitely work. I might be singing a different tune if I were really into the mobile gaming scene or consuming certain types of content as thats where I feel most of the innovation is taking place (even though Angry Birds is now in the browser).

Phones and computers are converging, and phones are starting to feel like shitty computers. (Although, I really hope I eat these words when NFC becomes prevalent). This is especially apparent when my Macbook Air is sitting next to my iPad 2 on my coffee table. It is only slightly larger, an order of magnitude more useful, and usually the first to be picked up when someone wants to browse the web. That said, just to be clear, I still do believe that a properly done native iOS or Android app focused on consuming content can still rival anything out there and can appeal to a wide(r) audience.

I Just Bought a Phone

I’m sure I slipped throughout this post and referred to my not having a phone in past tense. That is because yesterday I finally bought myself a replacement phone, an HTC Sensation, not because I needed it, but because I wanted it. I’m looking forward to being able to tether my air again.

This is the first of several personal project’s that I plan to open source in the coming months. As I’ve slowly begun the process of migrating all of my personal projects from a private gitosis installation to github to a new server, I’ve realized that most of my 43 private repositories will amount to nothing in my hands alone. I’m also a big fan of free software without restrictions. With that in mind, I am licensing these projects under the MIT license.

Paperblocks is a flash 3d tetris game I made in my spare time years ago. I previously made a short blurb about it here. It is built with Flex and Papervision3D with a small php high scores backend. The original inspiration for the game was from Blockout, which was one of my favorites growing up.

Play the game or check out the source code. Cheers!

I am typing this right now on my latest generation MacBook Air. The reason why I switched to OS X was because it was the best of both worlds. I could have a Unix shell, Adobe products, as well be able to use XCode to develop iOS applications (which you can’t do on Windows, but that is a separate issue). I could do everything Windows could and more. Analogously, choosing between Windows 8 and iOS for a casual user is very similar.

I also have an iPad 2 and an iPad before that. People, mostly family, are always very attracted to my iPad and frequently ask me if they should buy one to replace their existing aging laptop. My answer is always a resounding no. Were that to happen, they would inevitably call me and ask how to open Office documents, view flash websites, and do all the other countless things that an iPad is not suited for.

Windows 8 solves this problem. Sure, there will be an initial period where some apps will only be available in desktop form. But, at least there will be a less elegant way to do things that otherwise couldn’t be done. Additionally, this will only result in low hanging fruit for developers. If the metro tiling interface takes off, consumers will prefer a metro based application and developers will build one. Similarly, Android’s additional OS-level features (at the sake of battery life, some might say) are one of the reasons why I prefer it over iOS.

Another argument against Windows 8 is that of market and developer confusion. There is no market and developer confusion. Apple has already set the precedent. Consumers and developers both know what they want and what to build respectively. The capability is there and the developer who builds what the consumer wants will win.

Based on WP7’s market performance, who knows what will happen. My argument here is not to say Windows 8 is a winner. It is simply to say that the the arguments against it are misguided. I, for one, would prefer to be able to do more than less. One thing that is certain, however, is that having more competitors and innovation in the mobile/touch landscape is a good thing.

Roughly three months ago (in the beginning of March), for a variety of reasons, I decided to put my resume out there on the interwebs. Here I chronicle my experience being a software developer on some of the most popular and widely used job channels.

Background

For some context, I was doing research on an idea I had (now GroupTalent) and was also willing to entertain the idea of flexible interesting mobile projects. My resume included the following:

1. B.S. in CS and Math
2. SDE at Microsoft
3. YC Founder (Team Apart S’08, now defunct)
4. Misc. consulting
5. Independent app development (iOS and Android)

My objective read:

Seeking freelance or short term contract iPhone and Android development positions.

I posted this resume on Monster and CareerBuilder. I had also previously created a profile on StackOverflow careers and GitHub jobs. Additionally, and importantly, I had indicated that I would be willing to relocate.

Results

To relate my experience, I will begin with some numbers and then move into a more anecdotal portrayal.

Over the course of the roughly three month period after posting my resume, I diligently labeled all incoming emails from recruiters in GMail. Thankfully, I also use Google voice, and was easily able to identify and count calls and voicemails from recruiters. The numbers I am about to give exclude the numerous automatic emails sent from these sites; they all represent contact from actual people (or at least present themselves as so). The screenshot at the beginning of this post would suggest that I had received 252 emails, but this number is from when I began drafting this post roughly a week ago.

As I write this, all in all I have received: 266 emails and 96 voicemails. This roughly equates to 12.7 emails and 4.3 voicemails per workday. There were also some additional calls that I actually answered or that didn’t result in a voicemail. My Monster.com profile was viewed 261 times and “saved” 37 times. My CareerBuilder.com profile showed up in 343 searches (presumably by employers), and was viewed 31 times. My profile on StackOverflow careers was viewed by employers a whopping 1 time and had 3 search hits. GitHub jobs doesn’t appear to reveal any data of this kind.

The emails varied immensely in personalization and adherence to what I was actually looking for. My CV’s objective of short term Android and iPhone projects functioned as a mere leitmotif or not at all. My overall impression was that many recruiters simply do blanket keyword searches for terms such as “java”. Interestingly enough, many recruiters reached out to me on the premise that they found my resume on other sites such as Dice that I had never even created a profile on. It turns out that most recruiters do not even interface with the job sites directly, but instead use 3rd party software which crawls all the job boards for them.

Employers ranged from small startups to large corporations, the average being somewhere in between. The companies also included the likes of desirable A-Companies such as Amazon and Zynga. The split of jobs that were local and those which required relocation was about half and half with perhaps a few more on the relocation side.

Most recruiters were either head hunters or part of 3rd party staffing companies, but many were internal recruiters as well. For the first week, I actually answered all incoming calls, but this eventually became unmanageable. I used the opportunity to hear them out and also sometimes give them a reverse pitch on GroupTalent for feedback. Some recruiters were actually extremely savy people who wanted to build a relationship with you. Others were pretty abrasive. My favorite conversation was with the recruiter who actually suggested that I take a job at a mega corp while I still could since everything was going to be outsourced in the near future anyways.

Thoughts

According to Joel Spolsky, most good developers will never even be exposed to this situation since they will never be on the market. Combine this with the fact that everyone sucks at hiring and you have an industry that is basically a crap shoot. I also wonder if companies realize that many of their candidates are acquired through pseudo-spam.

In the interest of full disclosure, I actually have used Monster a few years ago and did wind up with an excellent consulting gig that was very flexible, but my experience was similarly noisy. I consider myself at least a decent developer and believe that good developers are on the market or are at least willing to entertain new opportunities. I predict that in the coming years the demand for top talent will be even higher and companies will need to resort to new ways to find and incentivize developers. While the experience I have presented here can vary, especially for new grads and developers travelling through reputation or word of mouth, my goal here was simply to give some perspective.

What is your experience being recruited?

Why I Use Android

Despite the IPhone 4 having admittedly better hardware (damn that retina display is nice) I much prefer Android devices. The reasons have everything to do with software:

1. Multitasking

“Multitasking” on iOS is a joke. I’m speaking right now from the perspective of a user, but trust me, I also truly know this, having been in the shoes of a developer. Notifications are horribly presented in modal dialogs; in situations where I have a large number of notifications, usually all but the last one shown to me are lost. I also desperately long for an IM client which I can use on my IPad which I can naturally interact with while using other apps. No such app exists since all the apps are forced to go through the cumbersome notification system. On Android, as in a desktop operating system, applications can truly run in the background; on Android, IM can be almost indistinguishable from texting (which is coincidentally also better than iOS).

2. Intents

Android is an intent based operating system. What this means from a user’s perspective is a richer more deeply integrated experience. If I am browsing the web and click on a link to a product on Amazon.com, the context will switch and the product will be opened in the Amazon app. On iOS, clicking that link would just result in the link being opened in the browser (often times losing the context of the originating application). Android allows apps to have a deeper and more natural hook into the operating system and user experience. For example, in the coming years, when Google Voice finally gets a true VOIP client, it will be able to seamlessly replace the default calling application.

3. Back Button

The back button is a killer feature and is way more than just a physical button. The android operating system is essentially stack based. Going from the above example of clicking on an Amazon product link: after the Amazon app is opened, I can intuitively press the back button to return to the application from which I clicked the link. I cannot count the number of situations on iOS where I lose a retrievable context of where I was inside of an application by clicking on a link. Nor can I count the number of applications which pop open browser dialogs when you click on a link as a hack to fix this. Imagine how ridiculous it would be if it was the norm for desktop applications to all use an embedded browser. Imagine how unusable it would be. The closest equivalent on iOS for the back button (that I know of) is double tapping the home button (or four finger swiping) to get a list of the most recent apps and then clicking on the app you last used. Lots of users don’t even know you can do this.

The menu button on Android is also very convenient (although not as vital) and saves lots of prime mobile screen real estate.

4. Apps

As a user, I never need to buy an application. Moreover and surprisingly, there are many apps on Android that simply have no equivalent on iOS. If I want to use instant messaging, free apps exist. This is the status quo. Not so on iOS. Also, there is a GMail application which actually has an intuitive interface. I am shocked by tech-savy people who use the iOS mail application with their GMail account in an outlook-like fashion. Things like Wifi and USB tethering are also built in to the Android operating system.

5. Navigation

Newer version of android have a turn by turn navigation application by Google which uses data from Google Maps. Although some might consider this a smaller feature, this is hands down the best navigation application I have used and has rendered my Garmin navigation obsolete. I use this all the time. There is no equivalent for iOS, even though some apps exist in the app store with double digit price tags.

Why I Develop for iOS

Despite learning mobile development on Android and also preferring Android’s development framework and tools, I have shifted all of my app development to iOS (at least for first releases). One of my most recent games, Word Topple, is only available on the app store. The reasons have nothing to do with software:

1. Revenue

iOS has a much more profitable app economy. Even though it is ridiculously hard to make a hit iOS app, an iOS application is much more lucrative than the same android application with the same number of users. On iOS, users expect to have to pay for applications and they do. Each user of an iOS application is also much more valuable than their Android counterparts.

To back this up with some data, I will reveal some numbers on one of my games, BeWorded (in the Android Market and in the App Store). Both versions are identical ports and have never been marketed. They have also both not been updated in months. The primary source of revenue for this app is through AdMob advertising. Interestingly enough, both versions have had almost exactly the same number of impressions (~1.5 million). The iOS version has a CPM of $0.30 and the Android version has a CPM of $0.08. The iOS version is roughly 4x more profitable with an identical user base. Some of my other Android apps have even worse CPMs.

2. Game Framework Maturity

Let’s face it, most user’s play lots of games on their mobile devices. Games are huge. On iOS, there are a number of game frameworks with very active communities, my favorite being cocos2d. Android, on the other hand, suffers from a lack of mature game frameworks. I first started writing games on Android and have tried virtually all of the 2D frameworks I know of. I wanted a full 2D scene graph and none of them were sufficient. I ultimately wound up using an incomplete port of cocos2d to android which suffers considerably in performance and in completeness, but is getting a lot better. This fact has resulted in iOS being a much better platform for developers and users with respect to games.

Thoughts on the Future

Android is a much more advanced and well though out operating system compared to iOS. It is open. Its applications are free. Even its development tools are more modern (which I will go into in another post). Game frameworks will eventually catch up and the communities are growing. The biggest leg up iOS has over android at this point is hardware and aesthetics, and that gap is closing fast and might already be closed. Unlike the laptop market, other handset manufacturers like HTC and Samsung are producing amazing devices. The IPhone was clearly superior when I was on my G1. After upgrading to a Nexus One, my phone was superior to my friend’s IPhone 3GS’, before the IPhone 4 was released. Next generation phones like the soon to be released HTC Sensation and Samsung Galaxy S2 are going to blow existing devices out of the water. The bar for applications on Android is also increasing and the truly good, sexy apps are floating to the top.

Although I currently still develop primarily for iOS, I expect that to change soon. All of the low hanging iOS applications have long since been built and more and more apps are becoming free to compete with the incumbents. I expect this to affect the profitability of iOS development and the expectations of users. Android is also gaining market share and truly has a better user experience. People are starting to openly prefer their Android phones to their friend’s IPhones. If I had to make a long term wager on a mobile OS, all my money would be on Android.

Having formerly been a Math and CS major in college, I have always had a penchant for green engineering pads, on which this theme is based. This theme is also open source and is up on GitHub here. Enjoy! (P.S. I really wish more designers would use version control.)

I spent the last few days teaching myself Flex 4 and AIR. Per my usual way of learning things I like to make (somewhat) functional applications. This time I made a desktop notification system for Stackoverflow. Currently it just notifies of new questions asked, subject to certain filters. Eventually I will add notifications for questions that have been answered, among other things. If you install it now, it should update to the latest version automatically in the future. Use the badge below to try it out and let me know what you think:

Based on the backwards compatibility with Halo, my initial idea was to migrate one of my existing side projects from Flex 3 to Flex 4 and then incrementally switch over to Spark components as development progressed. In theory this sounded fairly easy, but ultimately this required lots of overhaul to my CSS files and lots of additional bloat. This is due to a design pattern that I favor which heavily depends on reusable custom components and CSS type selectors.

The design pattern is simple: I create custom reusable composite components which consist of several other components and then I style those components in a separate CSS File using type selectors. For instance, I will have a component called UserView which, for simplicity, would just consist of a VBox component containing Image and Label components. This would then be styled in an external css file, style.css, as follows:

1

UserView { .... }

This component would then be reused in many locations throughout the application. This worked great in Flex 3, however due to Flex 4 requiring all CSS type selectors being qualified with a namespace, this breaks in Flex 4, resulting in none of the styles being applied. The workaround is to create a namespace inside the css file:

1
2

@namespace "com.mypackage.views.*";
UserView { .... }

Now it works. The problem is, however, in large projects I normally have a multitude of these components in lots of different packages. Thus, since the CSS namespace spec requires that all the namespaces be declared at the top of the file, I have a huge number of namespaces at the top of the file and each component needs to be qualified. E.g:

1
2
3
4
5
6

@namespace views "com.mypackage.views.*";
@namespace forms "com.mypackage.forms.*";
...
views|UserView { ... }
forms|Login { ... }
...

This is frustrating because not only does it bloat the code, but it also decreases the spatial locality of the code, requiring me to jump around to mentally resolve namespaces.

If my classes were inside of a flex library, I could give them all the same namespace, e.g. http://ns.mycompany.com/2009, but I cannot find a convenient way to do this for classes which are part of a normal flex project and not pulled in from an external library.

Flex 4 is still great and by no means is this a deal breaker. Other people have overstated this as an EPIC FAIL and others have oversimplified it as a one-line fix (which is only true if you are styling components from a single namespace). It would be nice if there was something like the following:

1

@namespace "com.mypackage.**";

Or at the very least:

1

"com.mypackage.views.*"|UserView { ... }

Avoiding the requirement of having lots of declared namespaces.