The recent announcement that Google will support GeoRSS in addition to KML as a data format for geographic content in Google Maps is long overdue. This is one of those rare areas where Google trailed both Microsoft and Yahoo and did not seem at all willing to budge. Google's announcement also seals the deal on GeoRSS as the way to syndicate geo-specific data. However, despite the obvious importance of GeoRSS, there is little written material on producing GeoRSS feeds.

I promised a brief tutorial on creating a GeoRSS feed with my post on Yahoo's Tag Maps. More specifically, my post will focus on a boundary update GeoRSS feed. That is, you pass in the maximum and minimum latitudes and longitudes for your map in question and only data about the points that correspond to that particular latitude / longitude box is actually fetched. Obviously, if the user interacts with the map (i.e. panning or zooming), you can use the map's API and some AJAX'y goodness to make calls to the GeoRSS feed to pick up a new set of points that correspond to the updated map's boundaries.

The code below represents the most rudimentary and explicit way to construct a GeoRSS feed using ASP.NET and C#. For the purposes of illustration, no third party GeoRSS libraries are used. It's all basic I/O, streams, and very manual XML construction. Also note a single monolithic call in Page_Load, lack of exception handling and parameterized queries may or may not be the way you want to do things. Try it out though; it does what it's supposed to do really well. If you have any comments or corrections, just drop me a line.

I plan on posting a follow up in a couple of days with a live GeoRSS feed. I just need to find a nice sized set of simple data that I can load into a database and point my code at. Expect to see this soon.

using System;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Xml;

public partial class BlogGeoRss : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        this.Response.Clear();
        this.Response.ContentType = "text/xml";
        this.Response.ContentEncoding = System.Text.Encoding.UTF8;
        System.IO.MemoryStream stream = new System.IO.MemoryStream();
        XmlTextWriter XMLWrite = new XmlTextWriter(stream, System.Text.Encoding.UTF8);
        
        XMLWrite.WriteStartDocument();
        XMLWrite.WriteWhitespace(Environment.NewLine);
        XMLWrite.WriteStartElement("rss");
        XMLWrite.WriteAttributeString("version", "2.0");
        XMLWrite.WriteAttributeString("xmlns:georss", "http://www.georss.org/georss");
        XMLWrite.WriteAttributeString("xmlns:gml", "http://www.opengis.net/gml");
        XMLWrite.WriteWhitespace(Environment.NewLine);

        XMLWrite.WriteStartElement("channel");
        XMLWrite.WriteWhitespace(Environment.NewLine);
        XMLWrite.WriteElementString("generator", "geoglue.com");
        XMLWrite.WriteWhitespace(Environment.NewLine);
        XMLWrite.WriteElementString("title", "GeoGlue GeoRSS Feed");
        XMLWrite.WriteWhitespace(Environment.NewLine);
        XMLWrite.WriteElementString("language", "en-us");
        XMLWrite.WriteWhitespace(Environment.NewLine);

        // Pick up the query strings for the latitude / longitude boundaries
        float UpperBound = 0F, LowerBound = 0F, LeftBound = 0F, RightBound = 0F;
        try { UpperBound = float.Parse(Request.QueryString["UpperBound"]); }
        catch (Exception ex) { };
        try { LowerBound = float.Parse(Request.QueryString["LowerBound"]); }
        catch (Exception ex) { };
        try { LeftBound = float.Parse(Request.QueryString["LeftBound"]); }
        catch (Exception ex) { };
        try { RightBound = float.Parse(Request.QueryString["RightBound"]); }
        catch (Exception ex) { };

        // Build the item nodes for each of the specific tours
        SqlCommand cmd = new SqlCommand("SELECT Name, Description, Latitude, Longitude " +
                "FROM TOUR WHERE (Latitude < @UpperBound) AND (Latitude > @LowerBound) " +
                "AND (Longitude > @LeftBound) AND (Longitude < @RightBound)", 
                new SqlConnection(ConfigurationManager.ConnectionStrings["GeoGlueDev"].ConnectionString));
        cmd.CommandType = CommandType.Text;
        cmd.Parameters.Add(new SqlParameter("@UpperBound", SqlDbType.Float)).Value = UpperBound;
        cmd.Parameters.Add(new SqlParameter("@LowerBound", SqlDbType.Float)).Value = LowerBound;
        cmd.Parameters.Add(new SqlParameter("@LeftBound", SqlDbType.Float)).Value = LeftBound;
        cmd.Parameters.Add(new SqlParameter("@RightBound", SqlDbType.Float)).Value = RightBound;
        cmd.Connection.Open();
        SqlDataReader dr = cmd .ExecuteReader();

        while (dr.Read())
        {
            XMLWrite.WriteStartElement("item");
            XMLWrite.WriteWhitespace(Environment.NewLine);
            XMLWrite.WriteElementString("title", (string)dr["Name"]);
            XMLWrite.WriteWhitespace(Environment.NewLine);
            XMLWrite.WriteElementString("description", (string)dr["Description"]);
            XMLWrite.WriteWhitespace(Environment.NewLine);
            XMLWrite.WriteElementString("georss:point", Convert.ToString(dr["Latitude"]) + " " + Convert.ToString(dr["Longitude"]));
            XMLWrite.WriteWhitespace(Environment.NewLine);
            XMLWrite.WriteEndElement();
            XMLWrite.WriteWhitespace(Environment.NewLine);
        }
        cmd.Connection.Close();

        XMLWrite.WriteEndElement();
        XMLWrite.WriteWhitespace(Environment.NewLine);
        XMLWrite.WriteEndElement();
        XMLWrite.WriteWhitespace(Environment.NewLine);
        XMLWrite.WriteEndDocument();
        XMLWrite.Flush();

        System.IO.StreamReader reader;
        stream.Position = 0;
        reader = new System.IO.StreamReader(stream);
        Byte[] bytes = System.Text.Encoding.UTF8.GetBytes(reader.ReadToEnd());
        this.Response.BinaryWrite(bytes);
        this.Response.End();
    }
}

