Jon Udell

In the last few days I’ve received useful feedback on the elmcity project from an old friend (whom I’ve never met in person), and a new friend (whom I have). The old friend is Jake Ochs, an accomplished technologist who, like John Faughnan, was a valued online correspondent back in the BYTE era. The new friend is Mykel Nahorniak whom I met at Transparency Camp 2009. Mykel is cofounder of the social event listing platform Localist, and has been curating the elmcity project’s Baltimore hub.

Both Mykel and Jake are intrigued by the elmcity project, but are skeptical about the approach and likely outcome. Here’s Mykel, quoted with permission from email:

It’s already a challenge to convince a local venue that they need a Web site, let alone a Twitter presence, let alone an iCal feed. I think the return a lot of businesses are seeing from social media has helped motivate these local businesses, though.

Really, it’s about giving them a tangible return on their efforts. What incentive do these businesses have to curate their calendars in a specific format when, realistically, it’s not going to equal the return they’d get on, say, curating a Twitter account. That’s what needs to be determined on our end. Specific examples that would give a business no excuse to say “no.”

And here’s Jake, writing on his blog:

I can’t help but feel that Jon is missing the bigger picture. Well, he’s “getting” the bigger picture -that calendar-ish data will probably be a “big” thing. His recombinant approach to existing tools and ideas, though, probably isn’t it. The ability to create such mashups is a hallmark of the “Web 2.0″ era and Jon, once again, displays his masterful ability to create something powerful from simple, existing substrates. Historically, it’s been the entrepreneurs that somehow grasp a simple concept regarding human behavior -or an evolved human behavior- and bring that concept to bear on a traditionally complex problem that win out in the marketplace. I don’t have any idea what that concept will look like, so don’t ask, but I highly doubt that it will contain the recombinant DNA of existing solutions when it debuts.

Mind you, I said when it debuts. After the magical mystery viral calendar tool of the future gains traction, a clamor will be made for an API that will draw the tool into the prevailing social tapestry. (Facebook and Twitter today, who knows what tomorrow?) I wonder, though, will iCal make it into that mix when the day comes or is iCal’s fundamentally one-way nature not be up to the task of the wonder collaboration of tomorrow?

Lately I’ve been pitching my project to folks who don’t dwell the geek ghetto. And I’ve been telling plain stories that seem to resonate — at least in the old-fashioned way, one-on-one and face-to-face. Here’s one of them:

The Monday night chess club

The chess club in Keene gets together on Monday nights at 6:30. They used to gather at the Best Western hotel. Then they switched to the E.F. Lane hotel. For at least a year after the move, the Keene Sentinel’s community bulletin board continued to list the event at the Best Western. If the chess club had published its own authoritative feed, and communicated the address of that feed to the Sentinel — instead of transmitting a copy of soon-to-be-stale data — there might be a few more chess players showing up on Monday nights.

Why should businesses want to publish information in a syndication-friendly format? Because, like all of us, they want to be the authoritative source for information about themselves. And because they don’t want to have to remember, and refresh, every touchpoint to which they have transmitted data by value rather than by reference.

Is iCal’s “fundamentally one-way nature up to the task of the wonder collaboration of tomorrow?” True, iCalendar is a decade-old standard that has never rocked the Internet, and maybe never will. But one-way? That limitation exists only in the eye of the beholder. The chess club can publish a calendar that the Keene Sentinel can subscribe to.¹ The Sentinel, in turn, can aggregate those subscriptions into a combined calendar that members of the chess club — and others in the community — can subscribe to. Those other individuals and organizations can also be publishers and subscribers. The system I am building is not really about iCalendar. It’s about the principles, patterns, and practices that make pub/sub ecosystems such fertile ground for communication and collaboration.

Of coure Mykel and Jake are right, and I value their skepticism. I haven’t yet figured out how to make the chess club anecdote go viral, or tell it in a way that business can’t say no to. But I’m warming to the task, and I’m starting to connect with environmental activists, librarians, civic-minded geeks, and colleagues who can help me advance the story.

¹ The infrastructure that I’m building is dedicated to this purpose. If you’re a newspaper, a library, a chamber of commerce, or some other natural attention hub in your community, I want to help you syndicate calendars through your hub.

My guest for this week’s ITConversations show is Eric Rodenbeck, the creative director of Stamen Design. His 2008 ETech talk wowed me, and inspired this meditation on time, space, and data.

Near the end of this interview, as we were discussing the tension between graphic design and engineering sensibilities, Eric said:

When it was just me, working as a designer, I was having fun, but I wasn’t able to be effective. And when Mike [Michal Migurski, Stamen's technical architect] was doing tech work for PR companies, it wasn’t all that great. But when we came together, suddenly we had something.

Even in a design studio that we control, though, it’s hard to address that split between the lush sexy design versus the tech. Versus! Why is it always versus?

Exactly. Eric also notes another false dichotomy: cool versus useful. We violently agreed that coolness and utility are two sides of the same coin.

For that reason, it would fun to also talk to Eric’s technical partner Mike Magurski. In this interview, we learn that he created the original API for Oakland Crimespotting by scraping this police site, which (still) produces map images like this:

Mike’s task was to identify and locate incidents by writing code that would scan those images for “purple bras, boxing gloves, and hypodermic needles.” Which is funny, but also sad. So many more usefully cool things will be able to happen when publishers of data finally start to learn how to publish data.

In the first installment of this elmcity+azure series my plan was to build an Azure-based calendar aggregator using IronPython. That turned out not to be possible at the time, because IronPython couldn’t run at full strength in Azure’s medium-trust environment. So I switched to C#, and have spent the past few months working in that language.

It’s been a long while since I’ve worked intensively in a compiled and statically-typed language. But I love being contrarian. At a time when low ceremony languages are surging in popularity, I’m revisiting the realm of high ceremony. It’s been an enjoyable challenge, I’ve gotten good results, and it’s given me a chance to reflect in a more balanced way on the “ceremony vs. essence” dialogue.

Meanwhile, Azure has moved forward. It now provides a full-trust environment. That means you can run PHP, which is interesting to a lot of folks, but it also means you can run IronPython, which is interesting to me.

In this entry I’ll show you how I’m starting to integrate IronPython in the two main components of my Azure project: the web role that provides the (currently minimal) user interface, and the worker role that does calendar aggregation.

Using IronPython in an ASP.NET MVC Azure web role

The elmcity service writes a lot of log data to an Azure table. I’ll want curators to be able to query the slices of that log that pertain to the cities whose calendars they are curating. For Providence, RI, which uses the elmcity (and delicious) id mashablecity, the URLs for those queries might look something like this:

/services/mashablecity/log_info (log entries of type “info”)

/services/mashablecity/log_exception (log entries of type “exception”)

Here’s an URL route to carve out a namespace shaped like that:

routes.MapRoute(
 "services",
 "services/{id}/{what}",
 new { controller="LogServices", action="QueryLog", id="", what="" },
 );

Here’s a simplified version of the corresponding LogServicesController.cs:

[HandleError]
public class ServicesController : Controller
  {
  public ActionResult QueryLog(string id, string what)
    {
    return new ObjectResult(id, what);
    }
  }

public class ObjectResult: ActionResult
  {
  string id;
  string what;

  public ObjectResult( string id, string what)
    {
    this.id = id;
    this.what = what;
    }

  public override void ExecuteResult(ControllerContext context)
    {
    switch (this.what)
      {
      case "log_info":
         var script_url = make_script_url(this.id, this.what);
         var args = new List() { this.id, this.what };
         var result = new ContentResult
          {
          ContentType = "text/plain",
          Content = Utils.run_ironpython(script_url, args),
          ContentEncoding = UTF8
          };
        result.ExecuteResult(context);
        break;
      case  "log_exception":
      // etc
      }
    }

This fragment takes in the URL parameters, forms the URL that IronPython will use to fetch the script that it runs, packages the parameters into a list, calls a method to invoke IronPython, and dumps the script’s output into the outgoing HTTP response.

Here’s the code to invoke IronPython:

public static ScriptEngine python = Python.CreateEngine();

public static string run_ironpython(string script_url, List args)
  {
  var ipy_args = new IronPython.Runtime.List();
  foreach (var item in args)
    ipy_args.Add(item);
  var result = "";
  try
    {
    var s = Utils.FetchUrl(script_url).data_as_string;
    var source = python.CreateScriptSourceFromString(s,
      SourceCodeKind.Statements);
    var scope = python.CreateScope();
    var sys = python.GetSysModule();
    sys.SetVariable("argv", args);
    source.Execute(scope);
    result = scope.GetVariable("result").ToString();
    }
  catch (Exception e)
    {
    result = e.Message.ToString() + e.StackTrace.ToString();
    }
  return result;
  }

Whatever the script deposits in a Python variable called result winds up as the content of the HTTP response.

Using IronPython in an Azure worker role

Until recently I’ve been running some IronPython maintenance scripts from a standalone client machine. Now I’ve pushed them to the cloud. Here’s the scheduler that sets a timer to invoke a handler on a periodic basis:

public static void scheduler (ElapsedEventHandler handler, int minutes)
  {
  var timer = new Timer();
  timer.Elapsed += handler;
  timer.AutoReset = true;
  timer.Interval = 1000 * 60 * minutes;
  timer.Start();
  }

And here’s the handler:

public static void IronPythonHandler(object o, ElapsedEventArgs e)
  {
  try
    {
    var s = Utils.FetchUrl(Configurator.ADMIN_SCRIPT).data_as_string;
    var source = python.CreateScriptSourceFromString(s,
       SourceCodeKind.Statements);
    var scope = python.CreateScope();
    source.Execute(scope);
    ts.write_log_message("info", "IronPythonHandler");
    }
  catch (Exception ex)
    {
    ts.write_log_message("exception", "IronPythonHandler",
      ex.Message.ToString() + ex.StackTrace.ToString());
    }
  }

Best of both worlds

I’m still sorting out how I want to combine these two worlds, and I’m having a blast doing it. Could I have written the whole system in IronPython, had the option been available when I started? Undoubtedly. But high ceremony, coupled with a sophisticated tool like Visual Studio, has its charms. So does low ceremony and emacs. Using both together, and leveraging all their strengths, is really productive. And it’s loads of fun too.

On this week’s Innovators show I talked with Philip Rosedale about the ways in which Second Life, the virtual world, and Linden Lab, the real company, are laboratories for experimenting with social, economic, and organizational principles.

As I was editing the show, I sent some of the notable quotes to Twitter:

On transparency and central control:

As communication technology makes transparency cheaper, the need for central control drops.

On why Second Life works well for group meetings:

We spatialize the audio so you hear where everyone’s voice is coming from.

On distributed development:

We don’t specialize roles by geographic location.

The Linden Lab experience with decentralization, transparency, and fluid team formation echoes what we’ve heard from Andy Singleton. Philip Rosedale adds this thoughtful observation:

There’s a tension between people’s desire to work together in a cohesive, familial kind of unit, and the organization’s need to have people work together in the way that’s optimal for projects, where you want to attack a problem, work together, disband, and then reform to work with different people on the next problem.

Even if you will never fly an avatar around in Second Life, or use the in-world construction kit to build a 3D object, it’s fascinating to hear about the organizational strategies that Philip Rosedale believes make it all possible.

One of the core values of the elmcity project is respect for authoritative sources. Every event that syndicates into the system should have an URL that points back to that authoritative source.

Often, when the source is an iCalendar feed, some or all of the events leave the URL field empty. That’s why I encourage curators to provide a default URL for the whole calendar. For example, the newest city to join the hub is Falls Church, VA. One of the feeds that curator Dave Witzel created (using FuseCal) is for the Dogfish Head Ale House. As you can see in Dave’s metadata catalog, the bookmark he created for its calendar points to the URL of a FuseCal-created iCalendar feed. And one of the tags on that bookmark is:

url=http://www.dogfishalehouse.com/component/option,com_jcalpro/Itemid,70/

The url=http://… tag is how a curator tells the elmcity aggregator: “This is the default URL I want you to use, for any events in this feed that do not individually specify a URL.”

In this example, Dave has pointed the url= tag at the events page at the ale house, which is also the URL that he fed to FuseCal in order to get it to produce the iCalendar feed.

Let’s look at another example: the Thomas Jefferson Public School. Here, Google Calendar is the source of the iCalendar feed. And Dave has bookmarked the web page in which the school has embedded that calendar.

One place this default URL shows up is in the reference HTML view of the Falls Church calendar. On June 3, we see:

Wed 09:15 AM
7th Gr. Jazz Band Concert at TJ
(Thomas Jefferson Public School Calendar)

The link points back to the source. So far, so good.

Now, these source URLs should also propagate to any downstream services that syndicate from the hub. And in each of the outbound formats — XML, JSON, and ICS — they do. Here’s how that originally worked:

<event>
<title>7th Gr. Jazz Band Concert at TJ</title>
<url>http://www.fccps.org/calendar/tj.htm</url>
<source>Thomas Jefferson Public School Calendar</source>
<dtstart>2009-06-03T09:15:00</dtstart>
</event>

{
"title":"7th Gr. Jazz Band Concert at TJ",
"url":"http://www.fccps.org/calendar/tj.htm",
"source":"Thomas Jefferson Public School Calendar",
"dtstart":"\/Date(1244020500000+0000)\/"
}

BEGIN:VEVENT
DESCRIPTION:For more information regarding this or any other event please
 contact the MEH Main Office at 703-720-5700.
DTSTART:20090603T091500
URL:http://www.fccps.org/calendar/tj.htm
SUMMARY:7th Gr. Jazz Band Concert at TJ
UID:633778966573833700@elmcity.cloudapp.net
END:VEVENT

But this perfectly sensible mapping fails for iCalendar. It turns out that many popular calendar programs don’t surface the URL field in an iCalendar VEVENT. Apple’s iCal does, but Outlook, Google Calendar, and Live Calendar don’t.

What to do? Until somebody helps me find a better solution, here’s mine:

BEGIN:VEVENT
DESCRIPTION:For more information regarding this or any other event please
 contact the MEH Main Office at 703-720-5700.
DTSTART:20090603T091500
URL:http://www.fccps.org/calendar/tj.htm
LOCATION:http://www.fccps.org/calendar/tj.htm
SUMMARY:7th Gr. Jazz Band Concert at TJ
UID:633778966573833700@elmcity.cloudapp.net
END:VEVENT

In other words I’ve added a LOCATION field, which in this case was (not atypically) empty in the source calendar, and I’ve filled it with the same value that’s in the URL field.

The RFC2445 spec defines LOCATION like so:

Property Name: LOCATION

Purpose: The property defines the intended venue for the activity
defined by a calendar component.

And it gives this example:

LOCATION:Conference Room - F123, Bldg. 002

I’m stretching LOCATION to mean “virtual location of the source of information about the event” instead of “physical location of the venue for the event.”

Given that mapping, here’s how the 7th Gr. Jazz Band Concert shows up in various apps:

Notice how iCal renders both URLs — the one in the LOCATION field, and the one in the URL field — as clickable links. I wish the other programs also made an URL in the LOCATION field clickable. Reporting the source URL is better than not doing so. But the extra friction involved in copying the URL and pasting it into a browser will tend to prevent that from happening.

Given all this, I’d love to hear suggestions for a better approach. One thing to keep in mind is that I’m trying to strike a balance between two conflicting goals. I want to make the downstream syndication formats useful. But not too useful, because I also want to build a connected ecosystem that helps all the upstream sources — including Eventful, Upcoming, and growing populations of iCalendar feeds — thrive. The elmcity service doesn’t aim to be a container of other people’s stuff. It aims to be a router, or actually a whole bunch of routers, each of which helps bootstrap a connected ecosystem in which people become the authoritatives sources of their own information, and in which they learn to syndicate that information to one another.

When I shared my strategy for harvesting Keene’s softball schedules, the Little League baseball schedules hadn’t yet been published online. Now I see why. It took the folks at the Keene Cal Ripken Baseball Association (KCRBA) a while to get them written down in Excel, and then produced and uploaded as a set of web pages like this one. We’re two weeks into the season, and those pages are finally up, but not — sadly yet typically — in a useful calendar format that can mesh with other calendars.

Over the weekend, @llama_grande tweeted:

Dilbert creator on calendars @judell may enjoy http://bit.ly/2lKTlb

I set it aside thinking it was a cartoon I’d enjoy later. In fact, it’s a cogent essay by Scott Adams that nicely captures part of my motivation for doing the elmcity project. From the essay:

I think the family calendar is the organizing principle into which all external information should flow. I want the kids’ school schedules for sports and plays and even lunch choices to automatically flow into the home calendar. And when I want to decide what to do on the weekend, I want to click on the date for next Saturday and have all the relevant choices of plays, movies, and events pop up.

…

I think the biggest software revolution of the future is that the calendar will be the organizing filter for most of the information flowing into your life. You think you are bombarded with too much information every day, but in reality it is just the timing of the information that is wrong. Once the calendar becomes the organizing paradigm and filter, it won’t seem as if there is so much.

Meanwhile, here’s the reality for Kevin Curry:

checking a PDF 4 school lunch is daily routine 4 me

That’s how it is for most of us, most of the time. But it needn’t be.

Consider the Little League example. If the keystrokes that were poured into Excel to create those web pages had been directed into almost any calendar program, the schedules could have been published both as HTML for online viewing and as iCalendar for syndication to other calendars.

Happily, FuseCal can set things straight. It handily created calendars for each of the 27 teams. I collected the feed URLs and wrote a throwaway script to spray them into Delicious. In a few hours, when the elmcity service scans that account again, all the games will be included in the combined calendar. And anybody who wants what Scott Adams wants — to have the kids’ sports events flow into a home calendar — can have it.

This is wrong and backwards, of course. And while the creator of Dilbert would probably enjoy the absurdity of my solution, I’m glad to know he’s also thinking about the right way to move forward.

Like all University of Michigan alumni who were in the school of Literature, Science, and the Arts, I receive the quarterly LSA Magazine. This spring I’m actually in the magazine. For an issue on the theme of surviving in tough economic times, I contributed the back-page editorial which the editors entitled Can the Noosphere Save Us? The themes will be familiar to readers who know me: personal publishing, knowledge sharing, online collaboration. It was a treat to be asked to write about these topics for a diverse audience of UM alumni.

I would have subtitled the piece: “Ask not what the web can do for you. Instead ask what you can do with the web.” It features three people I have interviewed for my Innovators show, all of whom exemplify that dictum. They are Jean-Claude Bradley, Susan Gerhart, and John Leeke.

In order to make things easier for Susan Gerhart, who’ll be using a screen reader, I’m supplementing the PDF version posted at the magazine’s site with a plain HTML version.

I’ve collected the original URLs of articles and columns I wrote for InfoWorld at http://jonudell.net/InfoWorldArticles.html. Almost all are now live again, albeit redirected, after having been scrambled in the recent site reorg.

Still missing in action is my blog from that era. I have the whole thing in a clean XHTML archive that I can easily republish to my own namespace. However, since the articles and the blog essays cross-reference one another, I’m still hoping that the blog will reappear at its old namespace — underneath http://weblog.infoworld.com/udell — so that the cross-referencing will still work in both directions.

If the blog doesn’t resurface at its original namespace soon, I’ll go ahead and migrate it to mine.

When Phil Windley pointed me to Jeannette Wing’s manifesto on computational thinking, she had me at hello. The intellectual tools of computer science, she argues — including the ability to work at multiple levels of abstraction, to automate repetitive processes, and to make and use state machines — are really “a universally applicable attitude and skill set that everyone, not just computer scientists, would be eager to learn and use.”

In 2007 I interviewed Jeannette Wing for my Innovators show. Since then she has moved from Carnegie Mellon to the National Science Foundation, where she is — among other activities — working to define, promote, and bootstrap the teaching of computational thinking.

On this week’s show I spoke with Joan Peckman, a University of Rhode Island professor of computer science who’s on leave to work with the NSF on that mission.

Toward the end of the podcast, she relates this delightful anecdote:

At the first CSTB workshop on computational thinking for everyone, someone from the University of Indiana showed a video on how he was teaching science. We all looked at it and thought: “But it’s also computational thinking!”

In the course of teaching elementary school students about honey bees, he took them out on the playground and asked them to act out what the honey bees did: leaving the hive, finding the pollen, giving directions to the other bees. Then he brought them back into the classroom, went to a whiteboard, and engaged them in activites that I would identify as modeling, debugging, and drawing finite state diagrams. He didn’t call them that, but that’s what they were.

Yes he was teaching them science, but the way he was analyzing the subject, and engaging them in analysis, clearly involved a set of computational constructs.

In my own recent writing and speaking, I’ve suggested that feed syndication and lightweight service composition are aspects of computational thinking that we ought to formulate as basic principles and teach in middle school or even grade school.

We tried, but failed, to come up with a phrase that embellishes computational thinking with connotations of flow, orchestration, and connectedness. Syndication-oriented architecture. gets partway there, but will never fly in the mainstream. Maybe connected thinking? But you don’t want to leave out what computational connotes. Perhaps computational and connected thinking? Nah, too wordy. I’d love to hear suggestions for a tagline that concisely captures both aspects.

For more background on computational thinking, here are Joan Peckham’s show notes:

The CSTB (Computer Science and Telecommunications Board) of the National Academy of Sciences is holding Computational Thinking for Everyone: A Workshop Series in 2009. Monitor their website for developments and reports: http://sites.nationalacademies.org/cstb/CurrentProjects/CSTB_043590

Previously awarded CPATH projects (only some of which address computational thinking directly … although the current solicitation requires it):

2007 award portfolio – http://www.nsf.gov/cise/funding/CPATH2007awardsfinal.pdf

2008 award portfolio – http://www.nsf.gov/cise/funding/CPATH2008awardsfinal.pdf

Computer Science Unplugged (http://csunplugged.org/) site has a wealth of classroom ready activities.

Rebooting Computing Summit in January 2009 (http://www.rebootingcomputing.org/). Several working groups emerged from this meeting. Some of the groups were concerned with computing education, and in defining and better communicating computing to others.

The Computer Science Teachers Association (CSTA) has a web repository with K-12 computer science teaching and learning materials: http://csta.acm.org/WebRepository/WebRepository.html

The Carnegie Mellon University Center for Computational Thinking site has materials and resources: http://www.cs.cmu.edu/~CompThink/. [ed: Sponsored, I'm pleased to say, by Microsoft Research.]

A friend lent me the antique tool shown in these photos. I’d been thinking about renting a rototiller to prepare three garden beds, but this thing tore through them way more easily than I could have done with a shovel, rake, hoe, or garden weasel. It’s really good at clawing up major weeds and clumps of sod.

Our question: What is this thing called? I looked through the catalog at antiquefarmtools.info. It’s full of beet shovels, muck rakes, turnip grubbers, and barley forks, but I didn’t find anything that looks like this artfully blacksmithed and wickedly effective tool.

One of the ironies I’ve uncovered while working on the elmcity project is that many folks are publishing iCalendar feeds without even realizing it. I’ve found a number of Drupal websites, for example, that present calendars as web pages without offering the corresponding ICS links. But the biggest source of implicit iCalendar feeds is Google Calendar.

Here’s a typical example of Google Calendar embedded in a web page: Commmunity Gardens of Huntington WV. Curators for the elmcity project have figured out how to extract the ICS URL from this kind of page:

OK, it’s not that bad. As Bill Rawlinson points out here, there’s a civilian (non-geek) alternative:

1. Click the Google Calendar button

2. Add the calendar to your Google Calendar application — assuming you’re signed up to use it

3. Click Settings -> Calendars

4. Click the calendar you just added

5. Right-click its ICAL button and capture the link

But either method is cumbersome. So I’ve added a service that streamlines discovery of the iCalendar feed’s URL. The easiest way to use that service is to go here and install the gcal2ics bookmarklet. When clicked from a page with an embedded Google Calendar, like the Huntington Community Gardens calendar, it yields this:

URL of web page with embedded Google Calendar:

http://www.huntingtoncommunitygardens.com/8.html

ICS (iCalendar) URL for that calendar:

http://www.google.com/calendar/ical/communitygardenshunt%40gmail.com/public/basic.ics

Why would a service like Drupal or Google Calendar ever publish an HTML rendering of a calendar without also offering the corresponding feed URL directly? Because, I guess, we have all failed to teach people what feed URLs are, and show them why they matter.

For a while now, I’ve been wanting to connect the wealth of musical performance schedules on MySpace to the elmcity calendar project. For example, here’s the MySpace page for Jatoba, three young guys from Brattleboro whose eclectic, high-energy, acoustic string instrumentals and vocals have inspired me the couple of times I’ve seen them around town.

As is typical, there’s a calendar on their page. So I should be able to plug its iCalendar feed — and more specifically, the Keene-based performances in that feed — into the Keene calendar hub. But MySpace doesn’t export iCalendar feeds. What to do?

Today I hit on a solution. Here’s the recipe:

1. Visit a band’s MySpace page:

2. Click the (view all) link on the calendar to arrive here:

3. Copy the URL of the (view all) page, paste it into FuseCal, arrive here:

4. Filter the list, arrive here:

5. Click the Add to my calendar bar, arrive here:

6. Click Other Calendar, arrive here:

That’s your iCalendar feed URL in the box. In this example, the feed contains just two entries for Jatoba’s two upcoming Keene performances. Here’s the first:

BEGIN:VCALENDAR
VERSION:2.0
PRODID:-//Public Display Inc//FuseCal Software//EN
BEGIN:VEVENT
URL:http://collect.myspace.com/index.cfm?fuseaction=
 bandprofile.listAllShows&friendid=273136461&n=JATOBA
SUMMARY:VENDETTA  \, Keene\, New Hampshire  - free
DTSTART:20090507T213000
END:VEVENT

You can subscribe to that URL directly in your calendar program. If you’re an elmcity project curator, you’ll want to take one extra step to syndicate this calendar into your hub:

7. Bookmark the FuseCal URL.

Now Jatoba’s Keene performances will appear on the elmcity calendar, courtesy of FuseCal and Delicious. And neither MySpace nor Jatoba had to get involved. The web’s funny that way.