When releasing a new version of an AIR application that makes use of SQLite, it’s often necessary to upgrade the schema for that database as well. While taking a Hail Mary approach to the problem and just deleting the old database may work for some, it’s not an elegant option and will ensure that you can never persist data between versions. Instead, creating a way for your application to gracefully migrate its own database to the most recent version will ensure that your local data is not compromised, providing a smooth and seamless experience for the end user.

The Concept

We know that a database is the accumulation of all the CREATE, UPDATE and DELETE statements that have come before it. This means it may be easily represented and reconstructed by an ordered sequence of SQL files. It then becomes our task to manage which SQL files have already been executed in a given application version, and to execute (in order) those files which have not.

To accomplish this, we do the following:

1. We create a migration table within your database in which we store which scripts have been executed.
2. We check each script against this table before we run it.

There are other optimizations we can perform, however for this case we’re going to keep the idea simple.

Part 1: The Migration Class

The Migration class is a simple value container that contains your SQL Script as well as a Unique ID. Both of these are derivatives, since we want to give options on how to include the SQL file, and we don’t want to make our users have to think too much about how to set up a migration.

package com.fancybrandname.core.db
{
        import com.adobe.crypto.MD5;
        import com.fancybrandname.core.utils.LogUtil;

        import flash.data.SQLConnection;
        import flash.data.SQLStatement;
        import flash.errors.IllegalOperationError;

        import mx.logging.ILogger;

        /**
         * A specific database migration instance. It should contain both a version
         * and an embedded SQL source file that will be executed against the database.
         *
         * @author Michael Krotscheck
         */
        public class Migration
        {
                /**
                 * Logger
                 */
                private static const LOG : ILogger = LogUtil.getLogger( Migration );

                /**
                 * The SQL Source to use for this migration.
                 */
                private var _source : *;

                /**
                 * The SQL Statement extracted from the SQL Source object.
                 */
                private var _sqlStatement : String;

                /**
                 * This is the unique version key we use to identify this particular migration.
                 */
                private var _versionKey : String;

                /**
                 * The SQL Source to use for this migration.
                 */
                public function get source () : *
                {
                        return _source;
                }

                /**
                 * @private
                 */
                public function set source ( value : * ) : void
                {
                        _source = value;

                        // Here we attempt to extract the SQL statement from the passed object. If
                        // the object is a Class (as with the @Embed directive), we instantiate and convert it.
                        // If it's anything else we try to invoke the toString method, and throw an error if we
                        // can't find it.
                        if ( _source is Class )
                        {
                                _sqlStatement = ( new _source() ).toString();
                        }
                        else
                        {
                                try
                                {
                                        _sqlStatement = _source.toString();
                                }
                                catch ( e : Error )
                                {
                                        throw new IllegalOperationError( 'Unrecognized type for SQL Migration. Please use Embeds or Strings' );
                                }
                        }

                        // Now we generate a unique ID from this string.
                        // You could request this key manually so that you don't have a dependency
                        // on the adobe crypto library, but I prefer doing it this way.
                        _versionKey = MD5.hash( sqlStatement );
                }

                /**
                 * This is the unique version key we use to identify this particular migration.
                 *
                 * @read-only
                 */
                public function get versionKey () : String
                {
                        return _versionKey;
                }

                /**
                 * This is the unique version key we use to identify this particular migration.
                 *
                 * @read-only
                 */
                public function get sqlStatement () : String
                {
                        return _sqlStatement;
                }

                /**
                 * Constructor.
                 */
                public function Migration ()
                {
                }
        }
}

Step 2: The Migration Manager

Our migration manager does the heavy lifting for this class, by checking the database for the last applied migration key and only applying those keys that come after it. It assumes several things. Firstly, that the migrations are in order of execution. Secondly, that the SqlConnection instance passed to it is a synchronous, not asynchronous connection. This method would definitely work for asynchronous connections, however you’d have to adjust the class to iterate using eventListeners. I leave this as an exercise to the reader.

package com.fancybrandname.core.db
{
	import flash.data.SQLConnection;
	import flash.data.SQLResult;
	import flash.data.SQLStatement;
	import flash.errors.IllegalOperationError;
	import flash.errors.SQLError;

	/**
	 * This metadata sets the default property for child nodes used in MXML. This
	 * makes MXML markup a lot easier to understand.
	 */
	[DefaultProperty( "migrations" )]
	/**
	 * A simple class that assists in managing multiple SQL files that may need
	 * to be run against a locally stored database. It makes the assumption
	 * that the migrations must be executed in the order in which they are provided,
	 * and that the database starts "clean" and untouched.
	 *
	 * @author Michael Krotscheck
	 */
	public class MigrationManager
	{

		/**
		 * The SQL Connection to use to connect to the database and check for migration.
		 */
		public var sqlConnection : SQLConnection;

		/**
		 * The migrations to run against the database. These must be in order of execution.
		 */
		public var migrations : Vector.<Migration> = new Vector.<Migration>();

		/**
		 * The name of the table within the database to store the migrations in.
		 */
		public var tableName : String = 'migration';

		/**
		 * Constructor
		 */
		public function MigrationManager ( sqlConnection : SQLConnection = null )
		{
			this.sqlConnection = sqlConnection;
		}

		/**
		 * This method runs the database migrations.
		 */
		public function migrate () : void
		{
			// Can we migrate?
			if ( !sqlConnection )
			{
				throw new IllegalOperationError( 'No SQLConnection provided' );
				return;
			}

			try
			{
				// Make sure the migration table exists.
				createMigrationTable();

				// Get the last version key applied to the database.
				var lastVersionKey : String = getLastVersionKey();

				// Iterate through our collection and execute every script AFTER the version key we found.
				var len : int = migrations.length;

				// Switch to let us know whether the last version key was found.
				// If the last version key is empty, apply all of them.
				var lastKeyFound : Boolean = lastVersionKey == '' ? true : false;

				for ( var i : int = 0; i < len; i++ )
				{
					var currentMigration : Migration = migrations[ i ];

					if ( lastKeyFound )
					{
						apply( currentMigration );
					}
					else if ( currentMigration.versionKey == lastVersionKey )
					{
						lastKeyFound = true;
					}
				}
			}
			catch ( e : SQLError )
			{
				throw( e );
			}
		}

		/**
		 * This method creates the migration table if it doesn't exist yet.
		 */
		private function createMigrationTable () : void
		{
			var sql : String = 'CREATE TABLE IF NOT EXISTS ' + tableName + ' (version varchar(32) NOT NULL PRIMARY KEY, applied_on timestamp NOT NULL);';

			var statement : SQLStatement = new SQLStatement();
			statement.sqlConnection = sqlConnection;
			statement.text = sql;
			statement.execute();
		}

		/**
		 * This method gets the last version key recorded in the database.
		 */
		private function getLastVersionKey () : String
		{
			var statement : SQLStatement = new SQLStatement();
			statement.text = 'SELECT version FROM ' + tableName + ' ORDER BY applied_on DESC LIMIT 0,1';
			statement.sqlConnection = sqlConnection;
			statement.execute();

			var sqlResult : SQLResult = statement.getResult();

			if ( sqlResult == null || !sqlResult.data || sqlResult.data.length == 0 )
			{
				// No migrations found.
				return '';
			}
			else
			{
				// We found one, return it.
				return sqlResult.data[ 0 ].version;
			}
		}

		/**
		 * This method applies the database migration to the database passed to this function.
		 * Please note that this version of the class only works with Synchronous SQLConnections.
		 */
		private function apply ( migration : Migration ) : void
		{
			// Apply the migration
			var updateStatement : SQLStatement = new SQLStatement();
			updateStatement.text = migration.sqlStatement;
			updateStatement.sqlConnection = sqlConnection;
			updateStatement.execute();

			// Update the version key
			var versionStatement : SQLStatement = new SQLStatement();
			versionStatement.text = 'INSERT INTO ' + tableName + ' (version, applied_on) VALUES ( :version , :timestamp )';
			versionStatement.parameters[ ':version' ] = migration.versionKey;
			versionStatement.parameters[ ':timestamp' ] = ( new Date() ).getTime();
			versionStatement.sqlConnection = sqlConnection;
			versionStatement.execute();
		}
	}
}

Step 3: Usage

Finally it’s time to use our class. As you can see the MXML markup is pretty straightforwar, and usage in ActionScript is similarly easy. Note that I’m using both @Embed directives and raw text, and pay particular attention to the embed mime-type. Without it, this doesn’t really work.

<s:Application
	xmlns:fx="http://ns.adobe.com/mxml/2009"
	xmlns:parsley="http://www.spicefactory.org/parsley"
	xmlns:s="library://ns.adobe.com/flex/spark"
	xmlns:db="com.fancybrandname.core.db.*"
	>
	<fx:Script>
		<![CDATA[
			override protected function initializationComplete():void
			{
				super.initializationComplete();

				var dbFile :File = File.applicationStorageDirectory.resolvePath('myDb.db');
				var connection :SQLConnection = new SQLConnection();
				connection.open( dbFile );

				migrationManager.sqlConnection = connection;
				migrationManager.migrate();
			}
		]]>
	</fx:Script>

	<fx:Declarations>
		<db:MigrationManager id="migrationManager" tableName="migrations">
			<db:Migration source="@Embed(source='/sql/CreateSomeTable.sql',mimeType='application/octet-stream')"/>
			<db:Migration source="DROP TABLE IF EXISTS someTable;"/>
			<db:Migration source="@Embed(source='/sql/CreateSomeOtherTable.sql',mimeType='application/octet-stream')"/>
		</db:MigrationManager>
	</fx:Declarations>
</s:Application>

A discussion about OAuth and OpenID

Strictly speaking, Facebook supports OAuth, not OpenID. OAuth is a way for your application to act on behalf of someone else on another side, while OpenId exists solely for you to use the other website as an authorization authority. The difference is subtle, however telling that Facebook has explicitly stated that it does not want to be an authorization authority. In practice, however, the two standards are interchangeable, and OAuth works pretty well as a way to authenticate a user.

How Facebook Auth Actually Works

Here’s the flow in four easy steps:

1. The user clicks on a “Login to Facebook” link on your server, which redirects them to another page on your server that handles the authentication.
2. Your Facebook Auth page puts all the parameters for your authentication, such as your app ID and scope, into a URL and sends the user to Facebook via that URL.
3. Once Facebook returns the user (presumably authenticated) to your server, you can use the parameters sent via the URL to request an authentication token from Facebook. This is done via curl or some other server-to-server communication by calling the graph API.
4. You use this authentication token to access the user’s information on Facebook.

