Sridatta

Organizing Marc Andreessen's Thoughts Using Python and NLTK

2014-02-26T00:00:00+00:00

Marc Andreessen is one of my role models and favorite thought leaders in entrepreneurship. Back in simpler times, he used to write a blog of sagely startup advice. But since joining Twitter, Marc now shares his thoughts in small bursts of related tweets, forcing me to read his thoughts in a disjoint, reverse chronological order.

I decided to use Python fix this terribly pressing problem. The idea is to create a script that detects tweets posted in quick succession and batches them together. For amusement, it will also run some rudimentary NLP to generate a “title” for each batch of tweets. In the end, they will be output as a blog-like Markdown file (Marc-down file?)

The Twitter API

First we use twitter module to OAuth authenticate with Twitter. Despite the un-Pythonic method names, this module is quite pleasant to use.

import twitter
import json

api = twitter.Api(access_token_key="REDACTED",
                  access_token_secret="REDACTED",
                  consumer_key='REDACTED', consumer_secret='REDACTED')

The Twitter API doesn’t actually provide a way to retrieve every tweet a user has created. Instead, we have to manually iterate over batches of tweets in reverse chronological order. Even then, the API limits requests to only the 3200 most recent statuses. While not ideal, it should be good enough for a quick demo.

def get_all_user_tweets(user):
    tweets = []
    offset = 0
    max_id = None
    while True:
        this_batch = api.GetUserTimeline(screen_name=user, max_id=max_id, count=200, exclude_replies=True)
        if len(this_batch) == 1:
            break
        tweets += this_batch[offset:]
        offset = 1
        max_id = min([tweet.id for tweet in this_batch])
    return [tweet.AsDict() for tweet in tweets]

tweets = get_all_user_tweets("pmarca")

Batching the tweets

When Marc goes on a Twitter rant, he typically posts several tweets about the same topic, within minutes of each other. After retreiving all his statuses, the next job is therefore to detect batches of tweets posted in quick succession.

import dateutil.parser

def diff_created_at(a, b):
    return abs(dateutil.parser.parse(a["created_at"]) - dateutil.parser.parse(b["created_at"])).total_seconds()

def batch_tweets(tweets, rapidness):
    batches = []
    curr_batch = []
    for tweet in tweets:
        if len(curr_batch) == 0 or diff_created_at(curr_batch[-1], tweet) < rapidness:
            curr_batch.append(tweet)
        else:
            batches.append(curr_batch)
            curr_batch = []
    batches.append(curr_batch)
    return batches

The batch_tweets function above takes a rapidness parameter, which is the maximum time between tweets to them be considered part of the same batch. There is no science to setting this parameter. Through random observation, I found that Marc usually posts related tweets within 4 minutes of each other. So we will use 240 seconds as the value of this parameter.

Finally, we want to toss out batches of only 1 tweet long because we are only interested in Marc’s “longform” Twitter content.

batches = batch_tweets(tweets, 240)
rants = [batch for batch in batches if len(batch) > 1]

Generating titles using NLTK

What good are these pseudo blog posts without pseudo titles? Let’s generate some titles for each batch of tweets using using NLTK. I experimented with various methods of title generation, from bigram collocation to simply outputting the most frequent words. They were all pretty crappy.

The best results came from finding noun phrases in the batches of tweets. While not perfect, many topics that Marc tweets about are noun phrases, such as “Entrepreneurial mindset” and “insatiable demand.” Below are some methods to generate a parse tree out of a sequence of tokens and retrieve the noun phrases.

import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize

grammar = "NP: {<DT>?<JJ>*<NN>}"
chunker = nltk.RegexpParser(grammar)
stopwords = stopwords.words('english')

def leaves(tree):
    """Finds NP (nounphrase) leaf nodes of a chunk tree."""
    return [subtree.leaves() for subtree in tree.subtrees(filter = lambda t: t.node=='NP')]

def extract_terms(tokens):
    postoks = nltk.tag.pos_tag(tokens)
    tree = chunker.parse(postoks)
    terms = leaves(tree)
    return terms

Outputting the “Marc”down

Finally we put this all together by iterating over the “rants,” generating pseudo-titles and writing them to a file. If an interesting title couldn’t be found, it simply outputs “Idea #XYZ”.

import itertools

with open("rants.md", "w") as f:
    rant_count = 1
    f.write("# The Tweets of Marc Andreessen \n")
    for rant in rants:
        tokens =  list(itertools.chain(*[word_tokenize(t["text"]) for t in rant]))
        filtered_tokens = [t for t in tokens if t.lower() not in stopwords]
        nps = [p for p in extract_terms(filtered_tokens) if len(p) > 1]

        if len(nps) != 0:
            title = ' '.join([tok for tok, _ in nps[0]]).encode("utf8")
            f.write("## On %s\n" % title)
        else:
            f.write("## Idea %d\n" % rant_count)

        for t in reversed(rant):
            f.write(t["text"].encode("utf8"))
            f.write("\n\n")
        f.write("\n")
        rant_count += 1

So how did it turn out? Take a look for yourself here. The batching turned out to be fairly accurate in grouping together Marc’s tweets into a series of related thoughts. The autogenerated titles are hit or miss. Half of them are gibberish and half are surprisingly accurate. Given the simplicity of the natural language functions I wrote, I’m not surprised.

The Enchantments of Elm: Part 1

2013-12-25T00:00:00+00:00

TL;DR: I’m making a game in a browser based functional language called Elm. Here’s a simple Hello World-type demo.

Inspired by purely functional retro games and Steve Losh’s The Caves of Clojure series, I’ve decided to write a roguelike game in a variant of Haskell called Elm. I call the game “The Enchantments of Elm”, keeping with Steve’s alliterative naming.

According to the language’s website, Elm is a functional language that compiles to HTML, CSS, and JavaScript. It is designed for functional reactive programming, which is based on the idea of auto-updating values (similar to two-way data binding in Angular.js). To me, this seems like an ideal language to write a browser-based game.

I plan to develop this roguelike over time and blog about it. This series is best if you’re familiar with functional programming concepts such as high-order functions and combinators. This first iteration of the game isn’t that exciting. It waits for the player to hit Enter and then ends the game.

Let’s get started. First some necessary imports that we will use later.

import Keyboard
import Window

State Manipulation

Our game will need a state object to store player stats, inventory and such. Like in other languages with immutable data structures, the state will be manipulated by functions that accept the current state and return a new state.

