As one of the co-organizers of Mashup Camp, I'm getting a lot of inquiries via email and from the press about what mashups are and why they're getting so much buzz. Invariably, my response begins by evoking their memory of another technology ecosystem that exploded through the stratosphere just after exiting from its embryonic phase -- one that the mashup ecosystem (or what I call the "uncomputer") is virtually identical to: The PC.
In explaining the uncomputer, I recently wrote:
When I think about what today's operating systems are — Windows, OS X, Linux, etc – I mostly seem them as collections of application programming interfaces (APIs) that give developers easy access to resources (displays, networks, file systems, user interfaces, etc.)....The computer that we've come to know and love is quickly becoming a thing of the past (thus, the "uncomputer") and quickly taking its place (and drawing developers in droves) is a new collection of APIs (this time Internet-based ones) and database interfaces being offered by outfits like Google, Yahoo, Microsoft, Salesforce.com, eBay, Technorati, and Amazon (as well as smaller private enterprises, governments, and other businesses)....Barely a day goes by where some new mashup — the creative merger of one or more of these APIs with each other and/or with a public or private database — doesn't appear on the Web.
When I verbally explain these principles, some people get it right away (and the proverbial aha! moment follows). Others struggle. I know why. When I'm describing it, I'm picturing the one-to-one overlaying of the two ecosystems in my head. Even after reading the aforementioned passage, few people are working off the same imagery I am. So, I've decided to fix that problem by doing the images. Although it's not perfect and some of you techies out there might prefer to organize it differently or use other labels, here is my simplified image of how applications (eg: productivity applications) rely on the APIs of an operating system (eg: Windows) to get things done while interacting with the operating systems graphical user interface:
The diagram clearly oversimplifies how software works, but it is more than adequate when it comes to comparing the PC ecosystem to the mashup ecosystem. Here, you have applications in the top layer that interact with operating system's (OS) graphical user interface (GUI) and whose developers relied on the OS's APIs to do a lot of the heavy lifting for them. (The back and forth arrows that demonstrate this reliance may not be exact. They're just there to give the sense of data and instructions being passed back and forth between the two layers.) Back in the old days, for example, to put a packet on the network, developers had to write thousands of lines of code. Today, it's basically one line of code that calls the networking APIs that in turn, do all the hard work so developers don't have to. In labeling this layered model, I've provided samples of applications, APIs, and operating systems. But these aren't absolutes. Now, let's look at the basic framework of mashups:
With three primary layers (OS, API, and app/mashup) and a user interface, the underlying framework to the two ecosystems is nearly identical. While there are a bunch of APIs that you'll never find in an OS (with more coming every day) and vice versa, some of the APIs (ie: storage, security, messaging, database access) are the same. Even some of the applications are the same! The only others differences are that the word "mashup" appears in place of the word "apps", "browser" appears in place of the phrase "OS GUI" and the various OSes that play host to the APIs are replaced by the Internet. I probably could have used the word "Host" (as in API host) instead of "OS."
Another great aspect of the mashup ecosystem is that instead of the OS vendors being in charge of providing the APIs, that's left to the operators of Web sites. In true bazaar-like fashion (as in The Cathedral and the Bazaar), what this means is that anybody can add any API at anytime which in turn makes the mashup ecosystem incredibly ripe for innovation. After all, when has a developer not said, "I wish there was an API for XYZ to do some heavy lifting for me?" That desire to scratch an itch is where innovation begins and now, there's no paperwork to fill out, phone calls to make, or slotting of priorities to do in order to get itches scratched. Wanna add an API to the Internet? Go right head. Start innovating.
Finally, why might this ecosystem snowball the way none before it has (not to say that the ones before it haven't been unbelievably successful)? Because, with mashups, fewer technical skills are needed to become a developer than ever. Not only that, the simplest ones can be done in 10 or 15 minutes. Before, you had to be a pretty decent code jockey with languages like C++ or Visual Basic to turn your creativity into innovation. With mashups, much the same way blogging systems put Web publishing into the hands of millions of ordinary non-technical people, the barrier to developing applications and turning creativity into innovation is so low that there's a vacuum into which an entire new class of developers will be sucked. It's already happening.
Check out John Musser's new MashupFeed web site. On it, he charts the number of new mashups that are turning up every day. On the basis that there's 144 APIs and more than 350 mashups that use them, the average number of new mashups per day that he was reporting when I last checked was 2.63. And those are only the ones he knows about. Provided its accurate, at that rate, that's over 800 new applications per year. How will the rate change when there's 1000 APIs by the end of 2007 (my prediction)? It's anyone's guess. But one thing is for sure. It's not going down.