Good news Delicious fans — Yahoo has finally made something of an announcement, saying that the bookmarking service will not be shut down, but sold off.

Despite a leaked, internal image that listed Delicious and other services in a “sunset” category, Yahoo denies it is planning to shut the bookmarking service down.

The Delicious blog says the service is looking for “a home outside the company that would make more sense for the service and our users.”

According to the same announcement, the tech press is to blame for assuming that “sunset” meant shut down. More likely, Yahoo simply wasn’t ready for the level of backlash that rumors of Delicious’ demise brought about, and now the company is backpedalling.

Yahoo also hasn’t made any announcement regarding MyBlogLog, Yahoo Buzz or any of the other services listed as “sunset” in the leaked graphic that circulated last week.

Presumably, in some cases, sunset does in fact mean “shut down.”

Still, the word that Delicious will live on in some form is good news for the millions of users and bookmarks the service currently hosts. Unfortunately, Yahoo has not denied that it has laid off the engineers and technical staff behind Delicious.

See Also:

• Yahoo Plans to Kill Off Delicious Bookmarking Service
• Xmarks Lives: LastPass Buys Downtrodden Bookmark Syncing Service
• Geocities Lives On as Massive Torrent Download
• Geocities, Identity and the Problem With Disappearing Web Services

Google is now letting any Yahoo users sign in to Google using OpenID, the company announced Tuesday.

When you’re signing up for a Google account, there’s now a new button you can click on that says “Verify by signing in at Yahoo.com.” Click it, and you’re sent to Yahoo, where you’re asked to allow Google and Yahoo to link up your accounts.

Tuesday’s development marks Google’s first attempt to be an OpenID relying party — a website that accepts OpenID logins from third-party providers. Also, this only works for Yahoo users for now, but Google says it’s going to start offering support for other OpenID providers soon.

On the surface, this may look like an attempt by Google to poach users away from Yahoo by making it even easier for them to switch. In fact, it’s a real-world example of the type of interoperability that OpenID has been promising to bring to the open web for some time.

The more services, web apps and social networks we sign up for, the more places we have to create an account, remember a password, find friends, and build up a user profile. OpenID and the other twiddly bits in the “open stack” of social web technologies — like OAuth and Portable Contacts — make it easier for us to securely re-use this data across numerous websites and applications while only having to maintain one user account and one password at the provider of our choosing. With OpenID and OAuth, your data can easily be forklifted into other social networks with just a few clicks. OpenID currently powers the majority of third-party logins on the web.

This new Google/Yahoo system works because Yahoo is an OpenID provider. If you have a Yahoo account, you can use it to log in to any website that accepts OpenID. Google has simply started using the Yahoo OpenID API, the bit of code that makes it easier for third parties to create a simple, streamlined login experience for visitors who want to use their Yahoo ID to log in.

The same type of third-party login is possible using your Google account, since Google exposes the information necessary to make that happen in its own OpenID APIs.

So there’s no poaching happening here, just an open door policy on Yahoo’s end, and the implementation of one of Yahoo’s APIs on Google’s end.

Google is currently only offering OpenID logins for Yahoo users, the company says. The Google Code blog gives some more detail: “As [the new login feature] is based on an internet standard, we plan to use it in the future with other e-mail providers that add support for this usage of OpenID and related standards like OAuth, such as in the Microsoft Live identity APIs.”

Google is also experimenting with an OpenID/OAuth hybrid called Step2, which builds on similar community efforts to build a new system based on those two technologies. Among other things, these new hybrid systems aim to make the process less confusing for users, and to make OAuth sign-ins easier for applications that run on a phone or on the desktop rather than in a web browser.

See also:

• New ‘OpenID Connect’ Proposal Could Solve Many of the Social Web’s Woes
• Video: The Open and Social Web Explained
• Facebook Adopts Open Standard for User Logins
• Twitter Moves to OAuth: The OAuthcalypse Is Nigh

This is the basic structure of a data call to Yahoo Maps’ API. This will draw a 500px by 300px map centered on Wired’s San Francisco offices, complete with zoom and pan controls. When the user clicks on the location marker, a pop-up box will appear with some text inside.