For now, we only keep track of whether the game has ended yet. Elm has a data structure called a record, which is similar to a dictionary. We’ll define a GameState type to be a record with one field.

type GameState = {finished : Bool}

We’ll make a function to return the default state of the game. Naturally, the finished property will start out as false.

defaultGame: GameState
defaultGame = {finished = False}

It’s time to write that update function to transform the state. This function will get called on user input, namely when the player presses Enter. It ignores the input for now since it just tells us that the key has been pressed.

update : Bool -> GameState -> GameState
update input state = case state.finished of
                       True -> state
                       False -> {state | finished <- True}

Signals and FRP

Now we get to the fun part of Elm. While game programming in most languages would involve a main loop, Elm doesn’t have loops at all. Updates are triggered by Signals, which represent “reactive” values.

The one we care about for now is the built-in signal Keyboard.enter. It gets triggered when the Enter key is pressed.

Instead of writing handlers or callbacks, we will write a function called gameState that “collects” keyboard Signal events and turns them into game state Signals.

gameState : Signal GameState
gameState = foldp update defaultGame Keyboard.enter

foldp is a folding function over a Signal (which I think are applicative functors…) Every time Keyboard.enter is triggered, foldp will call update, which turns a signal input and current state into a new state. In this way, user interactions can trigger changes to our game’s state. We pass defaultGame as the starting value.

Rendering

All this state manipulation is useless if it doesn’t output anything to the screen. So we’ll define a function called renderState that does just that. It displays a different message depending on whether or not the game has finished.

renderState : GameState -> Element
renderState {finished} = case finished of
                      False -> plainText "Press enter to end game"
                      True -> plainText "GOODBYE"

The Elm standard library has many text and image processing functions. As this game becomes a real roguelike, that functionality will be useful to render menues, map tiles, and character sprites. For now, we are just going to use the plaintext features.

Finally our main function ties everything together. It takes the rendered gameState and passes it to display, which just puts it on the center of the screen.

Earlier I said that gameState is itself a signal. Whenever the gameState signal triggers, main will re-render and display it.

Note that we lift renderState and display in order to apply them to Signals.

display : (Int, Int) -> Element -> Element
display (h, w) el = container h w middle el

main = lift2 display Window.dimensions <| lift renderState gameState

Let us enjoy the fruits of our labor. Click here or enjoy this very visually impressive screen capture.

Video tag not supported. Download the video here.

Or visit the live demo.

Bits and Bobbles: Catchup Edition

2013-10-28T00:00:00+00:00

“Bits and bobbles” is a (supposedly) weekly, curated list of cool things I’ve seen people making on the Internet.

1. Web Services as Functions

A Twitter engineer explains how they they model their asynchronous RPC using futures and combinators. Although written in the form of an academic paper, this contains plenty of interesting discussion on real-world benefits and tradeoffs.

2. DIY Desktop CT Scanner

I love this project because of its beautifully laser-cut design and because it’s fairly dangerous as far as DIY bio hacks go. For safety reasons, the creator turned down the radiation level on the x-ray source, so it takes several days to scan a small object. Still amazing for a project whose bill of materials is around $300.

3. Javascript NES Emulation

In 2011, Notch (of Minecraft fame) announced 0x10c, a spacefaring game involving an in-game programmable CPU. The open-source community rallied to release 0x10c CPU emulators in every major language. 0x10c was sadly cancelled this year.

But it seems CPU emulation is in vogue again. This article walks through the architecture of the NES’s Ricoh 2A03 chipset and how to write an emulator in Javascript.

4. Meatspaces Chat

Meatspaces Chat is a public chat room that records and attaches an animated GIF of your face every time you send a message. I’ve idled on the site for a while and found it to be a really fun way to communicate. But can it evade being inundated with phalluses?

Bits and Bobbles: 10/7/2013

2013-10-07T00:00:00+00:00

“Bits and bobbles” is a weekly, curated list of cool things I’ve seen people making on the Internet.

1. Nootropics

People already take caffeine to stay alert. Why stop there? This guy find out whether off the shelf, mind-altering drugs can improve your personality and intelligence.

2. Puzzlescript

Puzzlescript lets you create full-featured 2D games in a 100% declarative way. This isn’t your grandfather’s logic programming language.

3. Acme Text Editor

Acme is a text editor where all text is UI and all UI is text. This means you can write scripts to generate GUIs to help you write scripts. Invented by Rob Pike, the same guy who created Golang.

4. Bullet Journal

One problem with being a hipster is you can’t Ctrl-F in your Moleskine. The “Bullet Journal” method of notetaking tries to solve this problem without Post-It notes and color coding.

Bits and Bobbles: 9/31/2013

2013-10-01T00:00:00+00:00

“Bits and bobbles” is a weekly, curated list of cool things I’ve seen people making on the Internet.

1. Foolproof Gardening

My dream is to have an automated vegetable garden which provides me all the produce I need. Projects like the Nourishmat give gardening a better UI.

2. Spark and Mesos

Spark is a data processing framework that is meant to compete with Hadoop. There are benchmarks that claim it is faster than Hadoop, but what I really love is the API doesn’t make my eyes bleed.

Spark is loosely related to Mesos, a distributed job scheduler. Mesos takes a compute cluster and a list of jobs and schedules them efficiently. It can schedule long-running and periodic jobs. Nice.

3. Open Source Bio Equipment

Cost of equipment makes biology prohibitively expensive for scientists in the developing world, or just curious hackers. Hacky yet effective open-source designs could bridge the gap.

4. Xmonad for OSX

Xmonad is the grandaddy of tiling window managers. It finally has been extended to support Mac OS X. I already use SizeUp but I’m inclined to give this a try.

Sprezzatura

2013-02-07T00:00:00+00:00

“Sometimes magic is just someone spending more time on something than anyone else might reasonably expect” - Teller (of Penn and Teller)

I recently came across an interesting concept called sprezzatura. It’s an Italian term that means “a certain nonchalance, so as to conceal all art and make whatever one does or says appear to be without effort.”

In many ways, sprezzatura is the antithesis of modern culture. It’s hard to create mystique when your Twitter is a publically accessible stream of consciousness. It’s hard to build conceal your art in the age of nightly builds and continuous integration, when you are encouraged to build fast and break things.

But it’s the product that matters in the end, not the process. Every peek behind the scenes deprives your audience of the magic and myth they deserve.

Maybe its time to reconsider the lost art of showmanship.

