We were invited to participate in IBMs Mashup Ecosystem Summit in San Francisco today. The purpose was to discuss the future of Mashups, identify the various moving parts, the challenges and the potential for interoperability among frameworks, vendors, etc.
It was nice to be invited to the event considering that we’ve only just started to talk about what we are doing. The day begain with Dion Hinchcliffe (via telephone) kicking off the discussion describing the state of the Mashup universe. He went through some of the challenges and opportunities. There were a lot of smart people there from IBM, Socialtext, (blog), Teqlo, (blog), Mashery, Reuters, Accuweather, Zimbra, Coghead, Kapow, and others.
John Musser who runs Programmable Web was there as well. In preparation for today’s meeting I visited Programmable Web to see what the state of Mashup was these days. Since we don’t focus on Mashup, per se, it had been a while since I dug around there to see what was gaining adoption.
There it lists 1,832 Mashups with 37% of them using mapping APIs, 9% photos, 8% news, 6% RSS and so on.
Their API scorecard indicates that Google Maps is used in 931, or nearly 50% of all Mashups!
I looked through Programmable Web for Enterprise Mashups, thinking that would be a good place to see how they tackled the problems of data integrations.
I was surprised to find that there are only 9 Mashups tagged ‘enterprise’. Out of these nine, Salesforce.com is part of four of them.
I was a little surprised by this and not exactly sure what conclusions could be drawn from it. One possible conclusion was that Mashups were really a consumer thing and Enterprises couldn’t figure out how to leverage Mashup techniques to their advantage. The other was that the Enterprises weren’t able to build Mashups because of a lack of tools or some other reason. I hoped to learn more at the Summit.
In preparing for my presentation today I went back to Dion’s post that suggests there are five different styles of Mashup:
The simplest type, Presentation Mashup are simply adding widgets to a web page. Not a lot of rocket science there. Most bloggers use some form of Presentation Mashup. The next most popular are client side Mashups, things like housingmaps.com, diggdot.com, etc.
Server side Mashup would include things that begin to resemble composite applications because they require integrating data from various sources processing it in some way and presenting it in a new application. Zillow is a great example of a server side Mashup.
As I thought about this some more, it occurred to me that Server Data Mashup are really just data integrations, but using Mashup techniques rather than conventional methods like an ESB, or an SOA. So, it seems to me that Server Data Mashups could be greatly simplified with SnapLogic.
I put together this slide to illustrate my thoughts on where SnapLogic and some of the other participants were positioned in the Mashup Stack. If you further distinguish between end-user and developer Mashup tools, you can see how the different approaches lined up. This seemed to make a lot of sense to me.
I liked this graphic since it helped me understand where some of these solutions fit. But it still didn’t explain why there aren’t many Enterprise Mashups. We discussed this today at the Summit and some suggested that integration is just too hard, and difficult things, by definition, aren’t Mashups. Other’s suggested that Mashups are really a client-side methodology and server-side Mashups were really just composite apps.
Well, to this, I agreed, and disagreed. Yes, they are composite apps, and building a composite app is hard. That’s what enterprises have been trying to do with their SOAs and Web Services initiatives. I even agreed that these are not Mashups.
However, I think this perspective is looking at the current situation and drawing conclusions from recent history. But if you change your perspective and posit that if building composite applications could be built easily, then they would most definitely be Mashup.
The trick is making them easier to build. And that’s where I think SnapLogic can play a role.
I hope a year from now after we get some adoption, we’ll see on Programmable Web a lot more Mashups tagged ‘enterprise’, and that the reason is that server side data Mashups have become easier with SnapLogic.
Thanks again to Rod Smith and David Boloker of IBM for organizing today’s Summit.