All of these attributes can be changed by modifying the code below. You’ll need to use your own API key.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">

	<head>



		<title>My Yahoo Map</title>

		<script type="text/javascript" src="http://api.maps.yahoo.com/ajaxymap?v=3.8&appid=YOUR_API_KEY"></script>

		<style>

		div#ymap {

			width: 500px;

			height: 300px;

		}

		</style>



		<script type="text/javascript">

		function initialize_ymap()

		{

			// Create a map object

			var map = new YMap(document.getElementById('ymap'));

			// Create latitude/longitude point

			var yPoint = new YGeoPoint(37.780764,-122.395592);



			// Add map type control

			map.addTypeControl();

			// Default map to satellite (YAHOO_MAP_SAT) -- other opts: YAHOO_MAP_HYB, YAHOO_MAP_REG

			map.setMapType(YAHOO_MAP_SAT);



			// Add zoom control

			map.addZoomLong();

			// Add the pan control

			map.addPanControl();



			// Display the map centered on a geocoded location

			map.drawZoomAndCenter(yPoint, 6);



			// Create a new marker for an address

			var myMarker = new YMarker(yPoint);

			// Create some content to go inside the SmartWindow

			var myMarkerContent = "<h2><strong>Wired HQ!</strong></h2><p>Home of Monkeys</p>";

			// When the marker is clicked, show the SmartWindow

			YEvent.Capture(myMarker, EventsList.MouseClick,

				function() {

					myMarker.openSmartWindow(myMarkerContent);

				});



			// Add a label to the marker

			myMarker.addAutoExpand("Click for more!");



			// Put the marker on the map

			map.addOverlay(myMarker);



		}

		</script>

	</head>



	<body onload="initialize_ymap()">

		<h1>My Yahoo! Map</h1>

		<div id="ymap"></div>

	</body>

</html>

Yahoo’s Maps API may not be as popular as Google’s mashup mainstay, but it has many of the same features. In some ways, it’s even easier to use than Google’s Maps API, so beginners getting started with API interaction might prefer Yahoo’s implementation.

To get started working with Yahoo maps, we’ll simply create a map we can display on a web page, and then add a marker to denote a particular location.

What you’ll need

• Knowledge of JavaScript, CSS and HTML
• A Yahoo account
• A Yahoo Application ID. Yahoo will ask for some information from you, but the good news is you get an ID right away.

How to Proceed

Step 1: Get started

Before using the API, you’ll need a Yahoo account and an Application ID. Once you have your ID, create a file containing the following HTML:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">

	<head>

		<title>My Yahoo Map</title>

		<script type="text/javascript" src="http://api.maps.yahoo.com/ajaxymap?v=3.8&appid=appidhere"></script>

	</head>

	<body>

		<h1>My Yahoo Map</h1>

		<div id="ymap"></div>

	</body>

</html>

This code is enough to load the API, but we don’t have a map quite yet.

Step 2: Adding in the Map

To tell Yahoo how and where to add a map, we need to add some JavaScript between the head tags near the top of our HTML file. Try this function, initialize_ymap:

		<script type="text/javascript">

		function initialize_ymap()

		{

			// Create a map object

			var map = new YMap(document.getElementById('ymap'));

			// Display the map centered on a geocoded location

			map.drawZoomAndCenter("San Francisco", 6);

		}

		</script>

Here, we tell Yahoo to use the element with the id “ymap” as our map. In the HTML code we created in step one, we included an empty div with the “ymap” id. In the second part of the script, we tell the map to center on San Francisco and zoom in.

Finally, we need to call the initialize_ymap function. To do this, add an onload attribute to the body tag of your HTML document, like so:

	<body onload="initialize_ymap()">

Reload the HTML file and you should see San Francisco. Yeah?

Now would also be a fine time to change the shape of your map if you’d like. To do this, you just need to add a few style declarations for div#ymap in your CSS file, or add this code between your head tags:

		<style>

		div#ymap {

			width: 500px;

			height: 300px;

		}

		</style>

Reload and now you should see San Francisco in widescreen. Fancy!

Step 3: Adding Markers

The thing that makes using these maps better than using a plain old static image is the added spark you get from interactivity. To that end, let’s take this map up a notch by adding a clickable marker — one of those little flags that denotes a specific point on the map. Yahoo also lets you include information about the location inside an element called the SmartWindow. Your visitors will see the Ajax-powered SmartWindow pop up when they click on your marker.

Placing a marker on your map will require adding some more JavaScript code to the initialize_ymap function. Add this bit after the drawZoomAndCenter line:

		// Create a new marker for an address

		var myMarker = new YMarker("520 3rd St, San Francisco, CA");

		// Create some content to go inside the SmartWindow

		var myMarkerContent = "<h2><strong>Wired.com</strong></h2><p>Home of Monkeys</p>";

		// When the marker is clicked, show the SmartWindow

		YEvent.Capture(myMarker, EventsList.MouseClick,

			function() {

				myMarker.openSmartWindow(myMarkerContent);

			});

		// Put the marker on the map

		map.addOverlay(myMarker);

