Kai Lautaportti, Chris Calloway, Josh Livni, Sune Woeller, and Alessandro Amici are sprinting on PrimaGIS for Plone 3.0 in Naples today while Alex Mandel and I tele-sprint from California and Colorado. Goodbye old map interface, hello OpenLayers.

I was wondering about these "Sword" entries in my Hammock collection, and it seems they are associated with the UKOLN Simple Web-service Offering Repository Deposit (SWORD) project. The 1.0 version of the SWORD AtomPub profile was released today. Librarians, more and more, are getting the value of web-style services and resource-orientation.

Congratulations to Al Gore and the UN IPCC. Bill Gray, my tropical meteorology professor (who has on the record compared Gore to Hitler), is certainly annoyed today, and heads will be exploding in the nuttier wings of the blogosphere (like this: pop!). It's hard not to reflect on where we might be today if the 2000 election hadn't been stolen.

When people start coming out of the woodwork to take credit. Stats from a recent Directions article on GeoJSON:

Number of times an author of the GeoJSON draft is mentioned by name: 0

Number of posts to the working group mailing list or wiki by anyone from Safe Software, the company prominently linked in the article to GeoJSON: 0

Frankly, the thought of people storing data in the GeoJSON format on their filesystems, or emailing GeoJSON attachments to their customers, scares me. That's what GML is for. GeoJSON is just a way to encode simple geographic data structures on the wire between web clients and web servers.

It pains me to see novices taught poor Python programming practices, and so I can't resist making a few corrections to this post. Processing and marking up data into KML is a simple task that can be used to teach better practices. Here are 3 easy ones:

• abstract access to file-like resources with urllib;

• iterators and generators;

• XML templating with Genshi;

Here is a script that reads in a FIRMS text file and writes out a KML document named fires.kml:

import urllib2

from genshi.template import TemplateLoader

def collect_latest_fires():
    f = urllib2.urlopen('file:N_America.A2007275.txt')
    for line in f:
        fields = line.split(',')
        lat = fields[0]
        long = fields[1]
        confidence = fields[8]
        coords = '%s, %s' % (long, lat)
        yield {
            'name': 'Wildland Fire at %s' % coords,
            'description': 'Confidence: %s' % confidence,
            'coordinates': coords
            }

loader = TemplateLoader(['.'])
template = loader.load('template.kml')
stream = template.generate(collection=collect_latest_fires())

f = open('fires.kml', 'w')
f.write(stream.render())

The input data file is hard coded in the collect_latest_fires function, but it's trivial to calculate the name of the latest data (A well-managed site would probably call it current.txt). You can get the input data via FTP or HTTP by using the proper URI scheme:

>>> f = urllib2.urlopen('ftp://ftp.example.org/current.txt')

By virtue of the yield statement, collect_latest_fires is a generator, an iterator that keeps track of its own state and computes values on demand. Iterators are a key element in Python programming. Note that Python file-like objects are themselves iterators. If you needed an actual list of fires, you could create it from the generator like so:

>>> collection = list(collect_latest_fires())

This generator function is the bulk of the script. The remainder simply loads a Genshi template, generates an output markup stream using an iterator over the latest collection of fires, and then renders and writes the stream.

Here is the KML template:

<?xml version="1.0" encoding="utf-8"?>
<kml
  xmlns="http://earth.google.com/kml/2.1"
  xmlns:py="http://genshi.edgewall.org/"
  >
  <Folder>
    <Style id="fireIcon">
      <IconStyle>
        <Icon>
          <href>http://maps.google.com/mapfiles/kml/pal3/icon38.png</href>
        </Icon>
      </IconStyle>
    </Style>
    <Placemark py:for="item in collection">
      <name py:content="item['name']">NAME</name>
      <styleUrl>#fireIcon</styleUrl>
      <description py:content="item['description']">
        DESCRIPTION
      </description>
      <Point>
        <coordinates py:content="item['coordinates']">
          LONG,LAT
        </coordinates>
      </Point>
    </Placemark>
  </Folder>
</kml>

Use well-engineered templating systems and/or serializers to create KML. Do not concatenate hand-coded strings of angle brackets. Templates like the one above can be run through your favorite XML tools to insure that they are well-formed. You can't do that with your Python code. A good templating system also handles the encoding for you.

Finally, since the FIRMS source data is changing only once a day, you should be running the script above no more than once a day. Don't use it as a CGI. Transform the source data to KML and write it to a file under your web server. Configure your web server to provide the application/vnd.google-earth.kml+xml content type for the KML and also set the HTTP Expires header to the modification time of the file plus 24 hours. That's a recipe that scales.

Open source software has a big role to play in sustainable development. In the closing session of last month's FOSS4G conference, the committee that will be hosting next year's conference in Capetown (congratulations!) reminded us that the South African government is committed to open source software. Getting locked into buying proprietary seed is not the way to sustainable agriculture, and getting locked into buying boxed proprietary software is not the way to sustainable digital enterprises. Where is the sustainability media on the subject of open source?

James Fee looks at Christopher Schmidt's WPSServer and writes:

Now this of course won't replace the complex analysis that ArcGIS Desktop or even ArcGIS Server can accomplish, but why not use such lightweight tools for lightweight needs?

A RESTful web geo-processor that provides a DSL for describing complex processes and analyses (my preference would be for Javascript ala CouchDB, and I'm hoping to find funding to develop such a thing and make Mush a more powerful tool for the digital humanities) and lets users create new processing resources from these scripts could certainly begin to replace ArcGIS Server. I'm a regular user of open source software that generates Python workflow code from UML, and I can imagine something like ArchGenXML coming to the aid of people who like to draw their processes graphically.

I thoroughly enjoyed the privilege of attending the NEH/CNR conference on "Using New Technologies to Explore Cultural Heritage", but was a bit crushed to learn that I missed meeting Dan Cohen. His book, "Digital History", has been a very important reference for Pleiades and I am a big fan of his blog. Cohen has written a detailed review of the conference.

It's "AtomPub", not "Atompub" as I've been writing:

The Atom Publishing Protocol (AtomPub) is an application-level protocol for publishing and editing Web resources. The protocol is based on HTTP transfer of Atom-formatted representations.

The slides that I will be using at the National Endowment for the Humanities/Consiglio Nazionale delle Ricerche "Using New Technologies to Explore Cultural Heritage" conference are online.

Speaking of slides, my FOSS4G slides are rather useless on their own. I'm going to try to herd my notes up into a paper over the next couple of weeks.