Step 1: Get all the data you need

To properly authenticate with Facebook, you need four pieces of data. The first two are your application id and your application secret, both of which are available on your developer application page.

A sample Facebook application page

The second two pieces of data are specific to your implementation. These are the redirect URI, which is used to tell Facebook where to send the user once they are done authorizing your application, and the permission scope, which you use to tell Facebook what permissions you want to request from the user. This latter one actually warrants some more documentation, which Facebook has graciously provided here. Be careful: Users can get really suspicious if you ask for too much data.

Step 2: Redirect your user to Facebook.

With this data, you can redirect your user to Facebook. Facebook will then work some magic and ask the user whether they want to grant your application access to their profile. Don’t forget to urlencode that Redirect URI.

$loginUri = "https://graph.facebook.com/oauth/authorize?client_id={$appId}&redirect_uri={$redirectUri}&scope={$scope}";
header('Location: ' . $loginUri);

Step 3: Request an Auth Token

Assuming that the user authorizes your application, Facebook will return them to your redirect URI with the “code” parameter in the URL. You can use this parameter to request an authorization token from Facebook. In this case I’m using the Zend Request handler to simplify things a little.

$client = new Zend_Http_Client( "https://graph.facebook.com/oauth/access_token" );
$client->setParameterGet('client_id', $appId);
$client->setParameterGet('client_secret', $secret);
$client->setParameterGet('code', $code);
$client->setParameterGet('redirect_uri', $redirectUri);

$result = $client->request('GET');
$params = array();
parse_str($result->getBody(), $params);
$token = $params['access_token'];

Step 4: Read the user’s profile

At this point, you have an auth token that grants you access to read the user’s profile information in accordance to the permissions they have granted you. These permissions are completely blind- you don’t have to additionally specify what you want to access – the requests will simply return the information to which you have access.

$client = new Zend_Http_Client( "https://graph.facebook.com/me" );
$client->setParameterGet('client_id', $appId);
$client->setParameterGet('access_token', $token);
$result = $client->request('GET');
$user = json_decode($result->getBody());

Zend_Auth_Adapter_Facebook

For those of you who would rather not take the above code and wrap it into your own Auth Adapter, I’ve gone ahead and done all that work for you. Below you will find a sample Zend Controller, as well as a pre-baked Auth Adapter. If you come across any major security problems in it, I’d love to know, since I use this adapter myself .

class Zend_Auth_Adapter_Facebook implements Zend_Auth_Adapter_Interface
{
    /**
     * The Authentication URI, used to bounce the user to the facebook redirect uri.
     *
     * @var string
     */
    const AUTH_URI = 'https://graph.facebook.com/oauth/authorize?client_id=%s&redirect_uri=%s';

    /**
     * The token URI, used to retrieve the OAuth Token.
     *
     * @var string
     */
    const TOKEN_URI = 'https://graph.facebook.com/oauth/access_token';

    /**
     * The user URI, used to retrieve information about the user.
     *
     * @var string
     */
    const USER_URI = 'https://graph.facebook.com/me';

    /**
     * The application ID
     *
     * @var string
     */
    private $_appId = null;

    /**
     * The application secret
     *
     * @var string
     */
    private $_secret = null;

    /**
     * The authentication scope (advanced options) requested
     *
     * @var string
     */
    private $_scope = null;

    /**
     * The redirect uri
     *
     * @var string
     */
    private $_redirectUri = null;

    /**
     * Constructor
     *
     * @param string $appId the application ID
     * @param string $secret the application secret
     * @param string $scope the application scope
     * @param string $redirectUri the URI to redirect the user to after successful authentication
     */
    public function __construct($appId, $secret, $redirectUri, $scope)
    {
        $this->_appId = $appId;
        $this->_secret = $secret;
        $this->_scope = $scope;
        $this->_redirectUri   = $redirectUri;
    }

    /**
     * Sets the value to be used as the application ID
     *
     * @param  string $appId The application ID
     * @return Zend_Auth_Adapter_Facebook Provides a fluent interface
     */
    public function setAppId($appId)
    {
        $this->_appId = $id;
        return $this;
    }

    /**
     * Sets the value to be used as the application secret
     *
     * @param  string $secret The application secret
     * @return Zend_Auth_Adapter_Facebook Provides a fluent interface
     */
    public function setSecret($secret)
    {
        $this->_secret = $secret;
        return $this;
    }

    /**
     * Sets the value to be used as the application scope (array())
     *
     * @param  string $scope The application scope
     * @return Zend_Auth_Adapter_Facebook Provides a fluent interface
     */
    public function setApplicationScope($scope)
    {
        $this->_scope = $scope;
        return $this;
    }

    /**
     * Sets the redirect uri after successful authentication
     *
     * @param  string $redirectUri The redirect URI
     * @return Zend_Auth_Adapter_Facebook Provides a fluent interface
     */
    public function setRedirectUri($redirectUri)
    {
        $this->_redirectUri = $redirectUri;
        return $this;
    }

    /**
     * Authenticates the user against facebook
     * Defined by Zend_Auth_Adapter_Interface.
     *
     * @throws Zend_Auth_Adapter_Exception If answering the authentication query is impossible
     * @return Zend_Auth_Result
     */
    public function authenticate()
    {
    	// Get the request object.
    	$frontController = Zend_Controller_Front::getInstance();
    	$request = $frontController->getRequest();

    	// First check to see wether we're processing a redirect response.
    	$code = $request->getParam('code');

    	if ( empty ($code ) )
    	{
	    	// Create the initial redirect
	    	$loginUri = sprintf(Zend_Auth_Adapter_Facebook::AUTH_URI , $this->_appId, $this->_redirectUri);

	    	if ( !empty($this->_scope) )
	    	{
	    		$loginUri .= "&scope=" . $this->_scope;
	    	}

	    	header('Location: ' . $loginUri );
    	}
    	else
    	{
    		// Looks like we have a code. Let's get ourselves an access token
	    	$client = new Zend_Http_Client( Zend_Auth_Adapter_Facebook::TOKEN_URI );
	    	$client->setParameterGet('client_id', $this->_appId);
	    	$client->setParameterGet('client_secret', $this->_secret);
	    	$client->setParameterGet('code', $code);
	    	$client->setParameterGet('redirect_uri', $this->_redirectUri);

	    	$result = $client->request('GET');
	    	$params = array();
	    	parse_str($result->getBody(), $params);

	    	// REtrieve the user info
	    	$client = new Zend_Http_Client(Zend_Auth_Adapter_Facebook::USER_URI );
	    	$client->setParameterGet('client_id', $this->_appId);
	    	$client->setParameterGet('access_token', $params['access_token']);
	    	$result = $client->request('GET');
	    	$user = json_decode($result->getBody());

            return new Zend_Auth_Result( Zend_Auth_Result::SUCCESS, $user->id, array('user'=>$user, 'token'=>$params['access_token']) );
    	}

        return new Zend_Auth_Result( Zend_Auth_Result::FAILURE, null, 'Error while attempting to redirect.' );
    }
}

/**
 * Sample Facebook Auth Controller.
 *
 * @author Michael Krotscheck
 */
class FacebookauthController extends Zend_Controller_Action
{
	/**
	 * Application default action
	 */
	public function indexAction ()
	{
		$appId = 'YOUR_APP_ID';
		$secret = 'YOUR_APP_SECRET';
		$redirectUri = 'http://path-to-this-controller-and-action';
		$scope = 'YOUR_COMMA_SEPARATED_APPLICATION_SCOPE';

		// Create the authentication adapter.
		$adapter = new Zend_Auth_Adapter_Facebook( $appId, $secret, $redirectUri, $scope );

		// Get an authenticator instance
		$auth = Zend_Auth::getInstance();

		// This call will automatically redirect to facebook with the passed parameters.
		$result = $auth->authenticate($adapter);

		if ( $result->isValid() )
		{
			// Get the messages
			$messages = $result->getMessages();

			// Get the user object from the returned messages.
			$fbUser = $messages['user'];

			var_dump($fbUser);
		}
	}
}

1- They don’t think of themselves as rock stars.

Arrogance is perhaps a key requirement in being an entrepreneur, but overconfidence will drain your cash pool faster than hookers and blow.

2- They have a proven track record of multiple shipped products.

You don’t want a hotshot kid out of school, you want a seasoned professional, preferably one who knows how to write applications for the industry you’re trying to reach.

3- They care more about frameworks than plumbing.

Unless you’re trying to design a complex new mathematical algorithm (in which case you should probably be partnering with a university research lab), you want someone who can grasp a system rather than a method. If this guy ends up in deep technical discussions about the optimal way of implementing a sort, you’ve got the wrong guy.

4- They’re not willing to work for free

Risk management and strategic thinking is key to long-term project viability. If you have someone willing to work for equity, they’re willing to take risks with your payment processing gateway just as easily as they’re taking a risk on you.

5- They believe in development process and best practices to speed up their work.

The last thing you want is someone who’s trying to reinvent the wheel. Mind you, this also likely means that the first two weeks or so of development you’ll see a lot of development support tools get set up and used before code actually starts, but that’ll give you time to get your documentation in order.

6- They have a positive attitude.

If someone bitches, they’re looking to blame themselves. Instead, you want them to identify their concern as a problem they can solve.

7- They get uncomfortable when you ask about their social life.

’cause, well, currently it’s still socially odd to prefer coding on a saturday night.

8- You don’t want Alphabet/Acronym soup in their technical skills.

Lots of languages means little depth in each, and depth = speed. Pick a serverside language (PHP, .Net, Ruby, etc), pick a database (MySQL, SQLServer, Postgres, etc), and pick a frontend (Flex, Mootools, JQuery, etc). Focus on that. If a dev has only a few languages this does not mean they’re stupid- it means they know how to focus.

9- They’re involved in the community.

Speaking, attending, whatever, you need to make sure their technical skills don’t stagnate, and that they’re willing to accept ideas from outside.

10- You respect them

Respect means you are willing to listen when they tell you you’re full of it, and that’s key in a partnership. You’re not looking for a monkey you can put in a corner who can bang out some code- you’re looking for a partner who’ll act as a technical sounding board.

So now I have this question: What makes for a rockstar business partner?