Reload your HTML file and now a little speech bubble icon should now be hovering above I-80 on the east side of San Francisco. Click it, and you’ll see the message inside a SmartWindow. You can even include HTML markup inside your SmartWindow.

Now you’ve made huge strides toward being a Yahoo Maps API expert!

Where to Go From Here

There are many ways to improve your Yahoo Map. So far we have a very basic map, but here are a few more things you can do to make it a little sexier, complete with code.

Add a short message to your marker when users hover their mouse over the icon. Add this code after the new YMarker line:

		// Add a label to the marker

		myMarker.addAutoExpand("Click for more!");

Make your map zoomable and navigatable by adding some pre-made controls from Yahoo’s API. Add this after the new YMap line:

		// Add zoom control

		map.addZoomLong();

		// Add the pan control

		map.addPanControl();

Set your map to show satellite images, and provide a way for users to change the map type. Add this after the new YMap line:

		// Add map type control

		map.addTypeControl();

		// Default map to satellite (YAHOO_MAP_SAT) -- other opts: YAHOO_MAP_HYB, YAHOO_MAP_REG

		map.setMapType(YAHOO_MAP_SAT);

Yahoo’s API is pretty neat in that it lets you add maps and markers with only the name or address of the place. Without extra effort, Google uses latitude and longitude points, two numbers that refer to a geocode location for a spot on a map.

Yahoo can use these numbers, too. The upside of using points is that, especially with many markers, your maps will load faster.

To change our map to use points, add this line after the new YMap line:

		// Create latitude/longitude point

		var yPoint = new YGeoPoint(37.780764,-122.395592);

Then change the new YMarker and drawZoomAndCenter lines to reference the yPoint variable instead of the city or address:

		// Display the map centered on a geocoded location

		map.drawZoomAndCenter(yPoint, 6);

		// Create a new marker for an address

		var myMarker = new YMarker(yPoint);

Create custom image markers, draw lines on a map, or overlay local search results — it’s all outlined in Yahoo’s documentation.

Further Reading

You can grab all of the code used in this article from Webmonkey’s Code Library: Yahoo Maps API

Since the major search engines have opened up their mapping tools to programmers, geocoding has become an essential step in the process of building many a mashup.

Geocoding is the process of converting human-readable place data — a city name, ZIP code, or address — to latitude and longitude points that can be easily plotted on a map.

Yahoo’s HTTP Geocoder API is easy to use, and its output is easy to incorporate into your applications. This article will describe its features and show some examples of how to access the results.

What You’ll Need

• Basic knowledge of XML
• A Yahoo account
• A Yahoo Application ID. Yahoo will ask for some information from you, but the good news is you get an ID right away.
• To incorporate results with an application, you’ll need some programming skills. I’ll be showing code examples in PHP.

How to Proceed

Step 1: Start a Search

Yahoo provides several options to search for a location, such as specifying an address and city separately.

For example, here’s the address for Wired.com, the home of Webmonkey:

520 3rd Street San Francisco, CA

Breaking this into pieces for the geocoder, we get:

street: 520 3rd Street city: San Francisco state: CA

The HTTP geocoder uses a simple URL. All we have to do is pass these pieces to the geocoder with the correct parameter. Here’s the URL we can use for the Webmonkey address (remember to include your Application ID):

http://local.yahooapis.com/MapsService/V1/geocode?appid=appidhere&street=520+3rd+Street&city=San+Francisco&state=CA

Tip: Sometimes we may be geocoding an address that comes from a user. In that case, we don’t always know where the street name ends and the city name begins. The Yahoo API provides a useful option of passing along everything as one parameter and letting the geocoder figure out which part is which. We’ll do that here, using the location parameter:

http://local.yahooapis.com/MapsService/V1/geocode?appid=appidhere&location=520+3rd+Street+San+Francisco+CA

Both of these URLs return the exact same results. That geocoder is smart!

Step 2: View the Results

When we searched for the Webmonkey offices, we received a whole bunch of XML that looks like this:

<ResultSet xsi:schemaLocation="urn:yahoo:maps http://api.local.yahoo.com/MapsService/V1/GeocodeResponse.xsd">

  <Result precision="address">

    <Latitude>37.780995</Latitude>



    <Longitude>-122.395528</Longitude>

     <Address>520 3rd St</Address>

    <City>San Francisco</City>

    <State>CA</State>



    <Zip>94107-1805</Zip>

    <Country>US</Country>

  </Result>

</ResultSet>

In XML, pieces of data are wrapped in tags that look a lot like HTML. The first thing you may notice is that the geocoder separated the pieces of the address for us. Now we have the address, city, and state, with each piece clearly marked.

The geocoder also told us some things we didn’t know. For one, it changed the street name. We sent 520 3rd Street and it returned 520 3rd St. Rewritten street names could help our applications remain consistent. It’s not a big deal, but it’s nice. We also now know the postal code of the address, and in the ZIP+4 format, no less.

Even more useful than that are the latitude and longitude points. It is those long decimal numbers that we can use to plot on a map or calculate the distance from another location.

To use this data, we need to have a way to load it into an application. Time to break out some PHP.

Step 3: Interpret the Results

We’ll be using PHP for these examples. Most web languages will have some method of interpreting XML, which is all that is necessary to use results from Yahoo’s geocoder.

Since we’re using PHP, we’ll be relying on cUrl and SimpleXML. Each of these libraries is usually installed along with PHP 5. cUrl makes HTTP calls to retrieve content from web pages or services, such as the Yahoo HTTP geocoder. SimpleXML takes XML content and converts it to an object, so that individual elements can easily be picked out from XML.

Create a new PHP file in a web directory with this content to test out the geocoder. I’m calling mine test_geocoder.php:

<?

/*** REMEMBER to use your own Application ID ***/

$appid = "appidhere";

$geourl = "http://local.yahooapis.com/MapsService/V1/geocode?appid=$appid&location=520+3rd+Street+San+Francisco+CA";



// Create cUrl object to grab XML content using $geourl

$c = curl_init();

curl_setopt($c, CURLOPT_URL, $geourl);

curl_setopt($c, CURLOPT_RETURNTRANSFER, 1);

$xmlContent = trim(curl_exec($c));

curl_close($c);



// Create SimpleXML object from XML Content

$xmlObject = simplexml_load_string($xmlContent);



// Print out all of the XML Object

print header("Content-type: text/plain");

print_r($xmlObject);

?>



Now go to your browser and load your test_geocoder.php file. The output should look like this:



SimpleXMLElement Object

(

    [Result] => SimpleXMLElement Object

        (

            [@attributes] => Array

                (

                    [precision] => address

                )

            [Latitude] => 37.780995

            [Longitude] => -122.395528

            [Address] => 520 3rd St

            [City] => San Francisco

            [State] => CA

            [Zip] => 94107-1805

            [Country] => US

        )

)

To access individual elements, such as Latitude, provide the path to the element like this:

print ($xmlObject->Result->Latitude);

Where to Go From Here

Geocoding is the basis for mapping. The Yahoo HTTP geocoder gives you the data you need to plot the points on your map so you can focus on the cooler aspects of your applications. Here are some ideas to help you take the next steps:

• When asking users for their address, you can force them to provide it in a correct format (including the ZIP code) to ensure a good address.

• Pre-process common locations and store the latitude and longitude in a database for easy, quick access.

• If you’re sticking with PHP, Yahoo provides a non-XML method to read in the results. If you add &output=php to the end of the URL to get serialized PHP format, which makes it available as a PHP array. If you run the unserialize function on the content, there’s no need to use SimpleXML. You’ll simply be able to call elements like arrays:

$yarray = ["ResultSet"]["Result"]["Latitude"]

• Visit the Yahoo Maps developer site for more documentation and examples.

Online maps are a popular way to spice up a site. To get the most use out of them, you need data to plot: addresses from a database, location clicks from the user or at least coordinates for the map’s center. With any map, you have to start somewhere.

If you’re low on data, you can fill in the map with local listings, such as those you’d find in the Yellow Pages. You can show coffee shops or pizza joints right along your other data, or even on its own.

In this tutorial I’ll show how to use Yahoo Local to search for nearby businesses and landmarks, then plot those locations on a Yahoo Map using the Ajax API.

What You Need

• Knowledge of JavaScript, CSS and HTML
• A Yahoo account and Yahoo Application ID. Yahoo will ask for some information from you, but the good news is you get an ID right away.
• A little familiarity with Yahoo Maps

Start With a Basic Map

