In this, our fourth experimental " reviewcast" (a videocast review of software or Web-based solutions that uses a combination of video cameras, still images, a WebEx-esque remotely delivered demo, and audio from our podcasting rig), I take a look at a newly announced collaboration involving the mashup development tools from IBM (Mashup Maker and Mashup Hub) and the ever-evolving directory of APIs and other mashup consumables that can be found at programmableweb.com.
Generally speaking, mashups are a type of Internet-based software that usually runs in a browser and draws upon two or more distinctly separate entities (often domains) for functionality and/or data. The most popular form of mashup today involves mapping functionality from Google Maps and global positioning or street intersection data from databases with the final user interface looking like a Google Map with virtual pins in it. One of the most commonly discussed mashups to exemplify this combination is chicagocrime.org: a searchable Web-site that shows the precise location of crimes that have taken place in the Chicago metropolitan area. But there are many many others.
To draw upon functionality found elsewhere (for example functionality found in Google Maps), mashups usually rely on application programming interfaces (APIs, a type of mashup consumable): interfaces that when called upon by a programmer from within a mashup's source code, return some specific function into the mashup application itself. In business environments where resusability is often excercised through the internal availability of such consumables, the tools coming into the marketplace from companies like BEA and IBM include a registry of reusable consumables that can be quickly and easily incorporated into the mashup development process. To the programmer, it's like having a card catalog of approved widgets at their fingertips, in the context of their development environments.
But as more corporate and business developers begin to look outside the firewall for functionality on the public Internet that can be drawn into their business mashups, the likelihood that those consumables will be listed in their local registries is low. Enter ProgrammableWeb.com. Since founding ProgrammableWeb.com, not only has John Musser been cataloging all the mashups that are out there, he has also been cataloging all the APIs and consumables that they use.
Surely, with mashup development tools like IBM's behind corporate firewalls and directories of consumable APIs like ProgrammableWeb, there's a way to bridge the two in such a way that developers can find mashup consumables that are relevant to the mashups they're developing (without leaving the context of development environments such as IBM's QEDWiki-based collaborative Mashup Maker).
Enter OpenSearch. First developed by Amazon.com, the best description of OpenSearch that I found is on Wikipedia and says "a collection of technologies that allow publishing of search results in a format suitable for syndication and aggregation." When the "client" (in this case IBM's Mashup Maker) uses the same search interface that's expected by the server (in this case ProgrammableWeb), all the friction is taken out of pulling structured results into the client side application (again, in this case, Mashup Maker) in a way that's contextually relevant to the developer. Using our reviewcasting rig, this functionality is shown in the above video with John Musser and IBM mashup enabler Dan Gisolfi working the controls.
By supporting OpenSearch as a means of retrieving structured descriptive data about mashup consumables, ProgrammableWeb has made it possible for developers using IBM's Mashup Maker to locate relevant APIs and integrate them into their applications without having to leave the context of their development environment. More importantly, their reliance on the Creative Commons-licensed OpenSearch instead of some proprietary interface for exchanging structured data in the context of a free text search could be a huge evolutionary step forward for not just the mashup ecosystem, but for the software development ecosystem on the whole which, over time, will come to rely more and more on functionality and data through API-accessible services.
While OpenSearch could turn out to be the missing link between development tools and the virtual public repository of consumables that they draw upon, this collaboration and proof of concept between IBM and Programmable Web probably scratches the surface of what could be the end game. For example, today, as can be seen in the above video, the descriptive data that Mashup Maker pulls into its development environment is relatively basic. If more companies on both the tool and consumable side embrace what IBM and ProgammableWeb have started, not only might the software community end up with some sort of defacto open standard on its hands, I could see that community using consensus to evolve the level of detail that directories of consumables return to tools like IBM's Mashup Maker.
At the same time, it's exactly that sort of industry wide interest that's needed for this OpenSearch-based approach to take off. For the time being, it is limited to the interaction between IBM's tools and ProgrammableWeb.com. But should other tool makers like BEA and Serena embrace the idea from the client-side, and should other directory providers on the server side support it as well, that's when things could start to get really interesting.
Disclosure: IBM is a sponsor of Mashup Camp which is an event produced by Mass Events Labs. I am co-owner of Mass Events Labs. IBM's sponsorship was not a factor in posting this reviewcast to the Web. Prior to doing a video of this mashup development tool in action, I recorded and published video of solutions from two of IBM's competitors in the enterprise mashup tool space -- BEA and Serena -- neither of which were Mashup Camp sponsors.