Cool, huhn? Security concerns aside (Believe me, I am never giving anything on facebook my credit card information), this isn’t exactly new- pushing product information into the Facebook stream was what the original Facebook Beacon was all about, and that was shut down via a class action lawsuit because it published user sales data without user approval. Additionally, pushing rich media applications into the Facebook stream is not new- anyone who’s viewed a youtube video in their Facebook stream knows how seamless that can be. What’s interesting though is that Resource has overcome the legal concerns with two changes: First, by giving users control of what to share when, and secondly by actually launching a full commerce application into something that people check every day.

If your initial reaction is disgust (“What? Another way for people to sell us their stuff? Blegh”) then you and I are pretty much on the same page, however don’t be blinded by other creative uses of this. For instance, if you want to buy someone a Christmas present, wouldn’t it be nice if you saw their wishlist items in the stream? What about gaming- if a friend of yours is playing some kind of a live flash mini game… wouldn’t you want to join them immediately? There are legitimate uses for this that don’t turn your stomach, so I figured I’d write a quick overview on how to put it together.

So how did they do that?

If you already have an application you want to run inside the Facebook news stream, then the process of getting it shareable is extremely simple, and is easily accessible to anyone who knows a little bit about flash, HTML metadata and the facebook platform. You have to perform the following tasks, most of which are trivial unless you are trying to do anything covered by a regulatory body (like accepting credit card information). For that you have to have a secure and federally accredited server, and that’s way outside of the scope of this article.

Step 1: Add the “Share on Facebook” link on the page in question.

The first thing you need to do is give your users the ability to actually share your page. This can be as easy as including a particularly formatted link in your product page or as complicated as including FBML in your site’s header and namespace. Note that the share URL can include URL parameters that will customize the content of the page, and should be pointed at the hosted URL of your flash application- this is crucial for step 2.

<a name="fb_share" type="button_count" href="http://www.facebook.com/sharer.php?u=[url to share]&t=[title of content]">Share</a><script src="http://static.ak.fbcdn.net/connect.php/js/FB.Share" type="text/javascript"></script>

Step 2: Add the correct meta tags to the page you want to share.

When a user clicks on the above link, it actually triggers the Facebook Sharer script to scrape the provided URL for metadata that tells it how to share this page. All of this data is contained in the metadata tags of a page, and you can read the extensive documentation here, however the important piece you’re looking for is how to share multimedia content. If you’ll read the documentation carefully, you’ll notice that while all references talk about video, in reality this share functionality allows you to display any flash content in the Facebook stream simply by replacing video_url with the URL to your flash SWF. This is still restricted to user action of course- nobody will see a flash app launched immediately, they’ll still see the icon and title as with any Youtube Video, and the application won’t launch until the user actually clicks on the icon.

<meta name="title" content="video_title" />
<meta name="description" content="video_description" />
<link rel="image_src" href="video_screenshot_image_src url" />
<link rel="video_src" href="video_src url"/>
<meta name="video_height" content="video_height" />
<meta name="video_width" content="video_width" />
<meta name="video_type" content="application/x-shockwave-flash" />

EDITORIALIZING: What worries me on this is that Facebook’s documentation is very clearly targeted at video sharing, and that this may be a violation of their intent of the sharer script. In short, what Resource is publishing as an innovation to social commerce is little more than a hack bolted into a loophole. Even so, I don’t believe Facebook will try to blacklist retailer sites to put this genie back in its bottle, because it both encourages use of their platform while also opening the gates to more legitimate uses. The ability to see that someone is, say, playing a game right now and your ability to join them is only a single click away puts an entire new spin on live online gaming, especially with the recent release of Adobe Collaboration Services, but I digress…

Step 3: Get your domain whitelisted by Facebook

If you paid especially close attention to the documentation linked above, you’ll also note that multimedia sharing won’t work if your domain is not whitelisted by Facebook. This is to protect Facebook from people who might want to distribute illegal content that would get them in trouble (licensed movies for instance), but also gives Facebook ultimate white and blacklist control over any activity they don’t want subverting their functionality. The process is actually extremely simple: Click this link, fill out the form, and wait for them to get back to you. Last time I did it it took less than 24 hours, but that was for a major retail site; your experience might vary.

That’s it. Enjoy!

We all know that students have no money- many of us have been there and scraped by on ramen and coffee often for weeks on end, and now we are all, to a greater or lesser extent, burdened by the cost of our education as we have leveraged part of our future to gain the success we have now. It’s part of our environment. It’s who we are, it’s what we expect, it’s part of our lives, and it will be part of our childs’ lives as they grow up. We don’t think much about it- it’s simply there.

If you’ve watched this video from TED on how schools kill creativity, you know that there are some salient points to be made about how our primary and secondary educational system encourages a certain type of talent – science and maths – while actively discouraging the humanities and arts. While I would love to see more study on the topic, I want to extrapolate on Sir Ken Robinson’s argument and apply it to the space of postsecondary education.

Consider: If you were a student entering college today, and you were told that you’re going to walk out with an average of $23,000 in debt ($33,000 for private schools, according to this study [PDF] ), would you choose a career in engineering or in the fine arts? To quote one student, borrowing so much only makes sense “as long as you’re going to the school for a career that will pay enough”, so it certainly seems like we are actively discouraging pursuit of “cultural” careers in the arts and humanities.

Is this a problem? Good question, but it certainly shapes our national identity. If we want to be known as a country of technical innovators, then this system is perfectly fine as it fills our homes with highly technical thinkers. If in contrast we want to be known as a cultural mecca, it’s the worst thing ever as we are actively discouraging our students from pursuing fields that contribute to that.

But that’s not the point I’m trying to make here, it is simply the path to how I got to this blog post. See, I see this as a problem, and problems need solutions, so I want to take a business-side approach to this issue and ponder on any market opportunities that might exist. After all, if federal programs are unable to meet this country’s educational needs, then private business will have to pick up the slack, and they’re only going to do it if there’s money to be made.

Some Numbers

To take some numbers from this study [PDF], I’ve extracted the following table:

Table 1: Total Student Aid and Nonfederal Loans Used to Finance Postsecondary Education Expenses in Constant (2008) Dollars (in Millions), 1998-99 to 2008-09

What we can easily extract from this is the individual line items which add load to students. The loans are easy, and I am also including Work Study and Institutional Grants. The former, because it’s activity that actively detracts from a student’s attention to their studies (by having a job) and the latter for reasons I discuss below. Given that, I’ve generated the following table:

Table 2: Total unmet need covered by students in Constant (2008) Dollars (in Millions), 1998-99 to 2008-09

Do you see what I see? I see a $128 billion dollar demand for a solution, but demand is only useful if a supply may be found that may be profitably offered to that market. Thankfully, the actual act of marketing any solution you can come up with is easy- between high school career counselors and college students’ naturally viral nature you effectively have a captive audience, assuming your solution is a good one. But unless you’re the treasury or the federal bank you can’t exactly pull $128 billion dollars and slap it on the table, and even if you were I doubt the taxpayers would be willing to pay for that (though we do love our bombers).

Universities as Contributors to the Problem

On of the real culprits in this whole situation is Universities themselves. College Tuition has been increasing at an average rate of 8% a year, while the median household income is hardly keeping up, especially if you take inflation into account. My own Alma Mater for instance (Carnegie Mellon) posted an annual tuition rate of $40,000 dollars this year, which from what I can tell is the highest in the nation and a significant uptick from the $18,000 I was paying in 2000. So how exactly can universities justify this increase?

Fact is, those tuition numbers are simply not real, because universities are skimming the market. Simply put, all the financial data a student is asked to report when they apply for financial aid year after year is used to calculate exactly how much the student and their family can afford. Once they have this number, they will add as many student loans as the student is eligible for (maxxed out of course), and might even add some private loans to it as well. Once they have that number, they will add something called a “Need based grant”, “Merit based grant” or “institutional grant” (or something similar) as a line item to make up the difference because they can’t charge you any more.

This makes identifying a good solution to student debt a far more difficult problem, because as soon as you find a business solution to meet the above noted demand, universities can simply respond by adding another line item to their financial aid calculations and the problem is right back where it started.

Or… is it?

Here’s where things get a little devious, and I apologize for suspending my personal ethics to even suggest this. Consider: If you provide a method for students to raise money against their debt, and universities in response raise their tuition to capture that value so that the debt doesn’t actually go away… then they are increasing the size of the market. That’s right, simply by helping students find a way to meet their debt obligations, the behavior of the other actors in the market environment will ensure that your market size grows. And while this certainly doesn’t provide a real solution to the actual problem, it should have any finance guy’s salivary glands working in overtime.

If, of course, you can meet the demand. In a new and successful way.

It’s fairly common for politicians to convert extremely complex topics into sound bytes. We’ve seen it happen- so and so will take their opponent’s economic policy, pull it apart looking for the slightest thing that might motivate the opposition, and then use it like a hammer to completely discredit their opponent. So has it been with the claims of the 45-day old election propaganda (does anyone still remember how much they cared back then?), so it will be with any and all upcoming elections as long as this firebrand strategy pays off.

One personal pet peeve of mine has been the Main Street vs. Wall Street debate, a catchphrase so overused that it’s rivaling Britney Spears for airtime. These five words attempt to turn two fundamentally different economic management systems into a bullet point, and allow anyone to repeat them in an argument while fully absolving themselves of actually understanding what’s going on. It’s easy, we’ve all been guilty of it: What’s more important? Main Street or Wall Street? The former of course. Why? Because it’s more relevant to more people.

Wrong.

The actual discussion is far more subtle and complex than that, and is rooted in the core difference between two economic management systems: Top Down vs. Bottom Up Capitalism. Fundamentally, these theories attempt to place a framework of understanding around economic activity, so as to simplify an incredibly complex system enough that it may be managed, encouraged, and in limited cases predicted. In other words, we understand that a country’s economy is so complicated that we don’t have a clue what’s happening, but we’ve got a sortof vague idea and theory and based on that are going to see if we can prevent it from getting out of control.

Amusing, isn’t it, that “Wall Street” is a simplification of Top Down Economics (Main Street likewise)…. which is a simplification of something we don’t really understand to begin with, but I digress…

To really set the stage for this discussion however we have to set some common ground.

The heart of a capitalist society is the Individual

While some call this person the “Consumer” while others call this person the “Worker”, fact of the matter is that it’s the same person. The Individual is an economic entity unto itself, and through his or her labor produces value which nets them currency from the market, which is then subsequently reintroduced into the market to support the activities of said Individual. In short the Individual is a unit designed to generate and spend wealth, which allows us to define “corporations” as Individuals within a market. In fact, Corporations and Businesses are usually seen as individuals for legal reasons, so at least there we have some backup.

