There are, in essence, three different ways to consume media on the internet. This is regardless of what kind it is- a solution that would work for sound will also work for video and vice-versa. While technical implementation may limit the formats you can broadcast, those choices are usually made well after the project requirements have been set.

Progressive Download

The first is Progressive Download. This is the easiest and the one you’re most likely to encounter in your day to day life, and will also be the cheapest for you to implement. In essence, you copy a video file and a player out onto a normal web server, and when a user loads the page with the player, that player will start to download the video and begin playing it as soon as it has enough to ensure a continuous stream.

The advantages are many. First, it’s easy to do- dozens of prepackaged players exist, and encoders are pretty easy to find as well. In some cases, you don’t even need a player- quicktime will play directly in your browser as long as you have the plugin. The downside is that your video is available for anyone and everyone to download and, presumably, rebroadcast on their own servers.

If you’re working on a viral campaign this is actually an advantage, but in most cases it’s probably not- who knows how some enterprising individual will mashup your video, right?

Server Based Streaming

The second method is server-based streaming. Rather than using a single web server, you’re now using two: A web server for your player, and a streaming server for your media. The user experience is practically identical- all changes happen under the hood as the user is only receiving the part of the media they’re currently watching. Once a particular second has been consumed, it’s discarded.

The advantages of this method are several: First, it’s a lot easier to detect how fast your client’s connection is, so you can provide them a smaller file that will still give them a good user experience. Secondly it is more secure- your user can’t really save the media without a third-party program, and those fail if you encrypt your stream. Thirdly, you can publish live media streams with this method- concerts, conventions, presentations and the like are now all accessible in real time.

Unfortunately this method isn’t exactly cheap… if done in house. It usually means a new server, server software that will cost thousands, and a developer who knows how to set up and maintain your server. To keep costs low you can contract with a media hosting company that already has the hardware and software set up. The free ones include Vimeo and Youtube, though they limit you to certain players and encryption is usually not available.

Peer to Peer Streaming

This method is (surprise surprise) very popular in the adult industry, but is also used for more common applications like Skype. The role of the server is cut out almost completely in this, as we instead broadcast media directly from one user to another.

The nice thing about this is that you can have a high-quality person-to-person interaction without paying an arm and a leg for bandwidth.

The disadvantages are largely experience related, since one of your users must act as the media publisher via a camera, microphone, or pre-downloaded file. That user will then be limited to how many people they can broadcast to simultaneously by how fast their internet connection is.

Strategies for Selection

Given the above, choosing a media streaming approach is relatively easy. The default is progressive download- if you don’t have a lot of media and don’t need anything encrypted or fancy, just go with that. If that’s not enough for you, decide whether you need a live feed: If not, use a streaming server.

After this things get a little trickier, because live media may be broadcast in many forms. The rule of thumb I use is as follows: If the number of consumers of a single media stream exceed the number of streams that can be provided at the highest bitrate given the internet connection, use a streaming server.

Some examples:

• The Democratic National Convention
  Single source of video, many users: Server Based Streaming
• YouTube
  Many sources of video, many users: Progressive download or Server Based Streaming (I recommend the latter based on scale).
• Pandora
  Many individual audio files, must be secured from copying: Streaming server
• Amazon.com Album Previews
  Many individual audio clips: Progressive download
• Customer service training video (internal)
  Lives on internal network, not live, single video: Progressive download.
• Internet Phone
  Thousands of sources, thousands of consumers: Peer to Peer.

I hope this guide was helpful. If you have any additional questions, don’t hesitate to put them in the comments.

The real challenge, however, is “Getting Something Out There” that you can build on. I don’t mean setting up a blog or a couple of static pages, I mean putting in place a scaffolding that you don’t have to replace in its entirety as your business concept matures. The optimal solution then seems to be to use an established software package that can be extended to suit your needs.

Easier said than done. Every CMS out there claims to be extendable, yet not all are created equal. Furthermore extensibility usually requires that you build within their own framework, which then locks you into a third party whom you don’t have control over.

This can be overcome by developing your business services independently, and create a loose integration between your application and your CMS. By doing this you’re suddenly free to proceed with your own plans without the added worry of being locked into a platform.

So why did I choose Wordpress and Zend? Well, Wordpress has an easily understood plugin structure as well as an active developer community, plus its plugins allow you to do pretty much anything your heart desires. Zend was chosen because it’s a professionally supported application framework with quite a few corporate backers, and it’s written in the same language as Wordpress- PHP (Plus, it’s what I know- Added Bonus).

The rest of this post is going to get technical, so I hope those of you who aren’t as geeky as I don’t mind. In essence I describe how to accomplish a loose Wordpress-to-Zend integration with all the benefits I described above.

Step 0: Assumptions

Before I begin, there are some assumptions I’m going to make.

1. You know how a Zend MVC application is structured.
2. Your Zend code base will be hosted on the same server as your Wordpress install.
3. You are running application stacks on the same primary domain. (blog.fancybrandname.com and www.fancybrandname.com works)
4. Your Zend application will handle user authentication records. This is because you don’t necessarily want to be restricted to Wordpress’ table structure.
5. Your application uses the MVC Templating System that comes with Zend.
6. The Wordpress integration code will live in the plugins directory on the Wordpress side and (with one notable exception) in the ~library/ directory on the Zend side.