Facebook's Sponsored Posts Become Smarter (and Creepier)

2012-11-28T00:00:00+00:00

I logged into Facebook today to find my friend’s 5 days old post on the top of my newsfeed. It wasn’t particularly popular so I was curious to see why it had resurfaced nearly a week later. Turns out it was “Sponsored”. I’ve included the post below:

I headed to the Facebook Help Center to double-check what this meant. I found the following.

What are sponsored stories?

Sponsored stories are messages coming from friends about them engaging with your Page, app or event that a business, organization or individual has paid to highlight so there’s a better chance people see them.

– Facebook Help Center

So there were two possibilities here. Either my friend had paid to surface this post using the new Promote feature, or someone else had paid Facebook to feature this post. My friend denied spending any money to promote this. This is where the mystery begins.

Sponsored Stories aren’t new to Facebook. When my friends “like” or share a post on some business’s fan page, it is often featured prominently on my newsfeed. This falls under them “engaging with [a] Page, app or event”, just as the Help Center says. I’ve included an example of this below:

But take a look at my friend’s post again, at the top of this article. He wasn’t engaging with any Page, app or event in the sense one might expect. He shared an Amazon link to a product and casually mentioned the product’s name in his post. According to Facebook’s description, there was no reason to believe this post could be targeted by advertisers.

Additionally, there is no way to know who had sponsored this story on his behalf. It could have been Amazon promoting the link to the product page. Facebook has been detecting/de-duplicating newsfeed links for a while:

It could equally have been Microsoft promoting his mention of “Halo 4”. Facebook has already been doing some non-trivial topic detection on post content:

Unlike sponsored “likes” and shares, there is no way to discern who is sponsoring these plain, old Facebook posts or why they were sponsored. The fact that companies can target a user’s arbitrary content is a little creepy.

Many people might be concerned that companies can “detect” what they are talking about and use their words as advertising. I personally do not mind. But the Help Center description of Sponsored Stories is outdated at best and evasive at worst. And I think people deserve to know who is benefiting from the content they post.

Why You Will Never Have a Jetpack

2012-10-29T00:00:00+00:00

Taking a look around you, you would believe that humanity is on a steady march of progress that carries on without bound. Today we live at the height of freedom and convenience. Some even claim this is nothing compared to what is in store. As a society, we feel disappointed in ourselves unless we keep up at least a 7% economic growth rate and double our technological power every few years.

If you think about, such thoughts indicate hubris and irrational bravado. Humans think they can do anything, but it is not without reason. A species of berry-pickers once at the brink of extinction during the last Ice Age, we now rule the Earth and number nearly 7 billion.

Upon more careful inspection, though, it becomes readily apparent that how useless humans really are. Millions of people are unemployed today because machines can do their jobs faster and cheaper than they can. Doctors who train for nearly a decade in their field are routinely outperformed by statistical databases when it comes to diagnoses. Our skills are overshadowed by those of our creations.

As a last resort, we try to justify humanity’s role in the world by clinging to the intagible “creativity”. There is some quintessential ability within us, we claim, that is impervious to mechanization. Progress seems to require the human spark of ingenuity. But what has this “ingenuity” begotten?

We learned to split the atom to product unimaginable amounts of energy. But this energy wasn’t used to propel us into the heavens. It was used to fuel an arms race between despots who sold their people dreams of equality and plutocrats who sold their people dreams of materialism.

In the last 100 years, we have created powerful computers and connected them in the largest communication network in history. But it seems 30% of this vast infrastructure is being used to transport online movies. The average American uses the Internet more often to stalk their friends on Facebook than for any other activity.

Humanity has spent millenia moving mountains and mastering the laws of the Universe only to reinforce our urges to feel loved, important, powerful, and safe. Any technology that threatens our understanding of ourselves or our relationships is categorically rejected.

That’s not to say great leaps of progress will not happen. We’ll cure cancer when some determined soul decides to avenge the death of his daughter. We’ll live in space when a generation of young lovers realize Earth is too crowded for them to settle down. We will achieve great things at the last possible moment for the most selfish of reasons, as we always have throughout our history.

We indulge our human nature at the expense of the The Important Things and maybe that’s okay. Maybe we should accept the fact that despite being the most intelligent, resourceful, and powerful species to have lived, we are after all merely human.

A Proposal To Improve Hacker News

2012-08-17T00:00:00+00:00

This morning, HN user sw007 reached out the community to explain why he/she hates Hacker News. sw007 is not the first to notice the vile demeanor of the site but it was his/her post that got me thinking about how to improve the community I love.

I hope these suggestions might inspire the community leaders to consider how small changes to the site can inspire larger social changes in the HN community. But I don’t mean to second-guess PG, the mods or anyone who might know better than me.

##What doesn’t matter I’ve read many threads lamenting the state of Hacker News. Inevitably a few suggestions come up that I don’t think are all that effective.

Complaints of “too much startups, not enough tech” or vice-versa:

The modern startup founder is a Renaissance Man (or Woman!). They must know new technologies to give themselves a competitive advantage. They must know how to sell their product. And a good founder is aware of current events and humanistic stories, so they can capitalize on changes in society and also empathize with people outside of the Valley bubble. The variety of content on HN fits this ideal very well.
Algorithmic changes

Tuning the ranking algorithm may be helpful but only PG knows how best to tweak it. It would be presumptuous of me to suggest “improvements” to an algorithm I know nothing about. Moreover, the problems HN faces are inherently social problems. I think these are best solved by improving the culture and demeanor of the site rather than introducing mysterious formulas.

Instead, here is what I think would benefit the community the most:

##Distinguish veteran users It would be incredibly shocking to see a vitriolic HN comment coming from community leaders like tptacek or patio11. They have worked for years to bolster their reputation and wouldn’t dare lose that respect by snapping at a lackluster “Show HN” post.

While not all of us can spend the time to become an HN celebrity, there are many of us who have worked to get a high karma over time. HN should highlight the names of such users in purple, similar to the way it highlights newbies with green.

There are two reasons for this suggestion. First, it reminds other users to tread carefully before bashing a user with a purple name because he/she probably isn’t a total idiot. Two, it reminds these respected users to comment carefully because they have some kind of reputation on the line.

##Reward users for browsing “New”

The average up vote count of a front page post has skyrocketed lately. This means that getting from the “new” page onto the front page is a nigh impossible task. The only way to guarantee any visibility is to time very carefully using HNPickup, be a celebrity like John Gruber or Dustin Curtis, organize an up vote cabal, or write sensationalist content.