The economy is measured by the movement of money, not the amount of money.

Let’s get one thing straight: If you have a lot of money in your mattress, it’s paper. It is not being used, it is not increasing or decreasing in value (Well, barring in/deflation), it is not helping you acquire goods and services, and it’s not getting registered on any beancounter’s analysis spreadsheet. The economy is defined by the transfer of money through purchase or other means. If the money doesn’t move, it’s worthless.

A single dollar is valuable

While to you or I a single dollar bill might be fairly trivial in economic terms a single dollar has an incredible impact because it is multiplied across millions of Individuals. Provide a $0.25 tax break to everyone in an economy and you suddenly have millions in surplus capital. Similarly, if you provide a $50 Million tax break to one individual (easier done with companies) you have a similar effect. The scale of either action does not matter, because from the side of the entity offering the tax break it all looks the same. In other words, economic actions may be performed regardless of scale, because a single dollar has value no matter how you slice it.

Competition makes the world go round

The true free market advocate (of which I am one) believes firmly in the rules of fair and equal competition. If the playing field is equal (that’s a completely different argument), then the best company should succeed. Notice how I didn’t say “win”- as with any real life simulation, the idea of winning and losing becomes largely meaningless, because we are not playing on a terminated field: The dice keep rolling, the clock keeps ticking no matter what you do. It is in this environment that those companies capable of making the best decisions succeed, while those that make the worst fail, and through that competition we see the ebbs and flows of today’s market.

Top Down Economics (Wall Street)

The basic theory behind top down economics is that management begins at the top, because as soon as you give an Individual (corporation) with far reaching arms the means to expand its operations it will do so (and vice versa), and the cascade effect of new infrastructure will give the appropriate economic kick in the pants.

There are two problems with this theory: First of all, you cannot easily distinguish between companies whose operations have a global reach vs. a local reach (i.e. you can’t say whether your money is leaving the country), and secondly that you cannot account for pork in the pyramid of corporate power (Like, say, CEO salaries).

Bottom Up Economics (Main Street)

Bottom Up Economics believes that if you provide the small individual with means, they will use it to support themselves and thus encourage the movement of capital through the economy. Furthermore, in search for each individuals capital, corporations become more competitive and thus, theoretically, provide better products and services.

Speaking personally, my own budget has always expanded to consume my income, so I can certainly speak to its effectiveness, but this theory has significant problems of its own. First of all, competition between corporations is as much quality and process (real quantitative moneymakers) as much as it is marketing and message (very qualitative moneymakers). Fact is, you can make crap, have a great sales guy, and shame people into shelling out money. Furthermore, you’re hoping that your individual consumer is spend happy and doesn’t save their surplus.

So which is better?

Both, of course, or neither, depending on the environment. Fact is they both have serious logical holes, and situations exist where, if anything, they’re the worst idea ever. It’s all well and good for you to give money to either the top or the bottom, if they end up behaving the way you expect them to. This almost never happens, but let me give you a couple of drastic situations:

Deflation

If currency is currently in a deflationary cycle, then your average day to day individual will take any money you give them and hold on to it, because they know full well that the special shiny thing they wanted to buy will be cheaper tomorrow… and tomorrow… and tomorrow. In other words, a bottom up economic system will completely and utterly fail in a deflationary cycle, assuming that’s the only factor affecting purchase decisions.

Low Unemployment

If your country currently has the (enviable) problem of low unemployment, then any corporation you give money to is in a bit of a bind. They now have the capital to expand operations, but the local labor market is extremely competitive (and therefore expensive). If they want to expand operations they can choose to stay within your country (at a much reduced effective rate of capital) or they can spend that money overseas for much greater effect. In short, a top-down economic approach will fail in a country with low unemployment, because the money is far more likely to flow overseas.

In both of these cases, the economic theory given completely breaks down, largely because you failed to take into account the conditions in which you’re operating. Other factors could include the level of regulation (more means fairer business practices, less means lower cost of business) as well as corporate/individual taxes (social security/Medicare/regulatory oversight vs. economic capital), and each have some very complex effects on the system.

Expanding this to the real world, let’s take a look at the mid 2000′s: We’re in an economic boom time, and the consumer is flush with credit (if not cash). Business is going great! So why question something that works- We’re going to continue giving tax breaks at the top, keep reducing regulations and continue to deregulate our industries. Business, after all, has proven that they can look after themselves.

And look where that got us. Would a more stringent regulatory strategy have gotten us somewhere better? Perhaps. Would increasing taxes at the top and reducing them at the bottom have kept the field more competitive rather than strangely lopsided? Perhaps. What we do know is that the correct approach to handling the US’s financial and economic matters was not what ended up happening.

Full Circle

And yet we always must have someone who’s right, and someone who’s wrong. Face it, we’re a binary species, and love to be on the winning side. I have many republican friends right now who feel like they’re on the losing side right now, simply because the present administration’s economic policy seems to be to blame for the meltdown that the opposing theory is trying to get us out of. One way or another, we each try to pick one side and go with it, and based on that we win or lose (or rather, we lose the election but we’re still right).

This isn’t a question of us vs. them. This is a question of us actually thinking about the issue, and coming up with the right solution. Intelligence and an open minded approach is the right strategy, and by actually turning off the television and sitting down with a problem by ourselves or as a community, we can easily overcome this problem and solve the issue not just right now, but for future crises as well.

Internet Explorer 6 is old, very old. It was released on August 21, 2001, which in technology terms is archaic. To put things in perspective, the original, first generation iPod was released two months after IE6, shortly followed by the original XBox, subsequently followed by the first monochrome BlackBerry in March of the following year. Processors at the time had barely broken the 1GHz mark, and the Dot-Com bust had come and gone, leaving its mark on Redmond and Silicon Valley.

Since then, many newer and better browsers have been released, all of which do a better job of implementing those standards (Though few do so completely). As a result developing for these browsers has become even more painful, because web developers have to support both the newer, more standards compliant browsers as well as trying to accommodate for IE6′s eccentricities. And yet IE6 continues to appear on spec sheets and software requirements, and is a continued presence in web analytics reports. We’re still stuck with it, so what gives? If it is really so painful to develop for, and really so limiting to the user experience, why has IE6 not been unceremoniously ejected from the web?

Who’s Not At Fault

Blame is tossed around like candy when it comes to figuring out who’s at fault. One of the common ones is the outdated hardware, yet even in the notoriously underfunded and out-of-date nonprofit sector (this study claims 44% of nonprofits operate on 3+ year old hardware), the software is reasonably recent (89% on Windows XP). If anything, the nonprofit sector is ahead of the curve, perhaps because they have to rely on smaller software providers.

The larger part of the guilt is usually laid at the feet of large corporate IT departments. I’m not talking about mid-sized businesses, I’m talking about behemoths that, along with their size, have a reputation of moving incredibly slowly and always being several versions behind on everything. Some people erroneously say that corporations like this don’t want to shake things up by going with something “untested” and “potentially insecure”, but in reality the largest part of the blame for all the frustration they’ve caused isn’t even their fault.

One of the primary systems that large, corporate IT departments maintain are Enterprise Resource Planning (ERP) systems such as SAP, Oracle, Peoplesoft and so forth. These systems are massive- a full implementation will touch every part of an organization from accounting to inventory and requires several years to implement. Their benefits are many- they greatly improve reporting, planning, and in many cases automate core business operations.

Additionally, these systems are ridiculously expensive, not only because of their original licensing fees, but also because these systems have to be highly customized, and at $180/hour plus expenses for a competent ERP consultant that bill starts to add up. With a pricetag of many millions of dollars, installing an ERP may still be easily justified (given the operational benefits it would provide), however providing a positive ROI for the incremental benefits from an upgrade are a lot more difficult generate.

