The Strategic Importance of the Offensive Line

Posted in: Blog, Development, Startups, Technology on August 29, 2010 | 1 Comment

The small running back leading the large offensive line onto the field

My 10 year old son has begun playing tackle football this year, and I honestly can’t tell which of us is more excited about this fact.  We now find ourselves spending a fair amount of time talking football strategy.  He plays running back and is easily the smallest kid on the team.  As a small, nimble, ball-carrying back, my son has quickly developed an appreciation for the strategic importance of his offensive line.  Without them blocking for him, he would quickly be overwhelmed by the 11 defenders eager to tackle the kid with the ball.

I often compare the football offensive line to a startup company’s tech operations; the guys who keep our servers and systems up and running.  As a startup that prides itself in being small, nimble and quick – with weekly sprints and product releases – the analogy to 5^th grade tackle football feels somehow appropriate.

As an offensive lineman your primary job is to protect the guy with the ball.  If you play a perfect game, the credit you’ll get is that nobody will ever call your name.  If you screw up just once, a defender will sack your quarterback or tackle your running back for a loss and you’ll look like a buffoon and likely kill the drive your entire team is working on.  Same goes for the operations of a small tech startup; being perfect 90% of the time means that 10% of the time you are down which will almost guarantee the failure of the entire organization – no matter how good you are in every other position.  In other words, 90% perfection isn’t even close to being good enough as an offensive lineman or a sysadmin.

Startups are a team sport where the true “skill” positions are most often behind the scenes, technical and usually very underappreciated.  In honor of football season kicking off across the U.S., I want to point out how important the tech ops folks are and say a great big thank you to every one of them.

–Keith

Beginning UI Design

Posted in: Blog, Development, Technology, UI on December 17, 2009 | 2 Comments

And now another word from the developer side of the house:

With many years of experience in the Microsoft static development world with all their fancy programs and business models I have found it quite difficult to make the initial pivot into the dynamic world of Python and Javascript. That being said, it has been quite exciting to not have everything handed to you on a silver platter. This post describes the initial design and structure of the code behind a flexible UI.

Javascript

In the Javascript world, one of the big points I keep hearing is that Javascript needs to be written from the prototypical mindset. As I have learned in past experiences, it almost always less of a headache to not fight the design of the paradigm but instead learn it’s intricacies and use it to your advantage. Hence, I have slowly learned how to incorporate duck typing to accommodate a style of coding that enables other developers to plug-in to the same objects being passed around and extend the current system.

With this belief in mind, I have come to a point where I believe the best course of action is to use a classic OOP design. The hardest part of implementing inheritance is that I constantly wonder if there is a way to be just as efficient in the dynamic/prototype paradigm. For most developers this is quite hard to put aside due to curiosity and performance improvements but my first lesson of operating in a startup, has been to focus on glaring, rather than possible problems. A difficult task but there are more interesting problems to solve at this point.

Events and State

One of my favorite parts of Javascript and Python is the ability to pass functions around as variables. Growing up in the Microsoft world, this was quite difficult to do with type restrictions on delegates. It was still possible but not nearly as easy. (It will be much easier with their upcoming dynamic keyword.) Seeing as how we need a way to link the state of a control to a particular action which occurs on the page (not necessarily attached to the state of the dom), I needed a way to call multiple functions when one action occurred. Basically, I needed Javascript to support event-driven design.

At this point all the event manager does is use an associative array to store function signatures in an array and then sequentially call those functions when the event is raised.


var onrender1 = function() { alert('Render receiver 1'); }
var onrender2 = function() { alert('Render receiver 2'); }
var manager = {
events: {},
    trigger: function(event) {
        for(e in this.events[event]) { this.events[event][e](); }
    }
}
manager.events.rendered = [onrender1];
manager.events.rendered.push(onrender2);
manager.trigger('rendered');
// Render receiver 1
// Render receiver 2
 
Download [zip]


Finally, the manager could be designed as a class to enable instances and attached to objects, allowing objects to enable events using duck typing if necessary.

This is only a basic implementation but works for are requirements quite well. It might be better to implement in the prototype model at a later time…but that’s for another time.

The entire purpose of enabling events is to call functions as soon as something happens This is extremely important when there are multiple controls/components whose visual state depends on a particular action (user initiated or not). A model similar to this is the UI state manager in Silverlight which handles events as well as supports dynamic transitions.

Personally, this is an exciting and interesting beginning to the UI development cycle.

- Collin

Cloud Magic and a Talking Monkey

Posted in: Blog, Technology on October 26, 2009 | No Comments

Security guards disallowed us from entering our data center because of an invoice dispute, which resulted in a geek-strewn, network-cable-tied, flying-hard-drive embroiled bloodbath. I only survived because I happened to have my trusty flask of high-potency 151 rum with me, which I used to cauterize my wounds and calm my nerves.
Read more…