Most importantly, please understand that this implementation is NOT for the faint of heart, and requires additional code on your part. I cannot easily make any assumptions about how user authentication is handled within your Zend application, nor what models or methods you have built to simplify object retrieval.

Step 1, Database: Create a linking table

The first fundamental requirement is that we need some way of linking the Wordpress user table (usually named wp_users) to the user table in the zend application. Usually this is done via a linking table, that might look something like this:

CREATE TABLE `user_id_link_table` (
  `id_zend` bigint(20) unsigned NOT NULL,
  `id_wordpress` bigint(20) unsigned NOT NULL,
  KEY `id_zend ` (`id_zend `),
  KEY `id_wordpress ` (`id_wordpress `)
);

Step 2, Zend and Wordpress: Configure the Cookie Domain

To make sure your authentication cookies are available across your two domains, you’ll need to make sure both Wordpress and Zend are looking for the same cookie. The way to do this is to set a wildcard Cookie domain so it transfers from one domain to another. If you look through the various configuration files and session initialization methods, you might see entries like “www.yourdomain.com” or “blog.yourdomain.com” near a reference to a cookie domain. To make sure they transfer, replace all instances with “.yourdomain.com” (the period at the beginning is important). That should ensure that your cookies are portable.

Step 3, Zend: Setting up an integration controller

The first thing we need to do is make sure that your Zend Application is fully loaded. Since you might want to use view helpers in your page templates, this means that we actually have to set up a ‘dummy’ controller that is used for integration purposes only, but which doesn’t try to output anything. This is easily done:

<?php
/**
 * The Integration Controller.
 */
class IntegrationController extends Zend_Controller_Action
{
    /**
     * Index action. Sets up the entire framework but disables output.
     */
    public function indexAction()
    {
        $this->_helper->viewRenderer->setNoRender();
    }
}

Step 4, Zend: Extending the AutoLoader

The fourth step is that we need to extend the Zend AutoLoader, because otherwise it will get confused when Wordpress tries to load its plugins. Since we don’t really know which plugins will be loaded ( and thus we can’t explicitly include them in our $PATH ), we’re simply going to restrict the Zend Autoloader to restrict its activities to certain namespaces.

This file is called ~library/Wordpress/Loader.php

<?php
require_once('Zend/Loader.php');

/**
 * The Wordpress loader class is a quick filter that ensures only specific application
 * libraries are passed through to load handling.
 */
class Wordpress_Loader extends Zend_Loader
{
    /**
     * Override of the loadClass method.
     *
     * @param string $class
     * @param string|array $dirs
     */
    public static function loadClass($class, $dirs = null)
    {
        $parts = split("_", $class );

        switch ( $parts[0] )
        {
            case 'Zend':
            case 'Wordpress':
            case 'YourNamespace':
                parent::loadClass($class, $dirs);
        }
    }

    /**
     * This handler has to be here for Zend_Loader invocation purposes
     *
     * @param class $class
     * @return string|boolean
     */
    public static function autoload($class)
    {
        try {
            self::loadClass($class);
            return $class;
        } catch (Exception $e) {
            return false;
        }
    }
}
?>

Once we’ve extended our AutoLoader, we now have to properly invoke it in our Zend Bootstrapper.

NOTE: You may have to adjust the following code somewhat so it fits in with your application. My own application has a Bootstrap Class within which this is a private method.

/**
 * Application Bootstrapper.
 */
class Bootstrap
{
    private function setAutoLoad()
    {
        require_once ( 'Zend/Loader.php' );
        // Notice that I'm still calling Zend_Loader, but I'm passing the new Classname.
        Zend_Loader::registerAutoload('Wordpress_Loader');
    }
} 

Step 5, Zend: Creating a Session Model

This fifth step is necessary if you’re going to delegate all authentication tasks to the Zend application rather than to Wordpress itself. By treating our user sessions like a CRUD-based application, we can abstract it entirely into a Model rather than keeping the code within a Controller. By doing this we can invoke the method from anywhere, including a Wordpress plugin.

NOTE: I’m putting this session class into the Wordpress namespace, while it really should go into a namespace appropriate to your application.

<?php
/**
 * The session model wraps basic session creation and destruction methods
 * into one single interface. 
 */
class Wordpress_Model_Session extends Wordpress_Model_Abstract
{
    /**
     * Creates a new session (aka logs in a user)
     *
     * @param string $user
     * @param string $password
     * @return 
     */
    public function create ( $user, $password )
    {   
        // Get our authentication adapter and check credentials
        $adapter    =   $this->_getAuthAdapter( $user, $password );
        $auth       =   Zend_Auth::getInstance();
        $result     =   $auth->authenticate($adapter);

        if ( !$result->isValid() )
        {
            return false;
        }
        else
        {
            // We're authenticated! Add your own logic here.


            return true;
        }
    }