To illustrate, take a look at these two excerpts from a product compatibility matrix for SAP Netweaver ’04 and’07, valid as of April 2008 (the date on the presentation. You can find the version for ’04 here and for 7.0here , and as you can see they don’t exactly support anything but Internet Explorer. Add to that the extremely high cost and only incremental benefit of upgrading and it’s really no surprise that IE6 is still standard at major corporations. The ERP solution is the decision driver, not the browser, and that’s the real reason IE6 is not about to go away.

Product Compatibility Matrix for SAP Netweaver ’04

Product Compatibility Matrix for SAP Netweaver 7

So what happened?

Remember all that hooplah several years ago about how Microsoft was being uncompetitive and monopolistic in its actions within the browser wars? This is the aftermath. By continually encouraging corporations and their software developers to make use of the full capabilities of Internet Explorer 6 and the admittedly feature rich ActiveX controls, they have succeeded at carving themselves the largest part of the browser market. Unfortunately, by doing so they have also forced a large portion of the web into obsolescence.

So who’s really at fault here? Microsoft for pushing its development platform, or the ERP system providers who developed for it. Personally, I think the blame is where you prefer to put it based on your own technological preferences. If you’re a huge OSS fan, Microsoft’s a convenient target. If you’ve ever been frustrated by ERP’s, then the provider is the target-du-jour. Personally, I’m more likely to consider the product managers, directors and developers who made the platform decision without considering the long term implications.

So are we stuck?

Sortof. With the impending release of IE8 web developers will be able to tell the browser to “pretend” to be a previous version, neatly circumventing any future compatibility issues. Unfortunately this only works for Internet Explorer, meaning that ERP developers have no reason to change past behaviors. Until they disengage from using proprietary extensions and ActiveX controls and start relying more on open standards based development, we’ll never truly escape this cycle, though Microsoft has made backwards-compatibility a lot easier.

And that’s exactly what Microsoft wants: Allow their development partners to improve functionality and give their clients reasons to upgrade, while not forcing their other partners (IT departments dependent on ERP’s) into technological obsolescence… sortof. This process will take a while, because IE6 isn’t one of the browsers IE8 can be reset to, but eventually we will see IE6 go the way of Netscape, only to be replaced with… Internet Explorer.

Bad news like that is almost inevitably followed up by commiseration about how many hours they’ve had to work recently, how they’re constantly under pressure to put in more, or how their coworkers have had enough and have left for greener… or at the very least less stressful pastures. This in and of itself isn’t necessarily bad- we all understand the pressures of marketing and agency work, and a certain amount of dedication to the project deliverables are par for the course. Yet when weekly hours exceed 50 on a regular basis, you’re buying short term productivity by draining both current and future creativity of your talent. Speaking from experience, gradual burnout is still burnout, leaving long-term scars, and the tightening of client budgets and inevitable cannibalization of the RFP bid has resulted in even more frightening stories: Talented designers and developers are going on antidepressants because of their work load (source withheld).

When I heard that, my first response was outrage. My second was to cast the management of those agencies in the worst light possible, as either willfully ignorant or maliciously exploitative. My third was to do a quick mental inventory of all the openings at Resource just in case there was a way I can get them out of that hellhole. Regardless of those, I’m confident in stating this: Those agencies are going to fail.

Ur Doin it Rong

Your talent is your greatest asset. Designers, developers, strategists, information architects, analytics experts, effectively all the people who actually produce whatever deliverable you’ve agreed to are the guts of your operation, and without them you’re simply a self-style executive or sales guy more useful as a hot air balloon.

So lets assume that you’re said executive with a production team, and hard economic times and active competition from other agencies has forced you to cut timelines and reduce your RFP estimates. A few of your employees are forced to work a few extra hours while you’re busy trying to find more clients, but the pressure doesn’t let up, becomes systemic and suddenly you’ve built a culture that expects 100% lifestyle dedication. If this was intentional, shame on you. If it wasn’t, you’re going to need to take drastic measures to fix it.

Your Reputation Is At Stake

As talented SME’s in the digital space we are of course extremely active online, and have a vibrant community of our own. We keep in touch over twitter, email lists, websites, blog, professional networking groups and what have you, and news like “I had to work a 100 hour week last week” gets around quickly. So while your marketing personnel and senior leadership are busy worrying about how your company’s brand is projected to current and potential customers, that same brand is being systematically undermined and destroyed in the professional communities that represent your talent pool. One single negative report is enough to mark you as an agency to stay away from, and in tough economic times it’s going to be much easier to accidentally cause these. In short, you might look good to potential clients, but when you try to hire the talent for that project which will grow your agency to the next level, the community will laugh in your face.

Let me emphasize this: If you put more pressure on your talent, the stress will reduce their creativity and productivity in the short and long run, you’ll have to hire more, which will refuse your offers because you’re known in the community as someone who works your employees to the breaking point. End result: You’ll be unable to produce high quality work anymore, and instead will leave your client with a bad taste in their mouth as you under-deliver on your promises, ensuring little to no repeat business.

And that’s the crux, isn’t it? If the web has taught us anything, it’s that high quality work (shameless plug) is a better sales person than anyone you can hire, and if your HR policies, culture and project management are systematically draining and destroying the talent which produces such work, your agency is either on life support or is one payroll cycle away from being roadkill. All the sexy, high margin projects will go to those that have the talent to consistently produce it, and you’re left with those clients unable or unwilling to pay for it.

It’s simple economics. If your production talent is interested and engaged, you’ll see the product quality increase while efficiency increases as well. We’ve seen this with Toyota and American Airlines, and there’s plenty of evidence that fundamental truths like this easily translate to the agency world.

And while that’s all going on, community leaders like myself as well as your competition will be waiting in the wings, ready to poach your best and brightest at a moment’s notice. So wake up, face the music, and realize that your agency’s bottom line is only as happy as your employees.

How will this impact Web Development?

This largely depends on what kind of web development you do. In most
cases you and your enterprise won’t be affected in the slightest.
Chrome has a very fast and robust rendering and JavaScript engine, and
much like any newly released browser (remember Firefox 1.0?) loads up
in no time flat. The rule of thumb is that if you’re already supporting
Safari, you can safely assume you’re supporting Chrome.

Why is this? What you may not know is that the underlying  engine that Safari runs on is a package called WebKit,
which is the same engine which powers Google Chrome. There are some
revision based incompatibilities (Since Safari’s already a few versions
ahead), but practically speaking they’re identical. The downside of
this is that if your agency is one of the rare islands left that only
support the “Two Major Browsers” (Firefox and Internet Explorer), you
no longer have an excuse to not support them.

If you’re doing Rich Internet Application development, you’ve just
been presented with a very interesting way of taking your application
to the desktop. You might not have heard of Google Gears
before now, or might not have considered it to be a viable option.
Gears is a browser extension framework that allows desktop-application
like interaction between your RIA and the client’s computer. Sounds
neat, right? It is, and it’s directly integrated into Chrome and is
available as a plugin for both IE and Firefox. Unfortunately, the major
restriction of Gears up to this point was that you were still
restricted to the browser’s UI, but as I point out later in this
article this is no longer entirely the case.

What about Mobile?

If you’re doing Mobile Web Development, you may be able to target
WebKit directly from this point forward. See, Safari is the exclusive
browser on the iPhone, and with the upcoming release of the T-Mobile HTC Dream,
you can bet that Chrome will be the default browser for Android. What
this means is that WebKit will become the de-facto web development
standard for mobile devices. While mobile UI patterns and application
frameworks will shake themselves out over the next few years, the
writing’s on the wall: If you want to take RIA’s to mobile devices
without bothering with a native application, WebKit is the platform to
build for.

So What’s The Big Deal™?

At this point you’re probably asking yourself: "What’s the big
deal"? If Chrome behaves much like the other major browsers out there,
why is there so much buzz about it? Is this just Google Hype?

Without going into a lot of gritty detail  about it (The Comic Book
published by Google does that really well), the major big deal is that
Chrome is not just a Browser: Chrome is an Application Platform.

Much like AIR, Chrome attempts to blur the lines between the desktop
and the web by creating a wrapper for previously developed content.
They even do it in very similar ways: AIR allows the execution of
JavaScript RIA’s in an integrated WebKit Browser running within the
ActionScript Virtual Machine, while Chrome allows the execution of
Flash RIA’s running in the Flash Player. The difference is simply the
technology stack used- Chrome is based around JavaScript and HTML,
while AIR is based on ActionScript and MXML.

The Google Engineers are quite explicit about this. The Comic Book
talks about it, and one of the primary features is "Create Application
Shortcut". While functionally this really just creates a direct link to
a specific website, the integration of Google Gears allows some
websites to move almost entirely to your desktop. It even goes so far
as to use the favicon for your application icon, giving you a Desktop
Application experience for any website you choose (try it with Google
Calendar or Gmail).

So what’s the Big Deal? It’s a concept change, a different way of
looking at the Web. It’s not particularly new- Microsoft tried to do
this with the close Windows/Internet Explorer integration in the late
90′s and .chm/.hta applications, but it is the first time that the
browser’s been turned into a (soon to be) platform agnostic application
wrapper.

A Future Vision

Not to be a crazy futurist or anything, but consider the following
possibility: Both Google and Adobe have now firmly cast their lot in
with an ECMAScript/DOM-like technology stack, and we already know that
there is a close relationship between the two companies both from
YouTube and from the indexable headless player. Personally, I think
it’d be pretty interesting if the future held a technological
convergence of all ECMAScript languages. Compiling HTML to a desktop
application? Converging JavaScript and ActionScript into a single
ECMAScript language? It’s all possible.

You know what I’m talking about- it’s that sudden snap in someone’s actions, that excitement and readiness to go, that real drive to go and pursue something- it’s the drive that makes someone awesome at what they do. Yet even so it’s something that can easily sound hollow when that spark isn’t there, which usually happens in the context of a tool rather than a concept. Can you see someone really get excited about blogging? No. But can you see someone being an avid educator? Absolutely: Their excitement comes from the contribution they provide and the respect they earn rather than the tools they use.

The best way to describe it, perhaps, is to separate passion and the expression thereof. As an example, I’m going to use my own dad, because frankly he’s the best example I can think of. His primary passion is problem solving. Taking the crowbar of his brain and jamming it into a particularly interesting problem to see if he can crack it is what he lives for. Now imagine how this might express itself, in how many different situations this might apply.

Need extra paper? I did- overcoming a particular challenge or problem is applicable almost anywhere. In his case the long-term chosen primary expression is quantum physics, but there’s no reason it couldn’t have been radio repair, satellite telemetry or dog training since each of them provides a series of always new and increasingly complicated problems to solve.

So lets get around to what your passion might be. Is it exploration? Healing? Craftsmanship, education or guardianship? I’d give you a long list of how to figure this out, but chances are it’s already blatantly obvious (you may not have bothered to look). Remember it’s not what you do, it’s why you do it. Take a long hard look at your day to day, figure out what you really look forward to, why, and find the common ground amongst them all.

Undoubtedly, the first procedures that can extend the human lifespan will be clinical in nature and sinfully expensive. I envision large, electronic devices that do all sorts of interesting things, making the prospective immortal little more than a bedridden cyborg brain. Why would anyone be interested in this? Well, people have done stranger things, like flash-freezing themselves until medical science can revive them. If the prospect of living on machines for just long enough for just long enough to be released from the machines is even remotely possible, someone will shell out the millions it takes to actually do so.

This will create a huge uproar, because… well, who doesn’t want to live forever? Limiting this benefit to those that can afford it is going to create a whole new concept of class separation, which most democratic societies will censure almost immediately. As we can see with Stem Cell research, countries that hamstring medical advances of a particular type find themselves well behind the times, and the nascent immortal population will find that they’re strapped to machines far longer than their budgets had originally projected. Expenses will rise, and only the extremely-super-rich will be able to sustain themselves… unless everyone emigrates to more lenient environments.

Yet even here there’s an interesting benefit. While the parent’s amassed fortunes would previously have gone to their heirs, they’ll now be spent on keeping them alive for long enough for medical science to advance to the point of no consequence. A trust fund only goes so far- chances are the first two or three generations of immortal offspring will be forced to fend for themselves or join the dirt with the rest of us.

Sooner or alter we’ll then reach the point of no consequence. This is the point where life-sustaining procedures no longer requires hospital time, and immortals can continue their normal lives with only token effort on their part. While this may sound great, it really is just the first step in the commoditization of these procedures. Privatization of the industry will occur, prices will come down, and soon enough immortality will be accessible to everyone.

This will really set off the simmering ethical battle, where the religious and the evolutionists will find themselves to be strange bedfellows: On one side, those that choose immortality will be cheating God’s plan, while on the other they’ll be halting evolution. Once again there will be cries for both social and legal limits on immortality, yet now the deck will be stacked against them vis.a.vis numbers. The funny thing is that it won’t really matter, because those that choose immortality at this point will eventually realize they’ve paid the price of genetic obsolescence.

Consider: 100, 200, even 1000 years from now, human intellect and physiology will have evolved significantly, and immortals will A) have all the money, but B) be unable to compete with the newer generations. This will either create a rich aristocracy begging for a revolution, or a zoo-like environment where the ‘spoiled little rich kids’ are allowed to exist in their little obsolete world, while the rest of the species goes on without them. That is assuming, of course, that they aren’t euthanized due to massive overpopulation.