As a starting place for getting Yahoo Local data into your map, we’ll use a basic map from Webmonkey’s introduction to Yahoo Maps. Add this code to a new HTML file:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">

	<head>

		<title>My Yahoo Map</title>



		<script type="text/javascript" src="http://api.maps.yahoo.com/ajaxymap?v=3.8&appid=appidhere"></script>

		<script type="text/javascript">

		function initialize_ymap()

		{

			// Create a map object

			var map = new YMap(document.getElementById('ymap'));

			// Display the map centered on a geocoded location

			map.drawZoomAndCenter("San Francisco", 6);

		}

		</script>

		<style>

		div#ymap {

			width: 500px;

			height: 300px;

		}

		</style>



	</head>

	<body onload="initialize_ymap()">

		<h1>My Yahoo Map</h1>

		<div id="ymap"></div>

	</body>



</html>

Add Your App ID

Before you continue to the next section, you need to add your Yahoo Application ID. Find this call to api.maps.yahoo.com and replace appidhere with your own Application ID:

<script type="text/javascript" src="http://api.maps.yahoo.com/ajaxymap?v=3.8&appid=appidhere"></script>

Once you make the change, save the file. Load it in your browser and you should see a map of San Francisco, like this:

Find Nearby Burritos

Now that your map is loading, it’s time to fill it with local goodness. Do you know something else filled with goodness? Burritos. Because I believe in beating bad analogies to death, in this section I’ll show how you can take your blank map tortilla, add some data cheese, then finish off with rice and beans in the form of markers on the map.

Okay, in plain English: I’ll be showing you how to search Yahoo Local, in this case for “burritos,” and plotting the results on our Yahoo Map. Here’s the finished product I’ll show you how to create:

We’ll start with the blank map of San Francisco from the previous section. The first thing we need to do is add a button, which will be used to activate the local search. Place this HTML below the “ymap” div:

	<form>

		<input type="submit" value="Search for burritos" onclick="javascript:doLocalSearch('burritos'); return false;" />

	</form>

Notice that we have a form with a single submit button. When the button is clicked, it calls a JavaScript function doLocalSearch and passes the string ‘burritos’ to it. We’ll need to make that function next.

First a note about the return false line that comes at the end of the bit of JavaScript inside the submit button. That tells the browser not to actually submit the form to the server. JavaScript works in the browser without submitting a form.

Performing the Search

Now that we can call the search with the form button, we need to write the code for the search. Add this function just above the </script> tag near the top of your document:

		function doLocalSearch(keyword)

		{

			map.searchLocal(map.getCenterLatLon(), keyword, 1, 5);

			YEvent.Capture(map, EventsList.onEndLocalSearch, addMarkers);

		}

There are two parts to this new function. The first passes four things off to Yahoo’s searchLocal function:

1. The center of our map (a YGeoPoint object)
2. The keyword we’re searching for, burritos
3. The radius of search results, in miles
4. The number of search results, 1-20.

Since the search uses Ajax, the results are asynchronous. Unlike many functions that return results immediately, there is a delay for local search. It’s sort of like placing an order at a restaurant. Say you want a burrito, so you let the cashier know. Unless you’re at the airport, you don’t get your burrito right away. Instead, you have to wait for your order to come up. Sometimes you’re even given a number, so you’ll know immediately that your food is ready.

The second line of our new function is where we tell the browser that we care about doing something with the results as soon as they come back. This is often referred to as a callback function. In Yahoo Maps, we enlist the callback function by “capturing” an event with the YEvent.Capture function. In this case, we told the browser to send the results of the search to the addMarkers function.

Placing the Markers

The results of our local search are being sent to the addMarkers function, so we need to create that function. Add this just above the </script> tag near the top of your document (just below the closing curly brace from the previous function):

		function addMarkers(result)

		{

			if (result.Data)

			{

				var places = result.Data.ITEMS;

				for (i=0; i < places.length; i++)

				{

					var thisplace = places[i];

					var marker = new YMarker(new YGeoPoint(thisplace.LATITUDE, thisplace.LONGITUDE));

					marker.addAutoExpand(thisplace.TITLE + '<br />' + thisplace.ADDRESS);

					map.addOverlay(marker);

				}

			}

		}

There are just a few lines in here that do the actual work of adding the marker to the page. The rest ensures that there was data that returned from the search, and iterates through those results.

The places variable is one I created to take the array of results objects from the search. Each object contains the data about the results, such as latitude, longitude, place name (title), and address.

