One of my favorite Internet stats to check out are the mashup and open API trendlines on the front page of Programmable Web. Consistently, month after month this year and right up until present day, we've seen the mashup stats climb intriguing steadiness. And along with hundreds of available Web APIs, we've Are users tired of being the integration point for most of their software?also maintained a sustained rate of approximately three brand new mashup applications being released per day. Interesting growth, but is it the start of a major trend?
The fact is that the majority of mashups aren't taking the world by storm quite yet though sites like Zillow show off the potential best. But more and more functionally useful composite Web apps continue to come out and the promise continues to grow. Sometimes it seems that we are potentially witnessing the rise of a brand-new application development model; one based on the concept of building applications primarily out of the content and functionality of other applications.
However, as with most new phenomena, the actual direction that mashups will take is unclear. But the questions that come out about all of this do at least sound pretty important:
Does the rise of mashups signify that meaningful software reuse is here at long last? Are most mashups really just toy applications with little sustainable long-term value? Will mashups become a valuable tool to unleash the potential of SOAs in the enterprise? Will consumers start to clamor for ways to connect their fragmented collections of data together? Do mashups the leading edge of a new era of very well integrated, yet loosely coupled systems? Are users tired of being the integration point for most of their software? It's too early to answer these questions though the broad outlines do seem to be coming together.
Unfortunately, we still have mostly anecdotal evidence this year, despite John Musser's diligently captured statistics in the diagram to the right. As part of the mashup story, we're just beginning to see the high quality tools coming that explicitly support the mashup development approach. Ajax was one of last year's hottest buzzwords (and remains one today), but it was the widespread emergence of useful frameworks and widget libraries -- along with compelling examples in use -- that actually helped it take off.
While plenty of very attractive examples exist, mashup development technology however is mired in the murky, complex, and slow-moving arena of software integration. Consequently, we're only now starting to see truly capable, easy-to-use mashup creation tools surfacing on the Web. I've written here on this blog about the various mashup development tools coming out and I can and will add many more to the list as they begin to emerge next year.
For my part, the question comes down to the value proposition. Mashups clearly offer a value proposition to developers, who are usually willing to integrate high value, hard-to-recreate content and services from elsewhere, as long as its very easy to do (or it likely won't overcome the Not Invented Here syndrome.) The ease of integration in the browser is also another major advantage. So too is value offered to users who aren't going to convince IT to build the custom app they need or consumers who might just be willing to use drag-and-drop tools to pull together the data they need to live their lives (such as the age-old problem of having a single electronic calendar with all your information on it.)
Mashups can in theory address all of these problems while reducing the cost of development to just about nothing. I'll save the cost of support for later since it's unclear how easy mashups will be to support if everyone in an organization is chuffing them out by the dozen, though it could be analogous to how difficult spreadsheets are to support, which are currently the most popular end-user development tool today.
And so end-user support challenges are potentially one of the downsides to the mashup phenomenon, though it's also one that IT departments faced a couple of decades ago when users starting bringing PCs in the back door. Yet, self-service IT always has the potential to result in anarchy and this is one reason why governance is such a hot buzzword these days, particularly in the SOA community with composite apps (aka mashups) giving rise to thorny issues around support, policy, enforcement, cost sharing, and so on.
However, tools like JackBe's Presto which I wrote about here not long ago have the potential of delivering the good aspects of mashups to the enterprise while explicitly providing tools and approaches to cope with the loss of control. And though we might just have a few hundred formal APIs available out on the Web, you can start preparing for just about everything to be converted into a service and soon. Powerful new tools and communities around open content are becoming available. Pre-eminent among these are sites like OpenKapow, a free set of tools with an online directory of services that allows anyone to turn any content located anywhere on the Web into a nice open API and share it with everyone else.
View a screencast I made about OpenKapow's RoboMaker and new online community, demonstrating how easy it is to turn any Web content into a mashup-ready API and share it with others
Obviously, the mashup phenomenon opens up numerous issues including how to monetize the resulting applications, the legality of using the content of others to build businesses that are potentially competitive yet potentially highly profitable. At last week's Web Builder 2.0 conference in Las Vegas I gave an overview of these very challenges to a room nearly full of IT managers seeking to understand just these issues. In a time when it's very hard to keep control of the content we put out on the Web, determining how to embrace what seems to be an inevitable trend will encourage the innovative among us to figure out the successful ways of open up content and services on the Web..
And it's not at all hard to see the value of providing APIs and opening them up on the Web. I often cite that Amazon's most profitable products are its open Web services APIs which earned them over $200 million in revenue last year alone. Though Amazon's spending on its very innovative Web services products such as S3 and Mechanical Turk has declined, it's also due to the fact that they've staked out a huge amount of territory and are years ahead of many of their competitors. So right now, the money in mashups is currently providing APIs, not necessarily in building the mashups themselves yet, at least out on the Web. But in the enterprise it may be a very different story as these new lightweight models for building applications primarily via rapid integration offers the potential to fundamentally revolutionize the economics of corporate software development.
Thus, many new mashup development platforms will be coming out in the next few months and I'll cover as many of them as I can here. For now, take a look at Denodo's new Enterprise Data Mashups and Nimaya's ActionBridge as just two small examples of what is likely to turn into a rush of product introductions in 2007.