    /**
     * Destroys a session (aka logs out a user)
     */
    public function destroy ( )
    {
        Zend_Session::forgetMe();
        Zend_Auth::getInstance()->clearIdentity();
    }

    /**
     * Constructs an instance of the auth adapter for this model.
     *
     * @return Zend_Auth_Adapter_DbTable
     */
    protected function _getAuthAdapter( $login, $password )
    {
        // Put your authentication plugin loader code here.

        return $adapter;
    }
}

Step 4, Zend: Add an integration method to your Zend Bootstrapper

The last thing we need to do is create a method in our bootstrapper that lets us load the entire application without Zend trying to parse the URL into which it was loaded. To do this, we create our own HTTP Request instance with a URL that invokes the Controller and Action we created in step 3, thus effectively ‘fooling’ the FrontController into thinking it was invoked from somewhere else.

/**
 * Application Bootstrapper.
 */
class Bootstrap
{
    /**
     * Executes the application in a bootstrapped integration state.
     */
    public function integrate()
    {
        // Construct a 'Dummy' Url to use for our Request.
        $uri = sprintf ( 'http://%s/integration/index',$_SERVER['HTTP_HOST'] );
        // Create a new request object
        $request = new Zend_Controller_Request_Http( $uri );
        // Dispatch our FrontController
        $this->_frontController->dispatch( $request );
    }
}

At this point, we’re done with all the work we need to do on the Zend side of things. On to the Wordpress Plugin!

Step 6, Wordpress: Create a plugin

The sixth step is to make sure that your entire Zend Application is available to Wordpress. This is a security risk- the instant someone discovers a vulnerability in Wordpress they’ve got access to everything, so make sure you have a competent PHP developer who knows how to secure an application.

<?php
/*
Plugin Name: Zend Integration Plugin
Version: 1.0.0
Description: Allows WordPress to authenticate users against the a Zend Session Model
Author: Michael Krotscheck
Author URI: http://www.krotscheck.net/
*/

class ZendIntegrationPlugin
{
    /**
     * Constructor. Initializes this class.
     */
    function __construct()
    {

    }
}

// Load the plugin hooks, etc.
$zend_integration_plugin = new ZendIntegrationPlugin();

Step 7, Wordpress: Load the Zend Framework

The next step is to load your Zend application. By creating a method that explicitly loads our Bootstrapper and then invoking the integration method we created in Step 3 above, we load all necessary classes and dependencies without them interfering with Wordpress.

class ZendIntegrationPlugin
{
    function __construct()
    {
        // .... previous code ....
        $this->Wordpress_framework_init();
    }

    /**
     * Initialize the Zend framework for inclusion.
     */
    public function Wordpress_framework_init()
    {
        // Import the Zend Bootstrapper. This path needs to be absolute.
        require_once ( '@APPLICATIONROOT@/bootstrap.php' );

        // Create a new Bootstrapper instance and invoke the integration method.
        $bootstrap = new Bootstrap ( );
        $bootstrap->integrate();
    }
}

Step 8, Wordpress: Disable Unnecessary Functions

Since we’re delegating all session authentication tasks to your Zend application, we need to explicitly disable many of Wordpress’ default functionality related to password and account management. We do this by using the application hooks created explicitly for that purpose.

<?php

class ZendIntegrationPlugin
{
    function __construct()
    {
        // ... previous code ...

        // Disable Lost Password, Retrieve Password, and Password Reset
        add_action('lost_password', array(&$this, 'disable_function'));
        add_action('retrieve_password', array(&$this, 'disable_function'));
        add_action('password_reset', array(&$this, 'disable_function'));

        // Remove Password Fields from the wordpress user profile.
        add_filter('show_password_fields', array(&$this, 'disable_password_fields'));
    }

    /**
     * Used to disable certain display elements, e.g. password
     * fields on profile screen.
     */ 
    function disable_password_fields($show_password_fields)
    {
        return false;
    }

    /*
     * Used to disable certain login functions, e.g. retrieving a
     * user's password.
     */
    function disable_function()
    {
        die('Disabled');
    }
}

Step 9, Wordpress: Autoload the session

This is perhaps the most complex piece of the plugin, because we have to do three things: First, we have to detect whether the authentication states between your Zend application and Wordpress match. If they don’t, we have to either create a wordpress session or destroy it. The tricky bit here is that Wordpress requires use of its own user database, so we have to retrieve basic information from the Zend User tables and construct a Wordpress user should it not already exit.

Unfortunately, I cannot say how your Zend application is built nor what models exist that would allow you to retrieve a user record. As such I’ve inserted pseudocode in the method below that describes what needs to happen rather than make guesses about your implementation.

<?php

class WordpressAuthenticationPlugin
{
    function __construct()
    {
        // ... previous code ...

        add_filter('plugins_loaded', array(&$this, 'auto_login'));
    }

