Chapter 9. Moving from APIs and Remixable Elements to Mashups
Table of Contents
Now that you understand the pieces that go into mashups (remixable elements such as a rich URL language, tags, and feeds—all the subjects of Part 1) and APIs (the subject matter of Part 2), this chapter teaches you how to get a feel for how mashups are created from their pieces. To learn how to create mashups, you should study a lot of examples of mashups. In the next chapter, we will work out all the technical details of how to create a specific mashup. In this chapter, we’ll step back to look at a broad range of problems that can be addressed with mashups. I won’t work through all the details of how to create the mashup, but by thinking about a variety of problems—how others have created mashups to solve the problems themselves or related ones—you can learn about how to create mashups, what’s possible, and what goes into them.
The primary technique we’ll use to learn about mashups and APIs in this chapter is to mine ProgrammableWeb for information. ProgrammableWeb is the most useful web site for keeping up with the world of mashups, specifically, the relationships between all the APIs and mashups out there. It’s by no means the only resource; you can’t learn all you need from using it alone. However, learning how to use it effectively is a great way to make sense of the world of mashups as a whole.
To effectively understand mashup making, you should have a specific problem in mind that you want to solve. There’s so much you can do with mashups that you will be overwhelmed if you set out to assimilate 2,000+ mashups in ProgrammableWeb without a set purpose. In this chapter, I will use some specific problems and show how ProgrammableWeb can help you understand how to use mashups to solve these problems.
Specifically, I’ll cover the following situations in this chapter:
Books: Integrating my varied interactions with books through mashups
Real estate search: Tracking houses coming onto the market and comparing them to estimates of worth
Travel search: Knowing when is a good time to buy airplane tickets
News: Using maps to understand current events around the world
Getting Oriented to ProgrammableWeb
You have already learned about ProgrammableWeb (http://www.programmableweb.com/) in this book. In Chapter 7, I discussed what you can learn about APIs, which are the major raw ingredients mashups, from ProgrammableWeb.
Here, I’ll show you how to use ProgrammableWeb to learn about mashups. ProgrammableWeb is probably the most comprehensive database of web APIs and mashups and how they are related to one another. ProgrammableWeb and this book are complementary resources to learn about mashups. This book is focused on the nitty-gritty programming details of how to use APIs in creating mashups, and ProgrammableWeb covers the field in breadth and keeps pace with the fast-changing field. Note, however, that ProgrammableWeb doesn’t claim to be comprehensive:[133]
You list a lot of mashups on this site. Are these all the mashups there are?
No. This is a subset, or sample, of all mashups. The universe of web mashups is too large and dynamic to be cataloged in one place. And even that assumes that there’s an agreed-upon single definition of what a mashup is. Which there isn’t. That being said, this is probably the most diverse and structured collection available.
One of the great features of ProgrammableWeb is that it covers APIs and mashups across a wide range of fields. Whereas API providers often link to applications that build upon their own APIs, ProgrammableWeb not only makes that information organized in a nice fashion, but it also lets you see how these APIs work with other APIs, which is really not usually of interest to any given API provider.
User-Generated Data in ProgrammableWeb
ProgrammableWeb depends deeply on user-generated profiles, as well as content entered by the people who run ProgrammableWeb. To participate in commenting or creating mashup or API entries, you can create an account on ProgrammableWeb here:
http://www.programmableweb.com/register
Registered users can create an entry for APIs or mashups and enter data about it here:
http://www.programmableweb.com/add
When you list a mashup at ProgrammableWeb, you can indicate what APIs are being used by the mashup.
Can Any Directory of Mashups Keep Up?
As mashups become more commonplace, we’re going to be in a parallel situation to when Yahoo! went from being able to list every web site in a directory to needing search engines to crawl the Web to figure out what’s on the Web. There will be way too many web sites that will use APIs in the future. Nonetheless, the practice you get here with the examples listed on ProgrammableWeb will help you recognize others in the wild. Until there is such a search engine for APIs and mashups that can automatically crawl for APIs, we will need a manual approach such as ProgrammableWeb.
Learning About the Overall Mashup Scene
You can follow ProgrammableWeb’s own overview here:
http://www.programmableweb.com/tour
I will also highlight for you how to use it specifically to learn about mashups.
Figure 9-1 shows the portal page for mashups on ProgrammableWeb.
http://www.programmableweb.com/mashups
That page is a useful snapshot of the world of mashups that are in the ProgrammableWeb database. Here are some statistics listed on the page (as of January 13, 2008):
The total number of mashups listed (2,661)
The average rate of new mashups being added to the database (the six-month average was 3.14 per day)
I have found that this rapid growth of mashups makes it a challenge to keep up with everything that happens, even though some trends have remained quite stable (such as the popularity of map-based mashups).
Directory of Mashups
You can get a list of all the mashups in the database (by page) here:
http://www.programmableweb.com/mashups/directory
You can sort the list of mashups by the name of a mashup (which is the default view), the date when the mashup’s profile was last updated, and the popularity of the mashup (the number of page views on ProgrammableWeb for that mashup). You can view the list as text, as “descriptive” (a mix of text and a thumbnail), or as a pure thumbnail view:
http://www.programmableweb.com/mashups/directory/{page}?sort={sort}&view={view}
where sort is one of name, date, or popular and where view is one of text, desc, or images.
For example:
http://www.programmableweb.com/mashups/directory/5?sort=popular&view=desc
Note that the popularity of APIs is measured by the number of mashups using that API:
http://www.programmableweb.com/popular
I like the idea of looking at the newest (if you are up on a field and want to see the latest) and the most popular (if you are new to a field and want to get a quick glance of what the scene is like). Comparing the newest and most popular mashups often helps to see what trends are afoot.
Indeed, you might be able to get the best of both by viewing a list of the top “popular new mashups” at http://www.programmableweb.com/mashups.
Using Feeds to Track Mashups
ProgrammableWeb uses techniques detailed in earlier chapters to help users not only track mashups but to create data about mashups. For instance, you can use the following RSS 2.0 feed to track new mashups on ProgrammableWeb:
http://feeds.feedburner.com/programmableweb/mashup
There are other feeds available such as the RSS 2.0 feed for blog entries:
http://feeds.feedburner.com/ProgrammableWeb
Here is the RSS 2.0 feed for the latest APIs:
http://feeds.feedburner.com/programmableweb/apis
You will find in the ProgrammableWeb blog (http://blog.programmableweb.com/) references to the APIs and mashup profile pages themselves. The ProgrammableWeb blog is an excellent place to read about the latest APIs and mashups of note, and it’s also a thoughtful commentary about what these APIs and mashups mean.
Using Tags to Describe Mashups
Tags serve in ProgrammableWeb as thumbnail descriptions of what a given mashup or API is about. They are normalized to some degree to enable comparisons among mashups, in other words, to find similarities and patterns. I’ll use these tags in this chapter to relate various mashups.
Tags associated with a given mashup are user-generated. That is, the user who creates a profile for a given mashup is allowed to use up to six tags that can be associated with the mashup. Note the caveat on the link addition page, specifically, the admonition to “[u]se spaces between tags, no punctuation and limit to six tags please”:
http://www.programmableweb.com/add
Also, the site will edit the entry to limit spam and ensure consistency—say, among tags.
You can see popular tags for mashups here:
http://www.programmableweb.com/mashups
Specifically, on this page you can see a pie chart of the top mashup tags for the last 14 days and for all time; this allows you to see how the current trends may or may not be deviating from long-term averages. Table 9-1 reproduces that information.
| Category | All | Last 14 Days |
| Mapping | 40% | 27% |
| Photo | 10% | n/a |
| Shopping | 9% | 12% |
| Video | 6% | 12% |
| RSS | n/a | 6% |
This quick comparison attests to the long-term and short-term popularity of mapping. It looks like video mashups are on the rise—but you have to track it more to be sure. At any rate, if you keep an eye on the popular tags associated with mashups over time, you can get a feel for both short-term and long-term trends.
You can find the tag cloud of tags associated with the mashups here:
http://www.programmableweb.com/search
There you will find a short list of the top ten tags. Another worthwhile page is here:
http://www.programmableweb.com/mashups/directory
On the left side, you will find a list of the top 20 tags for mashups, along with the number of mashups for that tag. Here’s a list of the ten most popular tags for mashups as of January 13, 2008:
mappingphotoshoppingsearchtravelvideonewssportsrealestatemessaging
Note that the URL template to access the list of mashups by tag is as follows:
http://www.programmableweb.com/tag/{tag}
For example:
http://www.programmableweb.com/tag/mapping
You can page and sort and change views, too:
http://www.programmableweb.com/tag/{tag}/{page}?sort={sort}&view={view}
where sort is one of name, date, or popular and where view is one of text, desc, or images.
For example:
http://www.programmableweb.com/tag/mapping/2?sort=date&view=desc
Note that the tags associated with mashups are not necessarily the same as those for API tags, though you can expect some overlap. For example:
http://www.programmableweb.com/apitag/mapping
That brings up APIs that have been tagged with mapping
and brings up mashups tagged with mapping:
http://www.programmableweb.com/tag/mapping
Note APIs are also classified in categories:
http://www.programmableweb.com/apis/directory/1?sort=category
API and Mashup Verticals
ProgrammableWeb calls out certain fields or segments with high activity as vertical markets for special attention:
http://www.programmableweb.com/markets
As of this writing, the special vertical markets (which are correlated to popular tags but not exactly) are as follows with upcoming markets for search, enterprise, and widgets:
If you take a look at one of these segments, you will see a dashboard (much like the main Mashup Dashboard) focused on that segment. One helpful extra is a description of the “big picture” for a segment, such as the one for telephony:
http://www.programmableweb.com/featured/telephony-mobile-apis-and-mashups
Why are verticals significant? That is, what does distinguishing verticals offer beyond just looking at the top mashup tags? You shouldn’t be surprised that there would be significant overlap between the top mashup tags and the verticals. Certain verticals (such as government and telephony) are identified whose importance is not immediately apparent from tag popularity.