Either that, or we’ll start seeing human upgrades, at which point the entire evolutionary theory goes out the window because we assume we know better. Given how far we’ll have come to even reach this point, there’s no reason to believe these upgrades won’t be ubiquitous. Who even knows what humans will look like by then: Will you have a small Apple logo under your ear, indicating an iPhone implant? Will your hair naturally grow in rainbow shades? Will your clothes reshape themselves to be in-line with the latest styles?

And in that kind of environment a few rich little immortals will fit right in.

Before we get into the meat of this article, however, you have a decision to make: Will your organization truly benefit from such a celebrity? The benefits are significant- both your company and brand are affiliated with one of the names in the industry, and that comes with no small amount of prestige. Business will come to you simply to be associated with your celebrity(ies), and their name can be a valuable asset when converting new customers. The downside, however, is that celebrities are a pain in the ass to manage. They demand that their input is heard on everything that falls in or even remotely touches their domain of expertise, and will seed dissatisfaction if their input isn’t heard or integrated quickly. If your organization isn’t ready to support them, be very cautious- the last thing you want is for your celebrity to leave dissatisfied and publicly discredit your organization.

Identification

So let’s assume you’ve decided that a celebrity can add significantly to your business. You have two choices here- you can either attract existing talent, or you can nurture one from your existing employees. In both cases, it behooves you to be selective about their domain of expertise- attracting an expert in finance isn’t going to do your manufacturing business one whit of good, so make sure their knowledge matches your own business objectives.

Identifying talent should be pretty easy. Chances are they are already well established within your company or the community, and you won’t hurt for individuals willing to recommend them. The real trick here is substance- there are tons of individuals who have blogs that are little more than regurgitated trends, so what you’re looking for is someone who is adding to the conversation by providing their own ideas and insight. Just because someone has a twitter account doesn’t mean they’re adding to the conversation, it could just be that they’re a habitual retweeter or shameless self-promoter. A good rule of thumb to use for this is the “Holy Shit” effect- if, while reading a blog entry or paper of theirs, you have a moment of true “Holy Shit” insight, then you know that this person is capable of inspiring ideas and is an expert at quality content generation (Note- you’ll need to adjust for your own self-confidence, experience, and… a-hem… arrogance).

The other option you have is to nurture someone within your own organization, which provides the added loyalty benefit of gratitude. Again, identifying them should be easy- everyone knows them, they are frequently sought out for advice, and at meetings they are the ones willing to bite the bullet and ask sometimes stupid, sometimes compelling questions, and not just to hear themselves talk. Chances are that their hobbies are social in nature, and when given the opportunity they thrive in the limelight.

Engagement & Support

Having identified your desired celebrity, the next step is to establish a working relationship with them. It’s your choice on whether to engage them as a direct employee or as an affiliated consultant is up to you, though each comes with significantly different expectations. The former is an employer/employee relationship, where you can directly leverage their expertise to support your business (as well as promoting it). The latter is more of a client relationship, and convincing them to consult on internal projects will normally cost you a commission. Support is also fairly straightforward, and should already be in the skill set of anyone who’s worked in PR for a decent amount of time. Speaking pitches, convention appearances and invites, book authoring and more are things your celebrity might be interested in, and usually it’s only a matter of presenting an opportunity to get them to bite.

Fact is, being a celebrity is hard work. Authoring presentations, writing whitepapers and blogging each take quite a bit of time, and one has to remain image conscious at all times. Add to that the constant industry monitoring that these individuals engage in, and without support it’s practically impossible for one person to do it as anything other than a full-time job. This is where you, as an employer, can speak from a position of strength. As long as you provide them an environment in which their skills are applicable and their public identity is supported (with a little judicious image coaching in extreme cases), you present them with a rare and invaluable environment.

The Point of Arrogance

There is a point in time when you will realize exactly how arrogant your celebrity is. This is a crucial point, where they feel they could cut loose and do their own thing- in short, you need the celebrity more than the celebrity needs you. This point can happen anywhere: Raise negotiations, Watercooler conversation, a happy hour comment like “What are they going to do, Fire me?”, and it’s up to you to recognize that point and understand that all the investment and time you put into this celebrity is about to walk out the door. (Caveat: This doesn’t always happen- if the individual is already substantially invested in other ways in your company, chances are they need the company as well and recognize this fact).

Let me let you in on a little secret: The vast majority of professional “celebrities” out there have gotten to where they are with a significant amount of corporate support… and whatever you do, DON’T TELL THEM THAT! Instead, spin their own arrogance against them: If they think of themselves as an entity easily separable from the company, then frame the conversation as a mutually beneficial partnership: You get to promote through them, while mitigating the workload of their own self-promotion.

This can be as easy as changing the nature of your conversation with them. Instead of directing them to promote a particular product or attend a particular convention, you simply ask whether they’d like to do so (Frankly, you should have been doing this all along). Most humans have a really hard time saying no when a friendly favor is asked, and while it will appear as if you’re granting them the right to manage their own appearances, in reality you’re simply taking advantage of human nature.

Leader of the Pack

So what now? Well, at this point you’ve shown your organization that you’re capable of engaging and retaining a celebrity, and are reaping the benefits of their affiliation and advocacy while providing them with the recognition they desire. Unfortunately, this is also going to bring all the hopefuls out of the woodwork- sleepers that desire the limelight and see it as a source of long-term professional advancement, but have not until this point had the energy to pursue things themselves.

This halo effect is perhaps the most dangerous effect of having a celebrity in your organization, because no matter how experienced they may be, your hopefuls either consider themselves equal or firmly believe that with the same level of company support they would be. The question “Why them, and not me” is inevitably asked, and will generate substantial professional dissatisfaction through your entire organization.

You have two choices on how to deal with this: The first is to really understand everyone’s personal value structure and assist them in realizing that. This should work for most, though it might mean a few unscheduled promotions or raises. For the others, chances are most hopefuls are not willing to trade fame for their free time, but nothing short of personal experience will convince them of that. To assist with this you might do well to create a group much like Adobe’s Tech Evangelism program. A basic coaching program should suffice to give them the exposure to the hard life of self-promotion, and should weed out anyone but the most determined individuals.

The important thing to note here is that you have to support your hopefuls, if only long enough to convince them that they’re not cut out for the celebrity life. Giving someone the Standard Lecture About Community And Corporate Values (TM) is just going to sound like a lot of sensationalist crap.

Parting Ways

Fact is, the United States is culturally very focused on the individual, which means that sooner or later someone will make your celebrity an offer you can’t match. The more famous someone is, the more likely this is to happen, so get used to the idea; hopefully you’ll already have someone ready to take their place.

Having said that, all of your investment in this individual is hardly in vain, because they won’t forget all the support you’ve offered them. You can go the extra mile and commit to any future speaking engagements you’ve scheduled on their behalf, but that would just be icing on the cake. Make them feel welcome, support them in their new career path, and with this continued positive support you will ensure that you will get free advocacy from them in the future.

So lets talk about the consumer for a bit, in particular the consumer described in The Long Tail. Here is an individual who knows his/her own lifestyle and needs, who like particular applications over others, whose preferred experience with one service might be different from his/her neighbor’s experience for the same. This is an individual who, when presented with a Smart Phone, wants to have features and applications behaving a particular way, and will only put up with the provided options of the telco because there’s no other choice. In short, they have a craving for personalization, and will gladly move to any platform that has applications that meet their needs.

Deploying a mobile application to meet these needs is, in its simplest form, the following: First, you must have a developer able to access your SDK, platform and testbed with minimal fuss. Then, that developer must be able to deploy his application to a location where a potential user may download it onto their device. Lastly, the device must be able to run said application. These three tenets of Develop, Deploy, Consume can be easily seen on the regular web. Developers have their SDK’s, Deployment happens on a web server, and browsers allow consumption of the offered services.

In the mobile world this isn’t quite as simple. Yes, there are many websites now that have mobile components, yet lets face it: The form factor and memory constraints of mobile computing devices make it so that few applications can offer full functionality and experience while constrained by regular browser controls. Additionally, we are back to (for the time being) the computing world of the early 90′s, where applications are restricted by processing and memory constraints. Back then, however, we could load applications from Floppy disks, something that’s not so easy on a mobile device. The development platforms exist, but deployment (as noted above) is extremely difficult, and the broad diversity of devices makes your target installable base problematic at best.

So let us take a look at the various players in the mobile market right now. First of all, let us look at the telecommunication companies, those that have the aforementioned problem with getting something On Deck. From their perspective, they have control over their delivery platform, and getting something from their platform to a mobile device is simple enough, however their process is such that they have completely lost their developer base. There are too many devices, too many different platforms and form factors, and deploying an application is simply too difficult for any developer to bother building something. Imagine the computing world in the mid-80′s, and you’ll understand what I mean.

Next let’s take a look at Microsoft, which in our case will also double as any company that has a mobile application which they want to deploy. Microsoft has historically been brilliant in its developer support tools, so much so that it’s stupidly easy to develop an application for their operating system. Similarly, the fact that they are in the software and not the hardware business lets them sell a platform rather than a device, which allows mobile manufacturers to create devices that can run any application built for it. The place where they have failed, however, is in securing and simplifying the delivery platform, which remains under the control of the telco’s.

Third, let us look at Google and Android. Here, the development platform is easy to access and has some brilliant development tools. And… then what? Well, frankly, we don’t know a whole lot about how Android will be delivered, because while many manufacturers and providers have jumped on the bandwagon, we as of yet have no idea whether Android will use an open application deployment platform, or even whether phones built by their manufacturing partners will come with Android pre-installed. The suggested promise of Android is Build Once, Deploy To Any Phone, but if it means that a developer still has to get something On Deck with a Telco, you will once again be in the same boat as Microsoft- a common platform, but no control over application distribution.

I should note here that I doubt Google will not have some central application service, it simply hasn’t been announced yet.