The last three options actively hurt the community. People are fed up with the empty words of blogger pundits and polemics, and are increasingly suspicious of promotional content from influential startups.

One solution is to reward users for browsing the “New” page and help surface content. Brave souls who upvote or a downvote posts on the New page should be rewarded with HN karma or some other metric. This turns “New” from a seedy underbelly where anything goes into a frequently trafficked page, reducing need to be a celebrity or cheater to garner up votes.

##Indulge the addicted HN could benefit from implementing infinite scroll, so the next page is appended asynchronously to the current one. This may sound frivolous but it is not a UI improvement for its own sake.

In my experience, being on the HN front page is a gift from the Gods while falling to the second page is effectively a death sentence. The problem is only a small minority of readers bother to click the tiny “More” button on bottom of the page.

Enabling infinite scroll on HN reduces the friction to explore content beyond the front page. Hopefully this increases readership on those less popular articles and diminishes the burning need to write inflammatory content in order to stay on the front page of the site.

##A hide button for the hot-heads Hackers like me are hot-headed. We hate to see people be wrong or idiotic so when an absurd post comes onto the front page, we rush to rip it apart.

Recently I installed an Chrome extension that allows me to hide HN posts I don’t like. Since then, I’ve simply hidden away anything that causes my blood pressure to increase. I’ve become a lot calmer and happier on the site.

Not every knows about this extension so it might be a good idea to introduce it to the site itself. It would appease the easily angered.

I'm A Maker, Dammit

2012-08-12T00:00:00+00:00

The other day I encountered this blog post in which an entrepreneur accidentally meets Russell Kirsch, computing pioneer and inventor of the first digital photo.

Kirsch, at the wise age of 81, informs the author of two principles he follows.

Do things that have never been done before

Nothing is withheld from us what we have conceived to do.

Russell Kirsch’s advice to work with determination and courage seems quaintly romantic. It surprises me that his words seem foreign to me, an entrepreneur living in the Silicon Valley. If anything, the principle of “Making Great Things” should be my personal religion. But as I read these blog posts, I could feel that I was not living that way.

Day to day, I find myself thinking of users as people I need to monetize. I no longer try to “do things that have never been done.” I do things to get to achieve the mythical goals of Growth and Traction. I judge my work by a yardstick that measures how rich I make other people. So if “nothing is withheld from us what we have conceived to do,” why am I spending all my time conceiving to do things I don’t even care about?

These principles are not why I got into startups. So from today, I’ve decided to distance myself from this “Silicon Valley way of thinking”. Hacker News and Lean Startup be damned.

I’m a maker, dammit. I’m going to go make great things.

A Primitive Approach to User Experience

2012-04-23T00:00:00+00:00

“Perfection is achieved not when there is nothing left to add, but when there is nothing left to take away”

– Antoine de Saint-Exupery

Designing an engaging and pleasant user experience is a very fragile art. It takes painstaking work to distill the power of a website or software into something that the everyday user can understand. But products from Twitter to Minecraft have become phenomenal successes by crafting their UX from very simple concepts. I dub these concepts “primitives”.

##What is a primitive? A primitive is a fundamental building block from which you can build more complicated things. Your computer screen can display millions of colors but they can all be described as a combination of three “primitive” colors - red, green and blue. All of Western music is built up from the 12 notes of the chromatic scale and the rests between them.

A user experience is also composed of primitives. Consider Facebook for example; the entire site consists of two things: posts and likes. Everything from timeline to events is just a stream of posts presented in different formats and contexts. Extraneous interactions that could not be represented by these (such as “pokes” and Facebook Gifts) have been removed or fallen out of favor.

Primitives are the key to designing an experience that your users will fall in love with. Picking the right ones results in a sense of familiarity that keeps competitors from poaching your user base. Specifically, a good UX primitive has two qualities:

###Minimalism Minimalist primitives are useful out of the box but allow room for experimentation. They enable “emergent properties,” which are interactions that your users invent without your intervention.

Users invented retweets by simply prepending “RT” before messages

Twitter has used minimalism and emergent properties to great effect. The concept of retweets and hashtags emerged organically from Twitter’s users, who invented them using just 140 character tweets and the “mention” feature. Only later did they formally become part of the product.

Trello allows users to create cards and put them into lists. Because of its simplicity, it is possible to use Trello for task management concepts ranging from a simple to-do list to a “Kanban” system that Toyota uses to manage its factories.

It is of course possible to go too far with minimalism. Google Wave had a user experience that was so generalized that no one had any idea how to use it. Instead of encouraging ingenuity, it just resulted in frustration.

###Composability In addition to being minimalist, the building blocks of your software’s UX should be composable. Having a set of composable primitives means that basic concepts can be combined in different permutations to express more complex interactions. This means that users can “discover” advanced techniques by building on their previous knowledge, rather than having to read how-to guides.

This window contains most of the magic of Photoshop

Composability is most often seen in application that are designed for “creators.” Almost every advanced effect in Photoshop is a clever combination of several filters and layer styles. Every seemingly magical keystroke in Vim is a sentence of the form “verb-preposition-subject”. Composability allows users to do hundreds of different things without having to remember hundreds of different things.

##Stretching the definition of UX These simple principles apply for any type of software interaction, from designing web sites to devising a new programming language. While I use these principles when designing clean and powerful APIs for developers, the same concepts can be used for all software.

How I Learned to Stop Worrying And Love Newbies

2012-03-31T00:00:00+00:00

I discovered this open letter to developers in an HN comment thread the other day. The author points out an concerning trait of many software developers to be overly critical and hateful towards beginners.

Almost every accomplished designer I know has disparaged Twitter Bootstrap and (implicitly) the people who use it. I admit I have the same tendencies. As a backend Web developer, I wince just a tad when someone mentions they’ve abstracted their entire application using something like Parse.

##The Tables Turn It is easy to ascribe this defensiveness to snobbery or “get off my lawn” attitude. But in reality, it is easy to see why the old guard sees newcomers as an affront to their skills. Making a concept accessible necessarily requires replacing nuance and individualism with sweeping generalizations. It hurts when the precepts of your craft are reduced to sound bites, code snippets, and cargo cult practices. Vitriolic essays comparing the software to terminal illnesses result.