The more I use Ruby on Rails, the more I become convinced that it is damn near the perfect framework for state government Web-based applications. That said, I don’t know of a single state, local, or municipal government that is experimenting with Rails in any meaningful fashion. I have a bunch of stored Google queries that have yielded woefully little information about the penetration of Rails into state government over the past year or so. I fear that is because there really has been little or no penetration.

When I think through the merits of Ruby on Rails and apply the pragmatic brush of my experience with state governments, I’m torn as to whether I believe Rails will ever gain a foothold in this arena. To articulate my ideas, I’ve enumerated, on one hand, my top three compelling arguments why Rails should be overwhelmingly successful in state government. On the other hand, I’ve listed the top 3 reasons why Rails doesn’t really stand a fighting chance. I’ve omitted what some would consider the “classic” selling points of RoR: ActiveRecord, Scaffolding, etc. By all means, I encourage you to look into these if you’re new to Rails. It’s just that they aren’t particular to adoption in state government. In the spirit of remaining optimistic, I’ll list the top 3 reasons Rails has a chance first.

Top 3 Reasons Rails Could Find a Home in State Government

1. Convention Over Configuration – With this mantra, the Rails community initiated a full-frontal attack against the J2EE crowd (pre-EJB3, have you), where XML configuration files had become the tail wagging the dog. Ruby on Rails, on the other hand, makes all sorts of assumptions about what how things will work and requires developer intervention as the exception rather than the norm. In an environment where developers really do work an 8 hour day (or less), focus on delivering functionality and not on tweaking and re-tweaking the application architecture means significantly greater productivity.
2. Painless Objects – For many developers, especially those transferring from procedural languages like COBOL or Visual Basic, objects do not come naturally. I’ve seen many state government developers spend years trying to catch onto the concept and still not get it. In Rails, objects just work out of the box, knowing how to deal with the database, providing easy validation hooks and manageable relationships. As a bonus, Ruby tends to be less intimidating to look at for COBOL or classic VB developers than do the C family of languages (C# and Java, in our case).
3. Embodiment of Best Practices – From unit tests and separation of concerns to database migrations and standard environment definitions, everything is built into Rails. These things can certainly all be done in the Java and .NET worlds, the practices and tools just seem so much more external to the way of doing things and have not been universally integrated into the standard way of doing things in these languages. As an example, how many C# texts talk about unit testing? How many RoR texts don’t talk about unit testing?
   

Top 3 Reasons Rails Will Fail To Find a Home in State Government

1. No Salesforce – Surprised that I didn’t mention cost in the reasons contributing to Ruby on Rails success in state government? That’s because it isn’t. The fact that the entire RoR stack is free means less “conventional” ways to make money on the software side of things. You won’t find IBM, BEA, or Microsoft pitching Ruby on Rails solutions to state governments. Furthermore, the large system integration vendors won’t be pitching it either. Without the software vendors and the SI’s, it’s really hard to get in the door at state governments.
2. Knocked as Not Enterprise-Worthy- Ruby and Rails have been knocked since their inception as great for hobbyist but not enterprise worthy. This is a knock that open source software gets in general and when it’s a scripting language to boot, you might as well be buying your technology from Toys-R-Us. For the real story on this, I suggest that you take a look at Dare Obasanjo’s classic blog post My Website is Bigger Than Your Enterprise. Dare’s points are very good, and although they’re not 100% accurate, you gotta think, “if this works for Google and Yahoo, why can’t it work for me?”
3. No Formalized Training Program – This may sound even more ludicrous than my first two points. What’s the right way of saying this… “it’s true.” Believe me, it’s a known fact that until there is formal training available for a technology and the big vendors are pitching it, it’s not enterprise worthy. Right?

For those Rails developers using RadRails as your IDE, you might have noticed that, in the last several days, the RadRails site has slipped off of the face of the earth. Due to a very unfortunate run-in with their registrar and DNS provider, the nice folks at RadRails are apparently stuck in DNS purgatory. This little mishap coincided with the announcement of the Aptana IDE / RadRails merger. Due to the site outage, many folks missed out on the announcement all together... so I'll repeat Aptana and RadRails are merging. You can now find the mirrored RadRails site here. The location of the RadRails download on SourceForge has not changed.

Aptana has posted a brief roadmap for the new combined product. This should be exciting new for folks using RadRails. It was apparent that RadRails grew far beyond the initial expectations of its creators and, as Ruby on Rails skyrocketed in popularity, support was going to be an issue. The creators of RadRails did a great job of maintaining and expanding the IDE for a long time. They then made the greatest of sacrifices and, instead of letting their product die on the vine, they merged it with a likeminded product for the greater good of their RadRails users. It would be great if all open source project owners functioned in this fashion. 1 or 2 great products is much better than 9 or 10 mediocre products.

If you haven't tried out Aptana, I encourage you to give it a look. It's a great Eclipse-based JavaScript IDE. With planned support for RHTML integration and hopefully more extensive code assist capabilities to come, there is much promise in this merger. Not that it is required, by any means, but a high quality IDE will only serve to further Ruby on Rails case and attract more and more developers from the Java and .NET camps to at least give RoR a look.

I’ve spent the better part of the last 6 years dealing with state government systems that manage information about citizens receiving government services. As creative as state government can be in some areas, presenting new and interesting visual metaphors for the management of citizen and case (i.e. collections of citizens) information is certainly not a forte. This problem is not solely the fault of state governments. Rather, it’s the product of state government business leaders’ lack of knowledge of the available options, educational obligation complacency on part of government’s IT partners, and the real or perceived difficulty of being visually creative in an environment where accessibility compliance is not an option. 

There are ways around the accessibility compliance constraints; up to and including parallel functionality with both accessibility compliant and non-accessibility compliant versions. Education, however, is not always as easy to come by. With the technology supporting rich Internet applications, we can do so much more than could be done with an old 3270 mainframe terminal. Yet, across a broad swathe of in-house, outsourced, and packaged case management solutions, you’ll rarely find anything beyond some minimalistic styling and obligatory “smiling citizen” pictures that could not have been done 20 years ago. There are many new metaphors that we could use to make the data presented by case management applications more meaningful to workers. I present three of the more radical concepts below:

 

1.      Geospatial - Use a geographic metaphor to allow the discovery of relationships between individuals, cases, caseloads, or entire programs. With the advent of map mashups, this has surely become one of the more popular new visuals for creatively displaying data on the Web. For publicly accessible examples of what is possible, check out Chicago Crime and Citystat. These two examples represent visualizations of publicly available data in Chicago and Wasington D.C. , respectively. Also, these were built on top of relatively garden variety two dimensional maps. More recently, things are moving more in the direction of quasi 3 dimensional (a.k.a. “Bird’s Eye Views”) and fully navigable three dimensional models. If you haven’t seen Microsoft’s maps at all (or as of late), I strongly encourage you to give them a look. Right from your browser you get fully scrollable 2 dimensional maps and bird’s eye views of many major and non-major (check out the Capitol Complex in Harrisburg , as an example) US cities. As a bonus, if you’re using Internet Explorer, you can get fully virtual reality tours of several major cities. Firefox users, don’t despair, support is supposedly being added soon for Firefox too.

 

2.      Temporal – Use a timeline metaphor to show a longitudinal time scale relationship between various events. These events could be various transactions within a case or across multiple cases. Simile Timelines are an exciting new way to model such relationships. Check out the example timeline for the events surrounding the assassination of John F. Kennedy.  Notice especially how the top and bottom timelines interact together as you drag them independently. For bonus credit, check out how the scale of time changes in the most critical moments surrounding Kennedy’s assassination from months to days to hours to 15 minute intervals. Timline, much like the maps that support the geographic metaphor, has a fully API against which one can program. This leaves the possibilities for state government based uses of the timeline metaphor wide open.

3.      Network Graphs – Using the network metaphor enables the discovery of complex relationships between people and other entities. With a deep network of relationships in most case management systems, this is potentially one of the most useful new metaphors. Given the graphic and data intensive nature of displaying these relationships, it’s also one of the most difficult ones to implement technically. There are some great examples of this being done on the open Internet though, most of them using Flash. Check out Tracking the Threat’s terrorist network navigator. Imagine using the same thing to expand the network relationships in a case management system. Moritz Stephaner’s Relation Browser is also a great example of what can be done in this space. Unfortunately, there’s a lack of standard tools to build these types of models. The one tool that I know of (Prefuse) uses Java and Java Applets instead of Flash. Hopefully, we’ll see some key players recognize the opportunity and create standard tools to support this metaphor in the near future.

These really are the more radical of the changes that I can think of. There are, of course, more rudimentary changes that can be made that could have just as profound of an impact. The use of pictures with personal profiles or the ability to perform full text searches on the system’s case notes (the unstructured data lifeblood of many systems) immediately come to mind. As much of a challenge as it seems to implement these suggestions for existing case management systems, the far greater challenge lies in adjusting users’ approach to leveraging these new features. A genuine knowledge worker approach is required to get the most out of these features. This is a proposition bound to be a very exciting opportunity for some and a very scary change for others.

One of the most common misunderstandings or missteps in following a particular software process is to follow that process in a blind, one-size-fits all fashion. This is especially true if you are mandated organizationally to use a particular software process. Just as the founding fathers could not have foreseen the challenges of the modern world when authoring the Constitution, there is no way that the creators of a generic software process could understand the nuances of every particular project where their process would be used.

 

Processes need to be malleable so that they don’t incite the “baby with the bathwater” response in which the entire process is tossed aside because it proves too inflexible. Good processes can and should be customized. There are several methods that can be used to achieve this end. One of my favorite articles on this topic is an oldie from Per Kroll (“Dr. Process”), entitled How Can We Customize the RUP? In this article, Per lays out 3 basic methods that can be used to customize the RUP:

 

1. Make comprehensive changes to the RUP with the Process Workbench (Heavy)
2. Produce a custom RUP configuration using RUP builder (Lighter)
3. Create your own development case and place it in the project-specific Web site. (BINGO)

First reading this article caused me to re-examine the development case, an often overlooked project artifact. I fell in love with the idea of the development case but the RUP and online examples I could find at the time didn’t live up to my expectations. Between online examples, my ideas, and a great section on the development case in the book Software Development for Small Teams: A RUP-Centric Approach, I pulled together a template that I’ve carried with me, more or less unchanged, until this very day. I’ve included a copy of this template for you to download. The version that is included in Pennsylvania’s BSCoE Software Engineering Process (SEP) is very similar in many ways. You can find that version in the center ring of the online SEP.

 

 

The beauty of the development case is that: (1) it’s very lightweight, just a Word file; (2) it works equally well with a commercial process tool or with no process tool; (3) facilitating a meeting to walk through a development case forces people to communicate about what will and won’t work for them and to make decisions that often have very beneficial impacts for their projects. The best part of the development case is that it works very much like object-oriented inheritance. Customizations from higher levels in an organization can trickle down to lower layers of an organization with customizations and/or additions being provided at every layer where this is required to add value.

I finally got around to adding videos to the site that I’ve been accumulating over the last couple of years. I’ve blogged about investigating Flash video a number of times before. After putting a number of videos on YouTube and being disappointed with the quality of the end product after their compression and resizing process was completed, I decided to go it on my own.

The decision to make this move provided the necessary impetus to do the final research and prototyping necessary to make this a reality. From my experience, I’ve come up with the three things that you’ll need to host Flash Videos, aside from the source video itself, of course.

1. A server with plenty of bandwidth and the capability to stream media.  Even though the Flash compression process yields fabulous results as compared to a raw video stream, these files are by no means small. I am seeing sizes of 6 – 12 MB per minute of Flash video depending upon the quality of the underlying source and some tweaking of the video encoder settings (like bitrate). Depending upon how much traffic your videos get, this could suck up quite a bit of bandwidth. With respect to streaming media, I suggest that you select a host that explicitly allows this or who gives you control over your server so that you can take care of this yourself. Beware that if you’re hosting on the Windows platform with Windows Server 2003, this server will not stream Flash videos out of the box. You’ll need to explicitly set the MIME type for the Flash videos as noted in this Tech Note from Adobe.

2. A solid Flash video encoder. With the explosion of Flash media at sites such as YouTube, Google Video, and MySpace, the number of tools available to do consumer Flash video conversion are on the rise. These tools range from rank amateur stuff to automated server-side tools like those used by the big boys. In the consumer space, you’re paying for three things: ease of use; the video encoder (codec); and the flash player. The most important of these things to me (but I’m sure not to everyone) is the actual codec.

The codec is like the engine in your car. That is, you can buy those flashy spinner wheels and fat (phat, maybe?) muffler but without a good engine, you’re going nowhere fast. That said, there is quite a war going on in the codec camp based upon proprietary versus non-proprietary formats (VP6 versus H.264). You can read On2’s summary of the issues here. Since On2 is the source of the proprietary “next generation” Flash codec, this comparison is to be taken with a grain of salt.

From a consumer’s point of view, you either buy On2’s technology or somebody else’s since most everyone else supports H.264. Many of the counterarguments to On2’s codec revolve around the portability, openness and near universal adoption of H.264. From my tests, the VP6 (On2) encoded videos looked better and compressed to smaller file sizes. The encoding process, however, is a bear and will peg the most capable of CPUs at near 100% utilization during encoding. The real proof for me was in the marketplace. With many major media and technology companies (including Adobe, themselves) using On2’s codec, I’ve assumed (rightly or wrongly so) that people much more knowledgeable than I in this area have done their homework and are convinced that On2 offers something that H.264 products do not. What seals the deal is that On2’s standard bare-bones encoder package costs only $39. Granted, it’s not as slick or user-friendly as some of the others that I tested but it has the most horsepower under the hood.

3. A configurable (ideally scriptable) Flash video player. The player is the part that actually drives the Flash video and allows the user to interact with the output, moving the video forwards and backwards, setting volume, etc. Many of the video encoder packages include a selection of players out of the box; so you may not be required to pick up one separately. If your codec doesn’t come with a player or you’re not satisfied with your player’s capabilities, I strongly recommend that you take a look at Jeroen Wijering’s Flash player.

As you can probably see from the screenshot above, Wijering’s Flash player is, well… not that flashy. What it lacks in glitz, it more than makes up for in power and flexibility. The player is very easy to use in its default configuration, playing either single Flash videos or running though multiple videos specified in an XML playlist. Furthermore, you can perform runtime manipulation of the Flash video by passing a set of parameters known as flashvars. This very handy feature alone makes this player standout head and shoulders above the rest. Finally, there seems to be a decent community support around this open source player with plugins built for popular tools like Wordpress, Drupal, and Coppermine. This extra article by Jeroen provides some good guidance on embedding Flash. For specifics, it’s best to download the tool and play with the samples.

Hosting Flash video is really not hard once you have these three things figured out. Although I didn’t mention source video, it really is key in the equation. Videos that I shot on older still cameras needed to be scaled up in size and are a bit pixilated. Videos that I shot on my newer Canon A630 look much better, but they are not in stereo and show signs of pixilation even if I use optical zoom. From this whole conversion effort, my most important takeaway is that I’m going back to my Sony Hanycam Digital for shooting video. It yields the best video and sound quality. The only downside is the digital tape to digital file conversion process.

In the final installment of this March 1^st trilogy, I’ll hit something really topical, the precipitous fall of the Dow Jones Industrial Average (DJIA) two days ago on February 26^th. For those of you just diligently minding your stakes in the market, you probably got wind that all the major indexes tanked pretty badly on the 26^th. The Dow, however, tanked in a rather unnatural fashion that was quite different from the others.

You can see the “Live” and recalculated Dow Jones numbers on the graph above. Although the actual  Dow (in orange) did drop pretty steeply, there’s no way it could have done the near vertical drop that the graph indicates without some outside intervention. It turns out that this outside intervention was provided by a “computer glitch”, as reported in the general press. More specifically, one of the queuing systems that feeds data to the system that actually calculates the Dow Jones index got backed up under record trading volumes. When market watchers got suspicious that the index movement did not align with the sliding values of its core components, they decided to investigate. Discovering the backlog, they manually switched over to alternate systems. When these systems worked down the backload, a new DJIA was calculated and voila, we had a 200 point drop in a couple of minutes.

As painful as this must have been for professional traders and as painful as it’s likely to be (in terms of lawsuits) for the Dow Jones company, this is really interesting from an IT point of view. If you’re an IT person looking for insight into how these markets work, I thoroughly recommend the book Practical .NET for Financial Markets. It’s one of the most advanced .NET texts I’ve ever read and, as a positive side effect, introduced me to a completely unfamiliar business domain, financial markets. Reading this book will not only make you a more educated developer (whether or not you use .NET), it will help you understand the causes and effects of events like those on the DOW two days ago.

If you work in the IT world today, you have a greater chance of not finding a Starbucks on a randomly selected block in Manhattan than you do of not hearing the term “SOA” during your daily workday. It’s unfortunately not nearly as often that I hear or read something about SOA that sounds reasonable, practicable, and overcomes my otherwise skeptic view of all the hype that so often masquerades as SOA. The recent ITConverations Podcast with Todd Biske and Ed Vasquez from MomentumSI is just the sort of real-world advice that avoids the hype and gives a heavy dose of ground truth reality.

Todd and Ed offer some pragmatic advice with respect to SOA and highlight challenges that really resonate with me based upon my experiences. Amongst these are the lack of a single design time and run time governance toolset and the importance of the mindshift from developing enterprise applications to developing reusable enterprise functionality that can be leveraged by different applications. Most importantly, however, is their insight in the importance of thinking of services as products. I have found this to be one of the single largest hurdles to achieving reuse – be it component-based or service-based reuse. Proficiency in application development in no way guarantees proficiency in product-based service development. In fact, most application development organizations that I have dealt with have little or no experience with product-based development. I couldn’t possibly cover all of the disciplines needed to master product-based development in this short post but I’ll refer you to a couple of sources that I feel give more than an adequate introduction.

• Beyond Software Architecture: Creating and Sustaining Winning Solutions – Despite the fact that I only gave it 3 stars in my Amazon review, this is the definitive read on product-based development.
• Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries – Although ostensively a book on framework design, this book gives some great guidance on developing an API to meet the needs of its users, not the needs of its designers.
• Enabling the Service Oriented Enterprise – Not much product development here. This article, however, fills in the missing pieces of product development that are exclusive to services.

I plan on recommending this Podcast to a number of people that I work with or have worked with in the past. I can’t expect everyone that I deal with to spend time digesting countless books and articles on the topic of SOA. As a matter of fact, given some of the materials out there, this might just prove more confusing than useful. An hour of time to listen to a Podcast (especially this one) isn’t too much to ask though. You’ll learn an awful lot in this hour.

In the first of my beginning-of-the-month speed blogs, I’d like to start with the topic that I’ve been putting off longest, building applications on top of Amazon’s Web services. For those of you that think of Amazon.com as just a book store, or an e-commerce platform, or [add your assumption here], think again. In the last year or so, Amazon has released a number of services that have not only established them as a first-class platform, but have pushed the envelope considerably on the idea of virtualization.

This trend started with Amazon’s Simple Storage Service (S3) and was expanded on with their Simple Queue Service (S2). Late last year, Amazon blew the roof off with the limited release of their Elastic Compute Cloud (EC2) service. EC2 is a configurable computing environment where you can load up virtual instances (roughly equivalent to your average Linux server) – on demand. You can load or unload these instances to meet cyclical demand and you only get charged for the computing time that you use. Couple this grid computing potential with S3 for storage and S2 for queuing and let your imagination be the limit.

Doug Kaye’s architecture for GigaVox Audio Lite, an audio file transcoder, might give you some ideas about what can be done with these services. The related ITConversations podcast contains plenty of details, with both Kaye and Jeff Barr, from Amazon, on the wire with Phil Windley. This podcast does a good job of conveying the vision and the realities of using these services. Some of the discussions, like managing and developing on top of a globally distributed queuing system where a call like size = MyQueue.size doesn’t really make any sense, will cause you to stop and think.

The final new Amazon service that I didn’t mention is Mechanical Turk, which is, simply put, a computer interface onto human services. This one has been around for a while and never got much attention from me until I heard the Podcast. Interestingly, the site castingwords.com, which produces Podcast transcriptions, farms out their work via Mechanical Turk. The combination - digital input in (MP3); digital input out (electronic transcript); virtual computing; virtual workforce – that’s pretty radical. There are some other great uses for this service mentioned on the Podcast as well.

The Podcast is absolutely worth a listen. And if this sort of thing piques your interest, you’re not alone. The queue to get into the EC2 beta program is a few months long. If you’re even remotely interested, get in line now.