    /**
     * This method runs after the plugins is loaded, and attempts to detect
     * an out-of-sync session.
     */
    public function auto_login()
    {
        $isZendAuthenticated = Zend_Auth::getInstance()->hasIdentity();
        $isWordpressAuthenticated = is_user_logged_in();

        // Check to see if we're logged out of Zend but still logged in to Wordpress
        if ( !$isZendAuthenticated && $isWordpressAuthenticated )
        {
            // Log out of Wordpress.
            wp_logout();
            wp_clearcookie();
            set_current_user(null);
        }

        // Check to see if we're logged in to Zend but not Wordpress
        if ( $isZendAuthenticated && !$isWordpressAuthenticated )
        {
            // Retrieve the user record from Zend
            $yourUserObject = yourUserRetrievalMethod();
            $wordpress_user_id = yourWordpressIdRetrievalMethod($user);

            // Check for the wordpress user ID, create a new user if necessary.
            if ( $wordpress_user_id == NULL )
            {
                // Retrieve the user creation scripts.
                require_once(ABSPATH . WPINC . DIRECTORY_SEPARATOR . 'registration.php');

                // Create a user object, using the hashed password value (It matter doesn't what you use as long as it's unique)
                wp_create_user($yourUserObject->login, $yourUserObject->password, $yourUserObject->email);

                // Check for a successful insert
                $wordpress_user_id = username_exists($login);
                if ( !$user_id )
                {
                    die("Error creating user!");
                }
                else
                {
                    yourWordpressIdUpdateMethod($user, $user_id);
                }
            }

            // Now that we know we have an existing wordpress user record that matches our Zend Table,
            // try to create a wordpress session
            $wpUser = new WP_User($wordpress_user_id, $yourUserObject->login);
            $wpPassword = md5($yourUserObject->password);
            wp_login($yourUserObject->login, $wpPassword, true);
            wp_setcookie($yourUserObject->login, $wpPassword, true);
            wp_set_current_user($wpUser->ID, $yourUserObject->login);
            return;
        }
    }
}

Step 10, Wordpress: Enable Login via Wordpress

At this point we are maintaining the authenticated session across our applications, but we don’t yet have Wordpress authenticating users against our Zend user table. As above, I can’t make assumptions about how your authentication is set up, but I can show you which application hooks to set up, leaving the rest of the logic for you to fill in.

<?php

class WordpressAuthenticationPlugin
{
    function __construct()
    {
        // ... previous code ...

        add_filter('check_password', array(&$this, 'check_password'), 10, 4);
    }

    /**
     * Override Check Password
     */
    public function check_password($check, $password, $hash, $user_id)
    {
        // Retrieve a user by the Wordpress User ID. You can use any class in your Zend application.
        $user = findZendUserByWordpressId ( $user_id );

        // Check for a valid return data.
        if ( $user )
        {
            // Try to log in.
            $sessionModel = new Wordpress_Model_Session();
            return $sessionModel->create( $user->login, $password );
        }

        return false;
    }
}

Step 11, Wordpress: Enable Logout via Wordpress

The very last vanity task to perform is to enable logging out via the Wordpress buttons. Again we use an action handler, and in this case we explicitly call the Session destroy method we created in Step 5.

<?php

class WordpressAuthenticationPlugin
{
    function __construct()
    {
        // ... previous code ...

        add_action('wp_logout', array(&$this, 'logout'));
    }

    /**
     * Runs Logout routines against the Zend controller.
     */
    public function logout ()
    {
        $sessionModel = new Wordpress_Model_Session();
        $sessionModel->destroy();
    }
}

And that’s it. With all these pieces in place your Zend application should now be integrated with your Wordpress intall. Congratulations! Now your startup has a fully functional, plugin ready CMS without being tied to a commercial solution for the long term.

To begin with, this session starts where the 5 minute install stops. There are plenty of tutorials out there that will help you set up your own WordPress blog, so I’m not going to bother repeating them. Instead I’m going to start covering topics that you’ll run into when you want to have your WordPress install do more than what it was originally designed to do.

Since the topics covered are very technical in nature, I will also take the time to demystify some of them. In other words, if you’re already a developer in your own right you might not get much out of this presentation, as I will be covering some basic PHP syntax, server redirects as well as an overview of modifying DNS records.

On the other hand, if you are a blogger who’d like to have a good introduction, or are curious about how WordPress might fit into your corporate environment, this will be an excellent overview.

Section 1: One Install, Many Blogs

11:00AM-11:20AM

If you’re an avid blogger and/or maintain more than one WordPress blog, consolidating all of your blogs onto one single WordPress install can help with everything from plugin management to upgrades. Most plugins, however, naturally assume that they exist on a solitary install, so if you want to use something like Google XML Sitemaps there are some additional steps you need to take. As such, this first part will cover the following topics:

1. Writing a Dynamic Configuration File (PHP)
2. Request Redirects with mod_rewrite
3. Configuring plugins for multi-site use

Section 2: WordPress^μ

11:20AM-11:40AM

In many corporate environments it’s often optimal to manage multiple blogs through one single administrative interface, which is where Wordpress^μ (Multi-User) comes into play. Installs such as these are often tricky, because they require a bit more technical expertise to get them set up properly. As such, I will be covering the following:

1. A brief feature overview of WordPress^μ
2. Installing WordPress^μ.
3. Redirecting for subfolders (http://www.yourdomain.com/blogname).
4. Redirecting for subdomains (http://blogname.yourdomain.com/ ).
5. Updating CNAME DNS records for subdomains.

If we have time at the end of the session I will open the floor for any additional questions you might have about installation challenges you might have faced. I can’t promise a comprehensive answer to all of them, but between myself and the rest of the room we should be able to get you pointed in the right direction.

Everyone on that list gets followed. Everyone else gets dropped.

Yes, there are caveats. If I’ve never met you before in my life there’s a good chance I’m not going to follow you anyway, for reasons you’ll see below. Also if we’ve had more than a cursory set of @changes, have emailed each other regularly or (even better) have hung out in person you’re automatically on the list.

The true power of human communication is interaction, discussion and argument. It is not doe eyed consumption of what the latest celebrity has said, nor is it short-burst updates in the hope of being profound. It’s not link propagation, marketing, spin, advertising, or a long list of messages that boil down to “OMG I’m # away from ### Followers, Pay Attention to MEE!”. Human communication and true discussion requires time, effort, and thought, and cannot be acquired via txt messages or 140 character snippets. Think paragraphs. Think books. Think libraries.

Yes, it requires effort. It requires we meet, or have an email exchange, or talk on the phone, or have some kind of meaningful exchange other than “@krotscheck omg that picture is so cute”. Once that social vibe and comfort is established then yes, casual methods of communication (like twitter) are great ways to maintain it over distance, but you can’t do that just because you listened to their presentation at some conference.

If you want me to follow you, you have to convince me to care, and no small “follow” button or automated bot is going to do that. If you want me to treat you like a human being, to really listen to what you have to say, then you really should reciprocate.

Hypocrite? Not really. Listen, I give people day-to-day updates because I assume that they’re interested in what’s going on in my life. I use twitter for banter, not for a meaningful conversation or professional exchanges. Banter, by its very nature, assumes a level of familiarity you can’t just get from a website, and if I don’t feel comfortable bantering with you then yes, you’re not going to get followed.

Yet having said that, a few weeks of scraping the far corners of the web for information on what the next big thing might be has left me with one overarching impression: Wow, my skill set is way out of date.

Of course, that’s to be expected. There are many different levels of being at the forefront of technology: There’s the leading edge, where you’re using the news most broadly supported technologies. There’s the cutting edge, where you’re working on bringing a new idea to a larger audience. And then there’s the bleeding edge, where you’re wantonly investigating every last thing that sounds like it might have impact, but you really cannot tell whether it’ll sink or swim (hence the term ‘bleeding’). As such, trying to remain on the bleeding edge is a dangerous and ultimately frustrating endeavor, because by the time you’ve built up the skills to properly explore an idea either your goal is outdated, your skills are outdated, or both.

As such, it is very rare to see an Agency truly on the Bleeding Edge. Between often unrealistic delivery restrictions and the need to keep everyone billable, it’s rare to see pure technological exploration. In most cases it’s easier and faster to use established tools and technologies because they are known and thus allow us to estimate a project to within a reasonable margin of error. This, by virtue of my definitions above, places agencies as no farther ahead than the leading edge, because by that time the tool makers have come through and made things as easy to generate as possible.

Seems legitimate, yes? Certainly. And yet through my own recent exposure to the technological trends and implementations, I can’t help but conclude that the next iteration of “Really Cool Marketing Apps” are going to be well beyond the technical skill set normal agencies have access to. Let’s take a look at some examples, shall we?

1. Amazon’s iPhone application uses sophisticated Image Recognition to detect what product you’re looking at. These methods and algorithms are by no means easy, and usually require someone who is extremely well versed in computer vision (A skill rarely found outside of academic environments). Who, at your agency, can do that?
   
2. QR Codes are prevalent in asia and are starting to make a dent in the US market for cell-phone based scanning. The QR Code standard uses Reed-Solomon error correction, which involves incredibly sophisticated algorithms that can support polynomial Galois theory. Do you have any experts in Computational Algebra at your agency? I thought not.
   
3. Augmented Reality involves the manipulation of 3D spacial geometries that requires more matrix algebra and vector calculus than most developers are ever exposed to. While authoring tools are certainly making headway in simplifying that (Adobe’s “Postcards In Space” support in Flash Player is one of them), there will always be a disconnect between what’s embedded into tools and what isn’t.

While we’ll definitely see smaller specialty shops rise up to address complex demand like this, it will still mean a sharp rise in demand for talent that’s traditionally only found in academic environments. In short, if you’re the Technical Director in an agency, and your talent pool is full of Software Developers rather than Software Engineers, you should probably start partnering with your local University to make sure you can source them at a moment’s notice.

More practically speaking, it also means agency costs are going to rise, and that many smaller agencies will be left in the wake because they can neither convince their clients that they have the talent nor can they retain it if they do hire it. This really isn’t news- there are plenty of Brochureware agencies out there that got into the web market and have been floundering since. The big players can afford to take a dive on a project just for the portfolio piece, and will thus gain poaching and award rights.

And yet, there is a ridiculous business opportunity here: If you’re the first agency who can pull off an AR or mobile piece convincingly, and are willing to monetize the expertise (via consulting or whatever), suddenly you’ve got the industry cred of being on the cutting edge. In essence you become the tool creator, with all the benefits and recognition that comes with it.

Yet… how big is it really? Let’s really narrow down our numbers and show you the ridiculous amount of talking that’s going on here. According to the bureau of labor statistics, there were 857000 software developers employed in the US in 2006. While that’s a measly 0.28% of the total american population, it makes a little more sense in context of an area where a conversation can legitimately take place. For argument’s sake, Columbus Ohio’s metropolitan area has a population of 747,755, which means that there are likely around 2147 software developers in the area.

Now let us assume that software developers only talk with one another, and that the Conversation is limited to them. Using myself as an example I talk with at least three other developers every day, about various topics which amounts to an average of 10 conversations or so. Assuming that other developers are like myself it means there are 21,470 conversations happening every day, in Columbus, Ohio, in one small segment of the workforce. Extend that to the entire population and increasing the conversation number to about 20 (We don’t just talk to our direct colleagues, do we?), we’re looking at ~8.5 million conversations amongst software developers, ~14 million conversations in Columbus Ohio, ~17 million conversations that software developers have with their peers, and a grand total of 3 trillion conversations happening in the entire American population, every day, for a grand total of one quadrillion every year. And that’s only an eyeball estimate of actual in-person conversation communication. Who knows what that number is once you include journalism, microblogs, instant messaging…

My, we’re a chatty bunch, ain’t we.

The downside of this, of course, is that being part of “The Conversation” means precisely squat. No matter what that sales guy or social media enthusiast over there tells you, you remain one tiny voice among trillions. Even if you slice and dice the population down to a specialized group that might let you have an impact, that group does not exist in a vacuum and remains influenced by anyone and everyone else that’s out there.

Humbling thought, isn’t it? That’s right, we’re really not as important as we think we are.

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.

Aaron: did I make .NET changes for the last release?

Michael: Yeah, remember you rewrote the backend to do my laundry?

Aaron: oh yeah

Aaron: how’s that working out for you?

Michael: Well, it works… but the licensing fees on the detergent are killing me.

Aaron: Yeah, I didn’t work out that integration well

Michael: I’m afraid I’m going to have to go with an open source solution.

Aaron: Many of our customers are feeling that way.

Michael: I hear a new one just got released. Have you heard of "Clothesline"?

Aaron: yeah, but I heard that the results aren’t as good if your server room has polluted air

Michael: Apparently it’s super configurable though. Some kind of API called "pins"

Aaron: Nice

Aaron: I’ve seen various distributions

Aaron: Pretty flexible

Aaron: You can install it on a wide variety of platforms

Michael: Still, I’ve read blogs that it only does half the job, and you’d really need a good Washboard operator to make it work.

Aaron: Also, the process is efficient, but slow.

Michael: I thought it multithreads?

Aaron: It can sometimes handle a larger load than the commercial product.

Aaron: It’s a trade off though.

Aaron: Speed or larger processing loads.

Michael: Well, you know me. Always overclocking the machine just to get those stains out.

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.

Before I go into it though, I want to talk a little about where Adobe’s been going strategically over the past few months. Chances are, you know of Adobe as a software company with a large portfolio of products targeted squarely at the creative professional (PDF, Flash, Photoshop, etc). Yet if you’ve been paying very close attention recently, you’ve noticed a whole slew of efforts intended to broaden their portfolio into the land of software services. Pacifica, Photoshop Express, Acrobat.com, and Kuler are only a few, and many of them go so far as to completely obliterate the web/desktop barrier itself.

The web has, if anything, become an even noisier place recently as startups and established services compete for your attention. These services and companies are so specialized that they only provide a very focused piece of functionality, and though they are usually good at what they do it’s difficult for individuals to leverage one service against others. In most cases they rely on the community or some enterprising company to bridge the gap between the forest of published API’s. Assuming this actually works, the short term result of this will be a web of services much like a distributed manufacturing network, where core resources (microblogging, address books, email, search) are packaged into products (facebook, gyminee, etc) targeted at specific use cases. In the long term, we’ll likely see horizontal and vertical consolidation, but that won’t happen for a few years yet. For now we are left with a mess of mashups which try to bring something new to the table by carving out a new, interesting use of cross-referenced information.

The catch is that many of these packaged platforms are specific to a demographic rather than to an individual or activity, and so the lesson from the Long Tail has yet to be applied- no platform is flexible enough to allow a user to fully customize their own environment. Let’s propose an example: You are an independent marketer, and in your day to day activity need to create, manage and analyze a variety of internet polls. Initially this seems fairly simple, right? SurveyMonkey lets you do most of this, but can you, from their website, also handle the email blasts that drive traffic to your poll? What about a Twitter announcement? And come to think of it, exactly how detailed can you get with your data, given that cross-referencing with other sources requires complex Excel acrobatics?

What’s missing is the “meta” platform, the application where your services are not preset for you- they’re set by you. To some extent, Facebook tries to do this through its third party API, yet individual applications still cannot coexist, nor can they communicate with each other. A Meta platform would, from a functional standpoint, be much more like an iGoogle, with the notable difference that individual ‘widgets’ are not prevented from talking with each other (integration, after all, being key). It’s the ultimate user-created mashup, where each individual can decide which services or sources are used in tandem.

Enter Adobe Genesis. As mentioned before, the concept is still in very early development, but what I’ve seen demoed took me through my initial skepticism and brought me to a reserved level of excitement. There are still a lot of questions that needs to be answered, but the concept is not only interesting: It’s disruptive, and overdue.

In short: The Genesis team believes that given a blank workspace and a series of catalogues filled with widgets, a user will custom create not only their own application, but in doing so will merge the complex and disrupted cross-site and cross-application workflows into one single, simple screen. In a Digsby-like statement of integration into a common platform, they aim to eliminate the multi-application paradigm in the context of the business user. I know the pictures below (taken from their flickr stream) are poor representatives of an actual demo ( Are you going to MAX? You should ), but if the concept of “Build Your Own Application From Widgets Of Applications You Commonly Use” doesn’t have you excited, go take a look at the presentation from the Office 2.0 Conference (It’s the second video).

Workspace management, allowing a user to add and remove widgets from a given workspace. In this case, announcing a widget that describes user’s 401k benefits.

Example Workspace, including Google News, SalesForce.com and Pipeline Analysis.

My biggest problem with the idea is that it’s being pitched as an Enterprise solution. This means that we’re assuming that large companies out there see enough value in this application that they’ll be willing to commit their own resources towards building an internal collection of widgets (To integrate with their own ERP or Inventory system for instance). As with any kind of software development effort, this will inevitably require usability and use case analysis, and if you’re going to go to that kind of effort the step to building a full-blown application may very well be more cost effective in the long run (I can hear the Microsoft Sales Guy now). I’m not saying that companies won’t put resources towards this, but I feel it’s far more likely that the ERP solution providers (Oracle, etc) will be providing these widgets.

I feel the real case for this platform is in the SMB space. Companies that don’t have their own development houses, that’ll be using the Genesis Desktop to integrate a variety of services provided by common web services they already use. Consider the Social Media Strategist, who would create a desktop with Twitter, Summize, Google Blog Alerts and their RSS reader of choice. How about the Independent marketer, who’d be merging SurveyMonkey, Constant Contact, PointRoll, WebTrends and event-management-package-of-choice? Or, to hit a little closer to home, how about the Software Developer who’d join Cruise/Hudson, Jira, Basecamp, SVN and IRC? The Fitness nut that joins Google Maps, Garmin Connect and a virtual trainer? The use cases are there, largely because they’re self-defining. Anyone’s a use case, if their widgets are available.

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.

A little background: 11 months ago (almost exactly) I decided that it’d be neat to start running a little. My regular cardiovascular sport at that time was inline skating, which I did with gusto… yet unfortunately skates don’t do too well in wet or snowy conditions. So rather than shift over to a weight training program like I usually do during the winter months I decided to “pick up” running. At that point in time the idea that I would one day run a Marathon was still somewhere between WTF and Crazy Talk, but a quick 5K seemed like a good goal to achieve.

What a ride (err… run) it has been! Through injuries, lost faith and motivation, accidental beer binges (long story) and seeming setbacks, I finally made it through to complete my first Marathon today. I had to learn a lot of things about what my body would put up with (less than I thought), had to explore much my body can take (more than I thought), and had to laugh about a lot of things I couldn’t change (which somehow increased the hilarity).

Now let me reiterate what others have told me: This approach to marathon running is not recommended, and you should always consult a medical professional before you do something of this magnitutde. I think I only got away with it because I’d already done a lot of regular cardio and as a result was pretty healthy. That, and I’m colossally stubborn and am a firm believer in Mind over Body.

Having said that, if anyone wants to follow in my footsteps (remember: bad idea), here’s the training plans I used:

1. Couch-to-5K Running Plan
   This plan is unlike others because it doesn’t slowly build up distance, it instead assumes that any human being can walk 30 minutes. It then starts injecting short periods of running into that 30 minutes, and after a few iterations of increasing the duration stitches them all together into one continuous effort… which happens to be 30 minutes of continuous running. If you’re running a 10 minute mile (a respectable pace) this’ll get you your 5K.
   
   
2. Mileage Buildup Plan
   At this point, you can easily run 3 miles on a regular basis, and you’ll quickly realize that extending it by another mile is a lot less effort than you might think (This is why many long-distance runners are fairly blase about anything less than 18). The reason I took on this plan was because I liked running enough to make it a regular thing, but not enough to really start training for a major race. With a 10-mile regular run as the final goal, I figured I’d be set to try something if the mood struck me.
   
   
3. Half Marathon Training Plan
   Peer pressure finally won over and I decided to do a race. This particular plan came up on Google, so I switched to it in the middle of the previous plan because I thought it’d be a neat thing to do. Fact is I was kinda sick of running without a concrete goal or race (the 5K actually had me run two races) so it came at just the right time.
   
   
4. Marathon Training Plan
   Unfortunately, I got injured during the Half training, so I ended up volunteering instead (For details, see the “Stupid Shit I Did” section below). After going through a few weeks of recovery (and let me tell you, endorphin withdrawal really, really sucks), my colleague Hanna mentioned that she was thinking of training for the USAF Marathon, and… well, by this time I’d caught the bug. So off I go to look for a marathon training plan, and wouldn’t you know it: This one actually started one week from the day I started searching.

Things to think about

First of all, remember that you need to be very candid with yourself about both your time availability and your commitment to running. Yes, a Marathon is the most fantastifrabulous goals of all of them (so much that I think we should replace the electoral college with a cross-country relay), but if your actual goal is just getting healthier and working on your endurance and cardiovascular system, a regular running regime will do you just fine.

Secondly, once you get up to the longer distances you will realize that running is painful… at least for the beginner. Mostly this is because you and your body haven’t quite come to terms yet on the equipment, the schedule, the distance or the fact that you’re doing this in the first place, but remember that long-distance-running is an endurance sport, which means enduring exhaustion, pain, injury and all kinds of other nastiness to get to your goal. Alternatively, you can just keep in mind that the first guy who ran one… died. How’s that for a reality check.

But most of all, and this is absolutely critical: Be resilient and proactive about bad stuff that happens- the worst thing you can do is ignore something that’s not going well, because it’ll derail you quickly. There’s no point in being a martyr when a little education and a little trip to the pharmacy will set you straight.

Having said that, most of the other advice I have to give I’m not really qualified for, so go forth and Google. The only things I am perfectly happy sharing with you is the blooper reel, which shall be titled:

Stupid Shit I Did Which You Shouldn’t

1. I bought my first pair of shoes online, without fitting them. As a web geek, it’s really easy to trust the sizes provided to you by a retailer, but nothing… I mean NOTHING will screw your feet up faster than a pair of shoes that’s not right for you. A running shoe has a very different fit from something you’ll wear to the office.
2. I thought I’d be all kinds of awesome and, rather than take rest days, repeat the previous day’s training regimen so that I’d be running every day and thus get fitter, faster. This, combined with the shoe issue and my own naivite, lead to…
3. …the fact that I didn’t realize I was getting shin splints, and thus ignored them, resulting in the injury mentioned above. Splints are actually a fairly common problem with me, and is usually the sign to get a new set of shoes or switch to the other pair, but in this case was just a matter of me having absolutely no clue about all the pitfalls that could befall runners. Verdict? Stress fracture in my left shin, and I was out for the count.
4. I thought it’d be an incredibly bright idea to explore a new running trail for one of my important major long runs (the 18 miler, second to last). Most of my running up until that point was in fairly easy suburban trails, so heading out to a brand new place to explore a new exciting trail… which turned out to be incredibly hilly and a royal pain in the posterior… was maybe not the best thing to do.
5. And lastly, I forgot vaseline for the Marathon itself. No, I’m not finishing that story.

This is where things get a little… uh… odd. See, I forgot to restart my Garmin at an intersection, so I never had a good idea of how far I was going. Instead I was simply listening to my body and how it felt about going that next mile, and before I knew it I’d not only passed the 670/Alum Creek intersection, I’d reached 3 Rivers Park.

My first thought? I didn’t know the Park was so close!

My second? Wait a sec, wasn’t that supposed to be 22 miles?

Urban Americans seem to have a mental barrier that prevents us from really understanding distance. Lets use flying as an example: Traveling from New York to Washington DC is perceptually no different than traveling from New York to Seattle. It might take a bit longer, but at no point do we ever have a full understanding of how fast or how far we’re going- we simply get into a large metal tube with small windows and in an hour or four we’re there.

This holds true for cars as well (though to a slightly lesser extent). Traveling in comfort, the only real difference between a day long roadtrip and a trip to the office is time and what we do at the destination. Distance is no longer an obstacle, and thus it has lost most of its meaning. Add to that such complex applications as Google Earth and Yahoo Maps and the concept of location is starting to blur within the digital space, creating no perceivable difference between here and anywhere.

This goes both ways: While we are no longer intimidated by long distances, short distances have gotten grouped into the mix. Even if the grocery store is only a mile away, we don’t think twice about getting in the car and driving because our sense of distance has become so compartmentalized. It’s almost like we live our lives in specific locations, with intermittent periods spent in travel capsules.

This is why I was so surprised at my biking experience, even though the insight had been knocking in my brain for a while now- Once you pursue traveling sports, your perception of distance rapidly aligns itself to reality, and surprise: The world is a lot smaller and more accessible than you thought. This builds on itself: After running 5 miles, 1 doesn’t seem that impressive anymore. After 20, 10 becomes a refreshing morning. Do that on a Bike and the world is your oyster. 30 miles? 40 miles? Whatever, that’s at best an hour and a half.

Or, in short: The world is small, and right there for the taking! Go out and Explore!

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.