But then I had to design a front-end for a side project I was making and I found myself with the daunting task of learning all about design. I could pore over articles about typographic style, proper layout and spacing, and graphic design or I could just drop a single Bootstrap script at the top of my HTML. I, the cynical backend guru, could finally empathize with those I had criticized.

##Embrace It was then I realized that these easy-to-use tools are not just a convenience but a necessity for a novice. Technology has progressed to the point that no single person can reasonably know everything about the full software stack. So much of what we know is encoded in implicit knowledge and oral tradition that a beginner would have to struggle for months before they could even get started. Abstraction is required.

There will always be people in the world who have no appreciation for your craft. Such people have always existed, even before starter kits and frameworks “dumbed things down.” There is nothing you can do except accept that fact. But for everyone else, the availability of tools provides an entry point for learning more advanced theory.

##Standing Up For Your Principles Any developer will agree that abstraction is one of the defining tenets of development. A designer should not be expected to know about databases and concurrency, nor a programmer about proper line heights. To disrespect tools like Bootstrap or Parse is to disrespect that principle.

Now, before I denounce anything aimed at beginners, I remind myself that before learning things “The Right Way,” it is necessary to learn it in the first place.

The Problem With Lazy Evaluation

2012-02-21T00:00:00+00:00

Imagine you have a landlord who collects your rent check and deposits it in a very unpredictable way. Sometimes he does it immediately. Sometimes he collects the checks for months before cashing them.

Initially you feel happy about this system because you get to live in your apartment without the money actually leaving your bank account. But soon you realize that the extra money is just a mirage. You can’t plan how much money you need to have at any given time because your landlord may cash your checks right when you don’t have the balance to back it.

This is the danger of lazy evaluation.

Rabbit holes: Why being smart hurts your productivity

2012-02-06T00:00:00+00:00

XKCD’s “Nerd Sniping” is the epitome of rabbit holing

##The geek’s Achille’s Heel I recently decided practice my algorithms skills everyday by working through Skiena’s Algorithm Design Manual and doing some Interview Street problems. To make it somewhat more interesting I decided to do all the exercises and problems in Haskell.

On my second day of practice, I felt the urge to find a better Haskell syntax highlighting extension for Vim. I managed to find one that was distributed in a package called a “Vimball”. I spent 10 minutes trying to figure out how to install a Vimball and then another 10 customizing the plugin’s settings.

Absolutely none of that helped me with my ultimate goal of learning about algorithms. By the end of the 30 minutes I allotted, I had 9 browser tabs open about useless trivia and I had not advanced a single page in my textbook.

The names change but the story remains the same. Designers find themselves studying fancy, new CSS3 effects when they should have been wire framing their checkout page. Hapless students find that they are on the Wikipedia page for Esperanto instead of writing notes on Norse mythology. Like Alice led into Wonderland by the White Rabbit, geeks too easily fall into “the rabbit hole”.

The most insidious part of this “rabbit hole” phenomenon is how unaware its victims are. We are lured into thinking we are making progress. What if this new language and setup this new stuff could help program so much better? How could you do something without having explored every tool and technique at you disposal?

As geeks, our pursuit of perfection and perfect information distract us from the task at hand, but it turns out that it is not always a bad thing.

##Your weakness is your strength Going down a rabbit hole is certainly devastating to productivity on a micro scale. But it is also a valuable “skill” when it comes to solving hard problems. Richard Feynman was fond of saying:

You have to keep a dozen of your favorite problems constantly present in your mind, although by and large they will lay in a dormant state. Every time you hear or read a new trick or a new result, test it against each of your twelve problems to see whether it helps. Every once in a while there will be a hit, and people will say, “How did he do it? He must be a genius!”

If one brilliant researcher wasn’t enough, Richard Hamming puts it yet another way in his essay You and Your Research:

I notice that if you have the door to your office closed, you get more work done today and tomorrow, and you are more productive than most. But 10 years later somehow you don’t know quite know what problems are worth working on … He who works with the door open gets all kinds of interruptions, but he also occasionally gets clues as to what the world is and what might be important. … [T]here is a pretty good correlation between those who work with the doors open and those who ultimately do important things, although people who work with doors closed often work harder.

What both of them are saying is that producing brilliant work is heavily reliant on serendipity. Putting your nose to the grindstone will certainly get things done, but when you are working on cutting-edge problems with no predetermined path to success you derive inspiration through chance discoveries.

Both these men were probably relied on conversations with their brilliant colleagues to deliver them random insights. But they also had the advantage of working at the top of their games at Caltech [1] and Bell Labs, respectively. The common geek today relies on the Internet, especially community watering holes like HackerNews and Reddit, to keep abreast of “what the world is and what might be important”.

##The solution We have concluded that random walks of knowledge-gathering keep us from getting things done day-to-day but can also be catalysts for amazing work. Falling down the rabbit hole seems to be an activity best done in moderation. How can you use it to your advantage without letting it damage you?

My solution is pretty low tech and simple. During my workday, I keep a text editor open on my desktop. In very large text, I write very specifically what I am supposed to be doing at that moment.

Every time I detect that I am wandering, I check back to the window and ask myself whether what I am doing right now will immediately benefit that tasks.

But then I don’t close the tab or stop my tinkering immediately. Obviously it was fascinating enough that I started looking into it. So I make sure that I record it somewhere so I can go back to it at my leisure.

For long form text, I am a fan on Instapaper and I’ve heard great things about Pinboard.in. If it wasn’t something on the Internet but something more abstract, like a new feature I discovered in a program, I make a note of it in my Trello board, in a list called “Wishlist”.

Make some time to revisit these repositories of information. It is easy to just hoard web snippets and never use them to your advantage. So set aside some time everyday to update yourself on your findings. It does not have to be much; just 15 minutes will suffice.

With enough discipline and practice, you may find that you are more productive than ever and maybe people will even say “How did he do it? He must be a genius!”.

Errata: Feynman had a career at Caltech, not MIT. Thanks to mturmon for the correction.

HTML5 Has Failed Us

2012-02-02T00:00:00+00:00

Unless you’ve been living under a rock, you’ve probably heard the fanfare about HTML5 and all it eye-catching splendor. What you don’t know is that HTML5 completely dropped the ball on ensuring that the web will stay free and open.

##”Shut up, you stupid hippy” That’s the first thing I think whenever I hear someone preach about the “free and open Internet.” Such rants are heard too often from neckbeards who incessantly rally against sites like Facebook or Twitter (probably because no one wants to friend them).