Now that we have received results from a search we hard-coded, let’s look at how we can accept input and let users search our map.

Accept User Input

With the map we created in the previous section, we can search for burritos in San Francisco. What if someone wanted to search for something else somewhere else? Let’s add some ways to accept user input and use it in a local search.

Here’s the example we’ll be working towards:

We can start with the version in the previous section, the static search for burritos. Instead of the single button to start the search, we need a couple input boxes and a new button. In fact, you can scrap the form in the previous section and replace it with this new one:

	<form>

		Search for: <input type="text" name="kw" />

		in <input type="text" name="loc" value="San Francisco, CA" />



		<input type="submit" value="Search Map" onclick="javascript:searchLocation(document.forms[0].loc.value, document.forms[0].kw.value); return false;" />

	</form>

Instead of calling the doLocalSearch function directly, our new button calls searchLocation, a new function we’ll need to create. It passes the two values inside the input boxes to the function, so our new function needs to accept the name of a place and the keyword we’re searching.

Add the searchLocation function to the file, just above the </script> line:

		function searchLocation(placename, keyword)

		{

			map.drawZoomAndCenter(placename, 6);

			YEvent.Capture(map, EventsList.onEndGeoCode, function()

			{

				doLocalSearch(keyword);

			});

		}

Much of the code in this function will look similar to what we wrote in previous sections. We’ve used the drawZoomAndCenter call since the first empty map. Before, we set the map on San Francisco. Now we’re zooming and centering into whatever place the user types in.

YEvent.Capture may also look familiar, from our doLocalSearch function. There we were capturing the onEndLocalSearch event. Here, we need to capture onEndGeoCode event. Why? Because whenever we look up a city (such as with drawZoomAndCenter), Yahoo needs to make an Ajax call to its geocoder. Since the result isn’t available immediately, we need to “place an order” so that something can happen as soon the geocoding is done.

When the geocoding is done, we want to perform the local search. In order to get the keyword passed correctly, we need to wrap the call in an anonymous function. It’s a little confusing if you haven’t seen it before, but that’s a common programming pattern with JavaScript callbacks.

Calling Out The Callbacks

Speaking of callbacks, there are two that go on every time the user searches the map in this example.

Callback one: After calling drawZoomAndCenter, which needs to geocode the location. When this is complete, the first callback initiates the search function.

Callback two: After calling searchLocal, which needs to perform the local search. When this is complete, the second callback plots the markers on the page.

Where to go From Here

You now have the basics down for plotting local data on a Yahoo Map. There are more directions to go than there are results for sushi in San Francisco.

Mashup Direction

What data do you have about your city? In addition to city locations, Yahoo Maps can look up specific addresses and landmarks. Armed with just park names, for example, you could show pet stores near parks.

To see this in action, just return to the search example in the previous section and search for “pet stores” and use “Buena Vista Park San Francisco, CA” as the location.

Academic Direction

Though I was mainly showing you how to use Yahoo Maps local search, you also received an introduction into more advanced JavaScript with callbacks. Now is the time to keep moving forward with your education by testing yourself. Can you edit the static search example to load automatically, eliminating the need for the search button?

Hint: you’ll need to capture an event inside the initialize_maps function.

Location Direction

Use some JavaScript to grab the user’s location as a starting point. Luckily, we have a JavaScript geolocation tutorial. Go for it!

After not responding to inquires, Craigslist CEO Jim Buckmaster eventually posted a terse message on the company’s blog saying that Yahoo Pipes mashups were using “a disproportionate amount of server/bandwidth resources.”Now it would seem that Craigslist has ended its ban of Yahoo Pipes, but for developers we imagine the damage has been done. For its part, the startup Flippity, which was the first to notice its Yahoo Pipe had been blocked, says it has moved on to friendlier sources, rewriting Flippity to use the eBay API.

It wasn’t the first time Craigslist has shutdown outsiders trying to improve on the site’s famously antiquated tools — the site previous blocked ListPic, a tool designed to help Craigslist users browse by images, and a tool to search all the Craigslist sites at once.

As we said in our initial report on this debacle, if you’re a developer looking for data to use in a mashup, think twice about Craigslist. The site has a wealth of data, but it guards it jealously and has no qualms about blocking even major players like Yahoo.

See Also:

• Craigslist to Developers: Look Elsewhere For Mashup Data
• Craigslist Blocks ListPic, Considers Adding Visual Browsing
• Craigslist Users Crack Down on IPhone Unlockers
• Why Craigslist Is Such a Mess