Lastly, let us come to Apple. In this case I have to make a special note, in that while I recognize the SDK is publicly available, it is unfortunately not available for Windows (No, Aptana junkies, that’s just a web browser). Thus while they have alienated a good percentage of computer users overall, the additional cost of an OSX development platform is comparatively minor, and won’t detract a company interested in building an iPhone application. Taking that into consideration, they have everything buttoned up. Developers can access the SDK, they have an established and largely ubiquitous deployment platform not tied to the telco, and they have a device that will run any software built. This end-to-end solution is exactly the same thing that made the iPod so successful, because it got a user from Purchase to Play in one smooth experience.

And no, I don’t own an iPhone.

Lets take Twitter as an example. Their service statement is, in a nutshell, “We let you microblog”. They don’t do it particularly well, their online interface sucks, their features are extremely limited, and the service goes down so often that the “Fail Whale” has entered the colloquial as a term unto itself. And yet their users remain loyal, the service continues to be used, and it’s probably the most popular microblogging service out there.

Why? Realize that 80%+ of twitter activity goes through their API, not the website. In other words, the guys at twitter have opened up the doors to the kingdom and allowed the community to decide how they wish to consume the service. That same community has risen to the challenge, providing a plethora of applications, widgets and plugins that allow people to consume and update twitter where and when they want to.

Lets take a closer look at what actually happened here: Twitter provided an API… and let the community (whether individuals or businesses) suck up the cost of developing use cases and interfaces, do usability testing, write requirements and eventually write the software. In short they just made someone else pay for the entire involved and expensive front-end development process.

Not only that, but they also neatly sidestepped the need to perform strategic market analysis to manage their own growth. Rather than focusing on meeting the needs of a single segment (and expanding from there), they boiled the service down to its absolute essentials and let each segment figure out how they want to use it.

This approach isn’t particularly new. AOL IM and Jabber have been around for a while now, Google and Yahoo have been making their services available for years now, and most of all the world wide web itself is… well, a communication platform built on the premise of a server/client relationship.

The key is integration. There are so many services, websites and widgets out there today that only the truly exceptional will be able to stand independently on their own. All the others are fighting for search engine placement, social tags, advertising and community buzz to promote themselves, but are never likely to hit the big-time unless they can integrate themselves into their user’s pre-existing day-to-day activities.

Wouldn’t you call that the value statement of any new company? “Provide a service that improves a users day-to-day activity so dramatically that they can’t live without it”. Whether this is done via process improvement (Make a task more efficient / less frustrating) or activity enhancement (Now you can tag your pages while you surf them) doesn’t really matter, because the core task remains the same.

My favorite example of this phenomenon is Firefox, because it provides a platform where users can customize their browsing experience with all the ancillary services they want. Plugins exist for del.icio.us, livejournal, myspace, gmail, etc etc etc- all tasks and activities that may not be directly related to the core browsing activity, yet provide a sufficiently compelling experience enhancement that they’ve become part of day-to-day web surfing.

So in summary: If you’re providing a new service, put some serious thought into building an open API. If your services and your data (’cause that’s what it boils down to) are compelling enough, you stand a good chance of having the community take care of segmentation, marketing, and implementation.

Most startups start off as LLC’s, largely because it protects the partners from liability while still being a valid corporate entity. The catch is that these organizations can’t have more than 99 shareholders, which puts a serious limitation on the micropayment idea. If you’re looking for $1,000,000, your investors have to be able to pony up at least $10,000 each, and there’s nothing micro in those payments.

Therefore, for the concept to be viable, the company has to take the role of the investor on behalf of the fund contributors (either directly or via a subsidiary), which means it must become a financial entity structured like a credit union or a mutual fund. This then means SEC regulation, transparency, due diligence and most of all a cubic boatload of fiscal liability.

These are not insurmountable- in fact we’re fairly confident the model remains viable and profitable, however none of us felt confident enough to continue development on a prototype without getting some better expertise. It is, in short, an idea for mature and experienced entrepreneurs- One Security Lawyer, One Finance Guy, and One Technical Genius.

So where does that leave us? Well, we realized we had to get out of the Equity field and into offering Grants, because that removes the liability. Yet nobody’s going to offer a grant to a startup without equity, unless they are personally invested- and there exist plenty of companies that address the philanthropic market.

So where does that leave us? Scholarships. Create your own Scholarship. Students can display a YouTube video explaining why they should get a scholarship, and visitors can pay into a scholarship fund. All I have to do now is deliver in 24 hours.

This is an Idea Foundry post. For more information on what this is all about, take a look over here.

This weekend is Startup Weekend Columbus, a three day skunkworks convention where 150 people walk into a building for a weekend and do their best to get a few companies started. I registered for it a few months ago with the thought that it’d be cool to really dig into something new and shiny for a short amount of time, and have some good fun networking with others. Unfortunately, three things happened that I wasn’t expecting at that time.

First, I didn’t realize is that I would decide a week beforehand that the idea I’ve been kicking around my mind might actually be worth pitching.

Secondly, I wasn’t expecting this idea to be extremely popular- it swept the vote during the first elimination round, and now there’s a bunch of people here who’re interested in making this happen.

The third thing I wasn’t expecting is exactly how far out of my league I feel right now. I’m a developer- a damn good Developer, Sysadmin and Architect. I’m also really good at identifying trends and turning commonly held assumptions upside down. Strategic thinking comes fairly naturally, but writing a Business Plan? Identifying revenue streams? Not exactly my forte.

So, first things first, I’m going to stop referring to this as My Idea (TM) and start referring to it as Our Idea- I’m part of a damn good team from what I can tell, which is the entire reason Startup Weekend exists in the first place. Everyone’s bringing their expertise to the table, and creating a company.

So what will this company do? Well, we want to Crowdsource Startup Capital.

Startup (or Angel) investment has so far been the realm of individuals with enough net worth that this risky pursuit is offset by existing capital investments. Normal people don’t have five, six, or seven digits to drop into a new company, yet many people would be interested in doing so if they could. So… why not take a page out of the book of Barak Obama and Howard Dean, and source startup capital from smaller donors? Open up the field of Angel investing to people able to contribute $100, $200, maybe $500 each, and facilitate crowdsourced investment. Individuals seeking to fund their pitches would list their credentials (via LinkedIn or reference) and their business idea, including any supporting documents and research they may have.

That’s pretty much it. Conceptually extremely simple, with a target market of “everybody who wants to get in on that startup thing”. Once you get under the hood a little you realize there’s a lot of things one has to worry about- SEC regulations, how to handle the money, do you structure yourself as an investment firm/bank/communications business, how do you handle Fraud and so forth. And most of all, what’s the first step in the business plan? This is an industry so heavily regulated that releasing functionality and additional features are dependent on lawyers and accountants rather than developers and project managers, so the first thing we have to do is identify a revenue stream that will get us to the point where we can afford people like that.

In other words, the trick is finding step one, and executing on it by Sunday. What happens after that … well, one thing at a time.

You cannot own social media

There were a few really good articles on corporate response to social media here, here, and especially here, and the originating post that got me to really think about it here. In a nutshell, the desire to organize around social media campaigns is… well, Jeremiah says it best:

“It’s important to note, that in the end, these skills (the ability to communicate online) will disperse and grow to many employees. Generation Y comes to us with these abilities built it as a “digital natives”– yet the need to organize will still occur, it’s a knee jerk reaction to every corporation.”

The bottom levels, or ‘fringes’ of our workforce are starting to fill with people accustomed to communicating online with such speed and frequency that most senior levels of management have a hard time even comprehending. Normal corporate reactions such as blanket internal social media policies inevitably feel heavy handed, and the inevitable reaction is an unfortunate social backlash.

In the long run tweeting, blogging, Facebook, etc etc etc will be seen as ubiquitous as chatting or texting, and we all know how useful restrictions on those have been over the last decade (that is to say, not at all). The long-term shakeout will likely be similar: Keep it to yourself, don’t do anything discriminatory or illegal, and in return we’ll respect your right to free speech.

There’s nothing new about Social Media

Methinks I’m going to piss a few people off by saying this, but there’s really nothing new about Social Media. We toss around these terms and definitions to try to give shape the world around us, and when we come across a neat new interesting way in which people are communicating we like to slap a new label on it. Social Media is no different – we all love it, it sounds cool, it’s the hip word of the day, but in reality all it comes down to is that the social networks that used to exist in communities, neighborhoods and college campuses have increased in speed and scope. All the same social rules still apply: insulting people is a bad idea, buying people off is cheating, and actually smiling and listening to someone will earn their trust faster than treating them like a random statistic (regardless of whether you act on it). Even the ability to create communities isn’t new, it’s simply grown beyond the local.

Titles are meaningless, references are everything.

I had an interesting exchange with Steve Weiss at O’Reilly, in which we talked about the term “creative” and how it’s used. It’s no secret that I feel standard classifications are nonsense ( Designer vs. Developer? Strategy vs. Marketing? Leadership vs. Management?) but even moreso I take the statements of pretty much every self-proclaimed expert with a grain of salt. Anyone can call themselves a Guru, so without the reference of someone who’s opinion I respect I treat them with a rather large grain of salt.

Furthermore, the prevalence of reference sites, spam referrals and self-flagellating social cliques makes such trusted references suspect in and of themselves. See, I can find 100 people who will say something nice about me (say, on linkedin) simply if I ask them. Why? Because it’s rude to say no, and spin is easy. It is in-person face-to-face referrals that are far more substantive, especially if they’re unsolicited. Does someone casually mention another name during a conversation? Do their eyes light up about someone else’s ideas? It’s this complete lack of formatting that makes a reference more genuine, believable, and far more valid.

You can talk a lot. You can blog a lot. But can you act on it?

Self-declared expertise is all well and good (or not, as you see above), but unless you can take your ideas and implement them you’re just another windbag. That’s why I have such a strong love of Google’s internal policy to let the engineers drive the company – say what you will about the lack of advancement opportunity there, they certainly know how to execute. Similarly I have a strong distaste for any company that only shows their marketers, sales people, or public relations guys to the customer. Give me a project manager, give me an product designer, give me a financier (in the case of investment firms), but please, don’t give me someone whose key career skill is based on saying what I want to hear.