I am not one of those people. Instead, my story starts when I was selecting blogging engines. This blog is implemented in Jekyll but it was almost a Tumblr blog. My greatest regret with rolling my own site is I miss out on the wonderful community that comes with a site like Tumblr. No comments, no one to repost my blog posts on their own pages. This is the price I pay to keep my data open.

##One little icon that will kill the web

That little sharing icon has become the very future of the World Wide Web. Sharing has become the primary way to consume content on the Internet. Knowledge no longer propagates through hyperlinks; it comes by way of Tumblr reblogs, Twitter retweets, and Pinterest repins. Re, re, re.

The truth is that HTML does not support any way to share content in this manner. True, images can be remotely referenced by way of hot linking. But what about snippets of text (such as a Tumblr post you want to reblog)? How about a Github commit/issue you want to display inline?

There simply is not way to tell a browser or – more importantly– a web crawler, that the thing you are seeing here is really just a “view” of some resource somewhere else.

To anyone who have programmed in Rails or iOS, the concept of separating a view and the underlying model is part of your toolkit. This is sadly impossible with even the latest HTML spec.

##I like freedom. I like convenience better. I’m turning the tables on Ben Franklin this time. We’ve demanded social Web standards for over half a decade. What did we get? An incomprehensible alphabet soup like RDF, OWL and SPARQL.

More than video element and the death of Flash, a better social experience is what HTML5 should have offered us. The HTML standards committee missed the boat on provided an easy and standardized way to relate the shareable snippets that our modern Web is composed of. Instead of being encoded in Hypertext, the underlying relational graph of the web is contained within the databases of private Internet giants.

I’m not going to stop using the Web because of this. Life is far too short to be an ideologue. But I can’t help but lament what could have been.

The Essence of a Good Software Framework

2012-01-28T00:00:00+00:00

I was reading a review of Backbone.js when I came across a quote that anyone who is writing a software library or programming framework should keep in mind.

I look at Backbone, and I say to myself, “Oh, this is code I’ve written, or wish I’d written only better reviewed and field-tested than the last ad-hoc implementation of this I came up with.”

That’s it. You don’t need a boatload of features and configurability. A framework should abstract a task just enough that it’s better than rolling your own version of it.

Nappy Boy and Pretty Boy: Finding Your Perfect Cofounder

2012-01-17T00:00:00+00:00

Chris Brown (Pretty Boy) and T-Pain (Nappy Boy) consistently produce radio hits together

One of the most common problems I hear from friends looking to get into startups is the difficulty in finding a cofounder. While I was fortunate enough to stumble upon my own cofounders, I can empathize. It seems that the interests of business people are at odds with those of engineers. It's easy for one party to feel shortchanged or for visions to diverge. I've heard of plenty of cofounder disasters.

But if you look at successful startup founders, even the venerable Jobs and Wozniak, a pattern emerges. Every good pair of founders needs to have what I call a "Nappy Boy" and a "Pretty Boy".

The Pretty Boy is a dreamer and a visionary. He can make you fall in love with the future he has concocted. His foresight is unparalleled but his track record may be spotty. The Pretty Boy may sound like a douchebag "idea guy" but he's not. This persona does not necessarily imply a non-technical person. For example, an engineer Pretty Boy can convince you that a distributed, in-memory streaming database will change the way companies look at their data. The Pretty Boy looks beyond the status quo.

The Nappy Boy is a brilliant pragmatist. His performance is unflailing but he never seems to get the recognition he deserves. While the Nappy Boy may seem like the archetypal basement-dwelling engineer, he can also be a designer or a businessman. A business Nappy Boy finds the market for the Pretty Boy's state-of-the-art creations, finding the perfect messaging and positioning so that it will succeed. The Nappy Boy transforms visions into the new status quo.

Together, Nappy and Pretty can do amazing things. Pretty provides the strategy, the roadmap for the future, the "what could be". And Nappy chews down that vision with his keen practical attitude until it becomes something achievable. The key is that they support each other. The pragmatist helps build the vision and the visionary provides foresight and momentum.

This dynamic can become tense when times are tough at the startup. Like all relationships, some level of tension is perfectly healthy. The key to survival is mutual respect. Nappy should feel safe and trust Pretty's strategy. And Pretty should truly believe that Nappy tactics/expertise is what will make his vision happen. Magic happens when the Nappy Boy and the Pretty Boy want to tell the same story.

How do you know when you've found your perfect counterpart? The easiest way is to observe how you and your prospective founder behave during a brainstorm. The dialogue should cycle between periods of enthusiasm and "what-if" and periods of pragmatisms and "here-is-how". The rhythm feels like two steps forward and one step back every so often. If your trust and respect can withstand the tug of this push-pull mechanism, you might have found the one.

Setting Metrics That Encourage Failure

2012-01-09T00:00:00+00:00

I've been using a nifty app called Chains to keep track of my New Year's resolutions. It is based on Jerry Seinfeld's principle of "Don't Break the Chain," in which you strive to accumulate as many consecutive days of keeping to a certain habit. The idea is that the longer your "chain" becomes, the more impetus you have to not break it.

Chains has been working wonders for me so far. I don't get the same nagging feeling I get with a to-do list or a task manager. In fact, the small act of adding one more link to my chain of habits is incredibly gratifying.

However, I noticed a small lapse in judgement as I was using this tool. The problem was that the gratification of adding links to a chain was almost too much. I broke my promise to sleep by midnight last night but before I hit the hay, I impulsively clicked "Done" on my "Sleep By Midnight" habit.

Pretty soon I realized what I had done but instead of immediately undoing it, I entertained the notion of simply leaving it. If I didn't build up my chain, it felt like a failure. I had to do it, even if it meant that I was lying to myself; it just felt too good.

I had the equinamity to force myself to be honest. But I realized that the problem with every metric is that sooner or later, you begin to pander to the metric rather than working on what the metric is actually trying to measure.

If the performance is self-reported, you become tempted to lie. Otherwise, you can still do a sloppy job in order to meet short term goals. For example, a salesman can too agressively upsell to existing customers to meet monthly sales goals, which damages his goodwill with them and might lose him the account later on.

What is the solution? For this particular scenario, I ensured that there was a meta-metric -- a chain called "Being honest on Chains". Regardless of how many habits I kept or failed on a given day, I knew that as long as I answered honestly I would get to click "Done" on the honesty chain. And while it meant accepting my failures, it also meant I was staying true to my ulterior goal of self-improvement.

This technique can possibly be applied at the workplace, with teams or anywhere performance is measured. The first step is to realize that a measurement is a proxy for what really matters. Attaching too much importance to it makes it a system to be gamed.

It is wise to measure failures, attempts and effort without fear of penalty. Not only does it increase honesty -- because it feels far better to fill in a failure than to not be able to put down anything at all -- but it also gives more granular information to analyze.

Thoughts? Leave a line in the comments.

Testing Out Syntax Highlighting

2012-01-08T00:00:00+00:00

I have a tendency to wax philosophical on this blog so I am hoping to bring a new sense of pragmatism by posting "real-world" things such as code snippets and tutorials. To help with this, I've installed a syntax highlighting script on my page.

Let's see if this works:

public static void main(){
  System.out.println("Hello World");
}

How to Achieve Everything You Want With Zero Discipline

2011-11-28T00:00:00+00:00

Traditional life coaches think you are too weak to be able to accomplish multiple things at once. Common wisdom says you should only try training for one goal at a time so you don't run out of motivation.

That's complete nonsense. In fact, there are millions people who specialize in training for painfully rigorous things, not just one at a time but in batch. They aren't extraordinary super-achievers; they are ordinary college students. An undergraduate student takes 3-4 courses during a single term. Mastering these courses is no mean feat but, as a whole, most students are able to complete each term with at least satisfactory acheivement in each topic of study.

How are they able to do this while the average person can hardly make progress on one or two of their goals? The secret is an effective syllabus, designed by experts.

Good training requires some source of rigor. Traditional goal-setting places this burden on the the learner. Let's take for example a beginner runner whose goal is to "be able to complete a 10K in 60 minutes". Even with this well-defined goal, it is up to the learner to fill in the blanks on how to get there. Most people just "get out there" and "practice". They may burn out by trying to do too much too quickly. They might encounter weeks of zero improvement. Pushing through these rough patches requires expending willpower, which is a limited resource.

Compare that method to a syllabus Bridge to 10K program. By following a syllabus, you are practically guaranteed to make meaningful progress with each training session. Sessions are designed to improve on or sustain the result of the previous session. But it is not just any progress; a good syllabus ensures that progress is being made at a sustainable rate. This reduces the issue of burn-out or plateauing. They also provide a well defined metric of success, for immediate feedback. An perhaps most importantly, a syllabus provides a timeframe so that the goal does not become a perpetual one.

A syllabus ensures that you make progress just by "showing up" and doing what it tells you.

Now all the rigor has been offloaded from the learner to the syllabus itself. Since each goal barely taxes your fixed bank of willpower, you are free to pursue as many as you have time for. If you have time in your schedule to allot to a given training program, you can tack that onto your list of goals.

So next time you set a goal, find a syllabus/training program to accompany it. A lot of forums provide such "[X] Week beginner programs" as sticky posts. On Reddit.com's mini-sites (called "subreddits"), helpful step-by-step tutorials can be found in the sidebar. And remember that if a college kid can learn 4 things at once, so can you.

Hidden Elegance of the JVM

2011-09-19T00:00:00+00:00

Last week, I wrote a (botched) attempt to run supervised user-generated code on the JVM. (It's a cardinal sin, I know, I know). In the process, I wrote several hooks into the JVM runtime to make sure the insecure code was not attempting to use unsafe features. (If you're curious, it involved custom class loaders and security managers).

It dawned on me that I was writing a Java program that was modifying the runtime that was executing it. It was reminiscent of Lisp macros and the metacircular evaluator in SICP. It's not quite on the same level as Lisp's homoiconicity but more elegance that I would expect from kludgy Java.

Programs that are able to reason about their own execution fascinate me.

What Computer Geeks Really Do: A Guide for Friends, Family and Humanities Students

2011-09-18T00:00:00+00:00

People like me are widely misunderstood. I am disappointed when people think of computer geeks as practitioners of soulless, mechanical endeavors. I like to think of what I do as an art and a craft. Yet I agree my job is steeped in arcane acronyms and daunting terminology that makes it seem like a form of witchcraft for geniuses.

As ubiquitous as computers are today, the layperson probably has a more intuitive understanding of the esoteric job of woodwork/carpentry. So to help friends, family, and humanities students what I do, I will draw the parallels between my occupation and those of woodworkers:

The Artisan

An artisan is involved in the aesthetic and usefulness of a piece of work. If the task was to build a chair, the artisan would make sure that the chair was comfortable to sit in, could be stowed away conveniently and would be pleasing to look at.

This computer analogue of that artisan is a "designer" or "hacker." They have good knowledge of computers and programming but their job is not to think about that. They instead think about whether the overall product is usable for the final user.

The Builder

The builder's speciality is in the precision and skill of his hands. He is the one who carves raw lumber into a useful piece of wood. A builder prides himself in making this transformation while producing as little scrap wood as possible and using the fewest cuts. He turns the craftsman's schematics into reality.

This is most like the job of a "programmer" or "developer". This type of work is the one that immediately comes to mind when thinking of computers. Programmers write computer code that makes different pieces of software do their bidding. To do this efficiently requires attention to detail and experience.

The Craftsman

The craftsman is concerned with the structure of the work. He concerns himself with finding out the strength and suitability of different woods, the load-bearing capabilities of nails and fasteners, and the overall stability of frames. A craftsman innovates by exploiting the capabilities of these components in novel ways.

In the computer world, such people may be known as "computer engineers" or "software engineers" (they are rather different, but that is not important here). They quantify the behavior of the underlying components of the whole and how to efficiently put them together. Like scientists, they collect data and metrics but they are involved in the practice more than pure theory.

The Scientist

Imagine if botanists who study tree composition started calling themselves "woodworkers". It is true that some discovery about the biology of oak trees could possibly benefit the construction of furniture. But the relation is not immediate.

Similarly, "computer scientists" are mathematicians masquerading as people that work with computers. The imaginary computers they study run on proofs and formulas, not hardware and code like real computers. Many of their discoveries advance the field in practical ways but not in ways that are immediately apparent.

It's rare that a geek falls squarely into exactly one of these categories. It's not even a spectrum per se. For example, I am an "artisan" and an "craftsman" but my code is not particularly good, so I'm not a "builder".

For more sagely advice on the spectrum of occupations within "computers", read the Paul Graham's famous essay, Hackers and Painters

The Frightening Return of Walled Gardens

2010-09-05T00:00:00+00:00