Unfortunately, the field is incredibly hard to break in to (Especially in software), and books on methods and methodologies are few and far between. So when my User Groups’ book shipment from O’Reilly came in with a complementary copy of Adaptive Path’s “Subject to Change” I was intrigued. From the title, the book is about “Creating great products and services for an uncertain world”. Think I was interested? You bet! Here was a book that seemed to be all about how to create and manage a product in the everchanging world of the internet! Unfortunately this particular edition was earmarked for a colleague of mine, however it took me precisely 30 minutes to track down a copy in a nearby Borders and start reading it that night.

You should note that I rarely, if ever, read professional books, that’s what blogs are there for. But I digress…

It turns out that my initial enthusiasm was a little naive, since the argument presented in the book was substantially different than what I was expecting. In fact, one of its chapters is titled ‘Stop Designing “Products”‘, which made me more than a little concerned. Yet having said that, and taking into account the often blatant plugs for Adaptive Path, it turns out the book was exactly what I needed, even though it wasn’t exactly what I was looking for.

Merholz, Wilkens, Schauer and Verba, Subject To Change: Creating Great Products & Services for an Uncertain World (Adaptive Path), O’Reilly, 2008

Chapter 1 lays out the foundation of the argument, which is that customers aren’t attracted to features, they’re attracted to an experience. Note that this does not mean bells and whistles – I can have an experience at a circus, but that’s not what I’m looking for in a laptop. Instead, it is critical to look at what your customer is actually trying to accomplish, and to make the experience of accomplishing that task as positive as possible. Layering on feature after feature is good only if the original intended task experience is not compromised, otherwise it simply adds noise to what should be an all-signal experience. In other words, good products are well designed, by which they don’t mean pretty, nor that they have an elegant software implementation. Design is instead used in the inclusive sense- all aspects of the product, experience and execution are carefully considered and integrated into one seamless whole.

This foundation is then built on in Chapter 2 by presenting the idea that the aforementioned experience is a strategic decision, and then clearly defining what that does and does not mean. Those of you who are trying to achieve some flavor of competitive advantage (aka differentiation aka edge etc etc) should definitely read this chapter, because it provides a long list of clarifications given the context. Quite frankly, the whole thing reads like a snopes article that slowly dismantles many lessons learned in academic marketing classes. My favorite one is the ideal of Parity – the misconception that a product can be competitive simply by matching features with the competition. See, a feature is simply that: An implemented piece of functionality on a product spec sheet. If accessing and using said feature requires an advanced degree in astrophysics doesn’t matter; the mere fact that the feature exists makes the product competitive.

With the supporting framework of their argument is clearly established, and Chapter 3 puts in context of previously established marketing approaches. When your focus is on the experience and the user’s motivations, habits such as market segmentation rapidly get turned upside down. You can no longer assume that the consumer is some faceless drone who exists to give you money, but instead have to give that person a face, a background a motivation, and an objective. A segment rapidly evolves into a persona, and eventually loses its distinction altogether- you’re no longer sculpting your message for a particular group or persona, but are instead approaching individuals to discover how you can best meet their needs and improve their experience.

Yet none of this can be accomplished without information, which is usually garnered by research (Chapter 4). Interestingly enough, the book does not necessarily go into individual research methods, but focuses more on the importance of qualitative over quantitative research and the need to involve every team member. Research, as is stated, too often happens in a strategy or research group independent of the team that will actually implement their findings, and thus the opportunity for consumer or persona empathy is lost within minutes of the powerpoint presentation. It is only by keeping everyone involved up front (though perhaps not directly contributive) that information gained is relevant, actionable, and provides durable insight.

Chapter 5 then takes us full circle back to the beginning, and really drives the idea that success is not driven by features, capabilities or marketing, but by the experience of the customer. It’s not just the experience of completing a specific task that is meant here, but the entire support system ancillary to that task. You might have an iPod, but without an iTunes all you have is a pretty piece of plastic. Find out what the customer wants to accomplish, figure out what it’ll take to perform all steps of that, and build a system to do so simply and elegantly.

At this point, the book could have ended and been a pretty effective piece on product design theory based on experience. It has taken us from the initial presentation of the idea all the way through the strategic advantage and full circle back to the beginning. Instead, it continues on and picks apart the actual implementation strategies, beginning with Design in Chapter 6. This is a beast of a chapter and not for the faint of heart, but is nevertheless utterly critical for understanding the depth of the argument. Design is picked apart by discipline, target, competency, strategic importance and implementation, and the chapter itself does a remarkable job breaking down common misconceptions. Design is necessary, strategic, and is presented as a mindset rather than a discipline, one that everyone must implement to properly contribute to the delivery.

Chapter 7 then goes into the nitty gritty of implementation by speaking about agile development methods. This is where the developer in me went squee, because for the first time I saw Agile presented within a strategic context rather than a reactive context. Too often when management hears “Agile Development” the first thing that comes to mind is “Development will be faster”, or more responsive, and in many cases this is true. Even so, the book presents it as an integral part of experience based design, and discusses how its rapid iterative nature can be used to convert a design or motion prototype iteratively into a fully functioning application, while allowing user research and experience evaluation (and revision) at every step of the way. If you’ve ever had to say “That’s what’s written in the requirements, we can’t change it now” this chapter is for you. Lets face it- issues and problems will arise during development no matter what happens, but if you keep everyone on deck (and not siloed into different expertise groups) you’ll be able to confront it much faster.

And with that, Chapter 8 closes the book. I’d copy the two pages that compose it here verbatim if I didn’t think there’d be conflict of interest issues, but safe it to say that it is the conclusion and summary of the entire book. The only thing certain is change, and here’s how you deal with it.

Personal Observations

Overall, a very good book, but I do have a few pointed comments. First of all, the cases presented within the book too often follow the pattern of “Here’s company X, known as a genius at Y, and here’s their process/methodology/etc.” The academic in me chokes at statements like that, because they imply causality – that their process is the reason why they are so well known and respected, when in reality it could be something completely different. The book itself warns of making surface level assumptions like that, so I’m fairly irritated that they do so themselves.

The other one is the mixture of authoring tones. At times casual, at times formal, it’s clear that more than one person wrote this book. When I’m reading a structured section about research and am suddenly approached in a conversational tone, my brain kicks me out of the narrative (and thus my experience with the book is diminished). Even so, I’d recommend this book to any marketer, strategist, developer… or, well, anyone who plays a role in a product production process. At 165 pages it’s a light read, the ideas are straightforward and well explained, and though they aren’t often supported as rigorously as I would prefer, the book itself make an excuse for that: If you spend too much time backing up your argument, you lose the time you’d spend on determining where your argument should take you.

I’d like to close with a quote from Jim Hackett, President and CEO of Steelcase: “Simply put, we make the same mistake that most organizations make when they undertake an ambitious project- having come up with a fine notion, we put all our energy into execution before we had thought the idea through.”

Words to live by.

My parents were huge believers in the roadtrip. Whether this is a cultural phenomenon or not isn’t important: What’s important is that pretty much every summer ever since I was a toddler we’d drive somewhere for a substantial amount of time. Greece, Denmark, Yugoslavia, Italy, Spain, Switzerland, you name it. This tradition continued on well after we’d moved to the United States, including pretty much anything within easy driving distance of Texas.

Now, when you’re a parent, you try to encourage your childrens’ curiosity to see which way their enthusiasm will take them- it’s not a matter of molding them into a particular set of standards (aka Teaching Them Good And Wholesome Values (TM)), it’s more about letting them find their own path, and most of the time… well, it’s a bit of a crapshoot, and you never know whether this new pursuit of theirs is going to be a flighty fancy or a serious pursuit. In addition to that my own ADD tendencies could not have made that much easier. Fixating on a particular task was easy for me, but finding something I’d be willing to fixate on for more than a week or so wasn’t about to happen. Name it, I’ve probably explored it, and my mom and dad’s support in every flighty fancy is… well, I can’t really thank them enough for it.

The additional difficulties with this kind of kid (that being myself) is that sometimes the really significant hobbies and pursuits are difficult to pick out from the noise. There are simply too many hobbies, unfinished projects and pursuits to figure out which one really took hold, and it’s not until I myself have gained the ability to retrospect properly that I myself can pick them out.

The actual point of all that commentary? I like kites.

One of the first trips we took after moving to Texas was to Corpus Christi, where my parents bought me a cheap little stunt kite. It was… an experience hard to describe. See, we kept it in storage (or rather, pinned to the ceiling in my room) for most of the year, and only when the opportunity arose did it get pulled out of retirement. In particular, there was one beach trip to Port Arthur where I spent so much time flying the kite that my back ended up with second degree burns.

I flew this kite ragged. The trailing edge started to fray, I had to duct-tape the cross brace, and the line had to be mended multiple times, but even so it was probably the best $40 they ever spent for me. I took it to college with me, but there wasn’t much opportunity in Pittsburgh to fly it. Soon enough it got lost in a move somewhere, and I haven’t really thought of it much since, until I went on vacation last year.

The event I’m currently at happens every year, essentially in the same place, and one of the featured stores in the area is Kitty Hawk Kites, a store that… well, sells kites. Last year I walked out of that place with a .7 m^2 stackable stunt delta that was my best friend for the next week (I did wear sunscreen this time though). Nimble, maneuverable, quick on the turn and beautifully responsive: hmmmmhhhh yeah.

So what did I forget to pack this year? Exactly. After a few short minutes of bellyaching over this gross insult to her I acquired a new one, a 2.5m^2 foil (Mom, Dad? Guess where the birthday check went. Thanks! ). In comparison to my delta it’s like switching from a scooter to a harley: It ceases to be an exercise of pure finesse and becomes a study of power, cantilevering and balance control. This kite requires quite a bit of physical cantilevering to prevent it from pulling me off my feet, and during my first practice flight I faceplanted in the sand a few times because I underestimated its power.

What’s even worse? This new kite has stacking mounts.

My new kite.

What happened? Well, I put out a post that was poorly worded. Someone (at work) took exception. I was told about this, took a long hard look at what I said, realized it could very easily be taken in the wrong way (and was), and so posted a retraction, explaining why. And now I’ve been told several times that the retraction looks like I’ve sold out, and that I’m subversively blaming my company for censoring me. That it looks like someone came down on me with a hammer, and/or that the entire exchange sounded insincere.

None of these are true. No hammers, no coercions, no subversion, no lack of sincerity on my part either. Simply one person’s (well, ok-several persons’) hurt feelings and my attempt to make amends. And apparently, I failed so completely that I looked like a vindictive little prat.

So now I don’t just have the original offense to apologize for, I also have to backpedal on the retraction. And short of pulling the original two posts (which I did) I can’t figure out how.