Everyone who used the Internet in the 1990s remembers the ubiquity of "AOL Keywords." They were short phrases that served as proprietary URLs within the AOL portal; for instance, you could navigate to the cryptic "http://www.oprah.com" or you could simply type "OPRAH" into your AOL keyword bar and be taken directly Oprah's special page hosted on the AOL network. Guess which one most people used?

Given the popularity of America Online as an ISP, its web portal tended to be the center of the layman's web browsing experience. Everything you could ever need was found with AOL's carefully administered walled garden, so the casual web user really had no experience with the World Wide Web at large. For big businesses, this fact meant that it was crucial to establish an AOL keyword so they could be found by the quarantined masses of AOL customers.

The public's eventual awareness of the rest of the free and open Internet was precipitated by the ".com" boom, better search engines and the demise of AOL. But it seems we are taking a step back to the Dark Ages of the 90s. Facebook fan pages have usurped AOL Keywords as the modern alternative to the publicly accessible Internet. You rarely see organizations publicizing their webpages anymore. These days, they just say "Become a fan of [whatever] on Facebook".

The parallels are frightening. Like the AOL network, Facebook is entirely proprietary. All content hosted on Facebook is only accessible by people who have signed up to be members of the site, just like AOL's web portal was only available to its subscribers. Today it is still possible to find copies of regular webpages that have been up since 1995. But there is little to no record of the pages that were hosted on the AOL network from that time. The same will happen to pages on the Facebook network if the social media giant were to crash.

I don't wear a tinfoil hat and try to live off the social media grid. I have plenty of my own data locked up in Facebook's proprietary social graph. But I will readily admit that these closely guarded walled gardens are subverting the Internet ecosystem, depriving it of content that is meant to be freely accessible through open standards. Perhaps we should consider that for posterity.

You're Only As Good As Others Say You Are

2010-08-28T00:00:00+00:00

This little tidbit, entitled "Apple's Attention to Detail, has been making rounds around the Internet recently. It describes how the Mac sleeping indicator blinks in a way that emulates human breathing patterns. I am skeptical if it is really a great example of attention to detail. This kind of "subliminal messaging" gets bandied about in design huddles everywhere. "Let's make the background silhouette more curvaceous so it invokes ideas of attractive women!" or "We should make the Purchase button green because green means 'go'!" We've heard it all.

But what is remarkable is the eagerness of Apple fans and product designers to correlate this interesting-yet-unremarkable idea with Apple's design prowess. The company's success is not in doing revolutionary things but rather in getting people to talk about them as if they were. This post isn't supposed to be about technology. But the Apple example above demonstrates a larger point that applies to you and me.

The fact is that most of us are not significantly better than our colleagues and competitors, despite our cognitive bias indicating otherwise. I know that I am certainly not; I have classmates who can score better grades with less effort and hacking buddies who can whip up prototypes faster than I can. But I am generally believed to be smarter and more talented than I really am. The trick is that the people around me do a better job of building my reputation than I ever can. I've had an acquaintance who I barely remembered excitedly introduce me as his most "interesting and genuine friend." I've gotten to work on some interesting projects because my friend made sure my reputation preceded me.

The secret to success is to get people to talk about you, whether "you" are a billion-dollar corporation or a sophomore in college. How do you ensure this? I doubt I could enumerate the steps myself but Dale Carnegie's How to Win Friends and Influence People suggests that simply being receptive and interested in others does wonders to their impression of you.

An Experiment in Simplicity

2010-08-19T00:00:00+00:00

Our inventions are wont to be pretty toys, which distract our attention from serious things. They are but improved means to an unimproved end. - Henry David Thoreau, Walden

Like Thoreau, I've decided to leave behind the trappings of modernity— in my web apps, at least. For my next project, I am setting out to build the simplest idea that will actually make me money. For once (and it pains me to say this), I won't focus on building innovative technology. My goal is to push out a minimum viable product that will generate revenue. I'm giving myself no more than 4 hours to make this happen

Let's get down to business.

Why Being A Techie Is Ruining Your Products

2010-08-18T00:00:00+00:00

If you are reading this blog, chances are that you describe yourself as a technology enthusiast. But all these things could be preventing you from building. Like many of you, I face the problem of being overimmersed in tech culture. My RSS reader has me reading 12 different tech blogs daily and I've probably played around with every reasonably stable development tools released in the last 2 years. But at one point, this quickly became a problem.

To me, technology itself became something inherently wondrous and beautiful. Products were amazing because they implemented the latest and greatest tech, not because they did anything particularly profound. Futhermore, my empathy toward other developers was clouding my judgement. I forgave that clunkiness and quirks of the web-apps I saw being posted all over the internet; after all, I knew how much effort it must have taken them and it wouldn't be fair to judge them too harshly.

What resulted was a sense of disconnection from what technology means to most people. I realized it when I was showing my best friend in Massachusetts a web app I created for a hackfest. There seemed to be a fundamental difference between what I what I thought was important to present to her and what she cared to hear about. This was true among the others I showed it to as well.

I don't mean to exaggerate the divergence between the techies and the regular people. Even those who frequent tech blogs have a sense of what is resonable, and the general populace does have a sense of fascination with fancy tech. But with Slashdot, Hackernews and other tech sites, we have created an industry-wide hype machine that distorts our perception of what makes good products.

Here's some tough love to keep you from becoming overimmersed:

Make sure you're not just building a tech demo. While building the first webapp that uses Clojure to program a Hadoop cluster that processes data from Facebook's Graph API may get you tweeted about, your end user only cares about what the product can do for him. No bleeding-edge technology is going to make up for the lack of a compelling set of features. Conversely, no one is going to stay away from a killer application even if it was programmed in VBscript.

Don't build a Swiss Army knife. Geeks love LOTS of little features. The most popular sites making rounds on the blogosphere have SMS integration, Twitter, a Firefox plugin, etc. However, real users prefer to look back at the big picture and see whether your app provides a cohesive experience. Its not about the features themselves but rather how they work together to provide value.

Prepare to be underappreciated. You know that polishing a product take months and that even trivial applications take hundreds of lines of code. But they don't. People simply expect computer technology to do amazing things out of the box and become better over time. If your product is not significantly better than what your users were using 6 months ago, there is no reason for them to switch. Very few people outside the techie crowd are used to using fly-by-night Web 2.0 applications. When the average person sees your site, they will likely compare it to polished, mature products like Gmail. Make sure you have the same "WOW" factor.