On a hunch, I checked the application configuration file AirShows-app.xml file and noticed that it uses the following namespace declaration:

<application xmlns="http://ns.adobe.com/air/application/1.0">

Since the Flex 3.2 SDK actually expects to be building AIR 1.5 applications, I had a feeling that this was the root cause of my problem. A quick change in the namespace to the following solved my problem:

<application xmlns="http://ns.adobe.com/air/application/1.5">

Thankfully I didn’t waste a whole lot of time trying to figure this out, but I do wish Adobe had provided slightly more useful error messages.

This is a situation I had accepted as a normal part of being a developer, right up until a week ago when a number colleagues past and present started to upload their personal projects to GitHub. GitHub is an online code hosting service that integrates with Git, a distributed version control system originally written by Linus Torvalds.

Code hosting services have been around for a while, and big hitters like SourceForge and Google Code have done wonders for open source projects. However, GitHub has one important feature that makes it so much more useful than the more established project hosting sites: a social graph. The ability to join a network of friends and automatically see when they’re updating their projects (or adding new ones), to watch or fork those projects for my own ends, gives me the impetus to keep my own projects moving a long.

Right now I only have two projects on GitHub: as3base64 (which was released a few years ago on this site) and AirShows. AirShows is a Adobe AIR-based GUI for editing the configuration file for pytvshows. It’s far from finished, and the code is really quite ugly, but the very fact that it’s now out in the open where my friends can see when I’m working on it (and when I’m not) means that I feel I’m more likely to keep up development.

If Git doesn’t suit your style you don’t have to use GitHub; there are plenty of other code hosting services that offer similar features, such as LaunchPad (Bazaar) and BitBucket (Mercurial). The important thing is that you chose the one that most of your friends are actively using, otherwise you’ll lose out on the very feature that makes these sites so useful for productivity.

A word about licensing

If you’re going to go to the effort of making your projects public, you might as well make them as useful as possible. A lot of developers have heard of the GNU General Public License and often use it for their projects. However, this license requires that the source code for all changes made to your code by third parties must be made available to the public. This means that businesses are often wary of using code licensed under the GPL as part of a project.

All the code I release publicly is licensed under the more liberal MIT License. This license grants developers the freedom to use the code in any way they choose without restriction, so long as the copyright notice remains in the source code. The BSD License is similarly liberal. I urge you to choose one of these two licenses for the code you make available, or at least make sure you understand the implications of the license you end up choosing.

REST stands for REpresentational State Transfer, and describes a technique to organise a web service into resources that can be uniquely identified by a URI. The actions that can be performed on that resource map directly to the standard HTTP methods: GET, POST, PUT, DELETE, HEAD and OPTIONS. With properly organised resources it???s possible to do virtually everything you can do with an RPC-style web service with REST. The benefit of REST is that it goes with the grain of the web, not against it.

The problem with the Flash Player is that the URLRequest class, which is the basis for all HTTP requests, only supports GET and POST operations¹. This is due to a limitation in the NPAPI pseudo-standard used by non-IE browsers that only exposes the ability to make GET and POST requests. Unless NPAPI is updated to allow other HTTP methods, and browser vendors and plugin authors update their implementations to match that new API, we need to find other ways of interacting with RESTful web services.

Now, If you???re lucky, the web service you???re trying to interact with will support some way of overriding the request method, such as a X-HTTP-Method-Override header. If this is the case, you can use the requestHeaders property of your URLRequest object to set the appropriate method:

// Create request object with appropriate resource URL
var req:URLRequest = new URLRequest( 'http://rest.example.com/v1/book/1234' );
 
// Use POST because DELETE is non-idempotent
req.method = URLRequestMethod.POST;
 
// Specify DELETE method in X-HTTP-Method-Override header
req.requestHeaders = [ new URLRequestHeader( 'X-HTTP-Method-Override', 'DELETE') ];

If your web service isn???t quite so forgiving, the only option you have is to use the ExternalInferface class and some JavaScript magic to make requests on behalf of your Flash project and send the response back. It???s an ugly hack, but a developer???s gotta do what a developer???s gotta do. If you???re interested in this workaround, leave a comment and I???ll knock up a simple example.

For what it???s worth, Silverlight fares no better in this regard. This is not surprising since Microsoft are stuck with the same browser plug-in APIs as Adobe, but that doesn???t make it any less annoying for developers on both sides of the fence.

In record time, i’ve managed to acquire new hosting, repoint the domain, set up wordpress, restore the blog database backup that I took first thing this morning, upload all the example files from a backup I did way back in April, fix an issue with the theme, and finally write this blog post. Phew!

There’s a good chance that I’ve missed more than a few things whilst doing this, so please let me know if the comments if you find something on the site that’s not working as it should.

The slides and example code from my Beg, Borrow or Steal: The Art of Flashing Without Flashing session at <head> ‘08 are now available for viewing/download from the My Talks section.

See <head> over heels for a full conference write-up.

I was fortunate enough to take part in two sessions at the conference. The first was a “State of Flash” conversation live on stage at the London Hub with Carlos Ulloa and Seb Lee-Delisle, and with Aral Balkan guest-starring as moderator. This was my first time on stage at a proper conference, and I think the conversation format and sharing the stage with 3 Flash luminaries, not to mention the large Yahoo contingent in the audience, really helped to ease whatever pre-session nerves I had.

We covered a whole bunch of Flash related topics, from what excites us in the Flash world to discussion of Johnathan Harris’s controversial statements made during the closing keynote at Flash on the Beach ‘08. Based on the questions and feedback afterwards, it seems this session went down pretty well.

Steve Webser, Carlos Ulloa and Seb Lee-Delisle at <head> (via bru76)

The second session, entitled Beg, Borrow or Steal: The Art of Flashing Without Flashing, was presented virtually from the comfort of my own living room on Sunday evening. The basic idea was to show that you can steal advanced features from the Flash Player in your standards-based sites and applications that you would otherwise have to wait until HTML5 is fully supported to use. Every time I practiced this before the day the session came in at around the 25 minute mark. Somehow, on the day, I managed to tak up 40 of my allotted 45 minutes with the slides and examples, which only left 5 minutes for Q&A. Oops.

Anyway, the slides and example files from the second session are available to download from the My Talks section of this site. Eventually there will be videos of both sessions available through the <head> website, though for the first 6 months they are exclusive to attendees of the conference. I’ll post a follow-up once the videos are generally available.

A massive thank-you goes out to Aral and the rest of the <head> team for putting together such an awesome and groundbreaking conference. Friday’s sessions and the general geek gathering at the London hub were, in my opinion, worth the admission price alone, and being able to watch the remainder of the conference in my pajamas was quite an experience. One thing’s for sure: <head> ‘09 has a lot to live up to.

<head> starts in just under 48 hours time. I am taking part in a ’state of Flash’ roundtable discussion with Seb Lee-Delisle and Carlos Ulloa live on stage at the London hub (Friday at 17:10 BST). Other speakers at the London hub include: Tim O?Reilly, Richard Moross, Jeremy Keith, Paul Boag, Simon Willison, Chris Heilmann, Stephanie Troeth, Ann McMeekin, Gavin Starks, Gavin Bell, and Simon Wardley.

If you want to attend any of the local hubs (expecially the London hub) you’ll need to reserve a place as there is limited seating. If you have your ticket, head on over to the Local Conference Hubs page, sign-in, select your hub and click the link to reserve your place. Don’t forget to print your ticket and bring it along with you on the day.

I’m also giving a virtual session in Room 3 on Sunday at 19:00 BST entitled ‘Beg, Borrow or Steal: The Art of Flashing Without Flashing’. Here’s the session description:

HTML5 is awesome. Well, it will be awesome when it’s finally ready. Probably. The bad news is that by the time the W3C have finished monkeying with HTML5, I’ll probably have given up on the web as a whole and taken up meat goat farming. The good news (for you, me and the goats) is that there’s no need to wait for a lot of the functionality that HTML5 promises; we can start using them right now. In this session I’m going to show you how you can steal these features from the Flash Player and use them in your standards-based sites or applications, without even a sniff of Flash on the page.

See you at <head>.

• Subscribe to FotB 08 Schedule: Concert hall
• Subscribe to FotB 08 Schedule: Corn Exchange
• Subscribe to FotB 08 Schedule: Pavilion Theatre
• Subscribe to FotB 08 Schedule: All Venues

Note that I’ve made an educated guess at which sessions will be in which venues based on previous year’s schedules. I have now confirmed the session venues with the official schedule. I will try to keep these up to date with any movements and changes as the conference progresses.

This text is slightly out of date for the release version of Flash Player 10. The data for local files isn’t available in the OPEN event, and you’ll need to wait for the subsequent COMPLETE event to fire before you can read the data.

I have updated the FlexPad example application and it’s source code, and I’ll update the article here shortly.

One of the features that I’m most looking forward to in Flash Player 10 (codenamed Astro) is local file access. Once the pipe dream of web application developers the world over, the next version of the Flash Player will allow you to read from and write to local files using a simple ActionScript interface.

This is all implemented with a few simple additions to the FileReference class. Reading the content of a file is accomplished with the FileReference.open() method, which can be called once the user has selected a file using the browse dialog. Like most things in the Flash world file loading happens asynchronously, so you’ll have to listen out for the Event.OPEN event. Once the file has loaded, the file content is available as a ByteArray object through the FileReference.data property to do with as you please.

package com.dynamicflash.examples {


public class LocalFileAccessExample {

public function LocalFileAccessExample():void {
  var fileRef = new FileReference();
  fileRef.addEventListener( Event.SELECT, onFileSelect );
  fileRef.addEventListener( Event.OPEN, onFileOpen );
  fileRef.browse();
}

private function onFileSelect( event:Event ):void {
  var fileRef:FileReference = event.target as FileReference;
  fileRef.open();
}

private function onFileOpen( event:Event ):void {
  var fileRef:FileReference = event.target as FileReference;
  var data:ByteArray = fileRef.data as ByteArray;
}


}
}

Saving data to a local file is as simple as calling the new FileReference.save() method and passing the data you want written to the file and the filename as parameters. As data you can pass either a String or a ByteArray object.

fileRef:FileReference = new FileReference();
fileRef.save( 'Here is some text', 'some.txt');

In order to make sure that nefarious Internet denizens can’t mess with a user’s files without a their knowledge, the Flash Player pops up a native operating system save dialog every time you try to write data to a file.

Consequently the filename you pass to FileReference.save() is little more than a suggestion to the user, and the default directory for the saved file seems to be the last save directory, rather than the directory the file was loaded from. I think this is a decent trade-off between functionality and security, even if it means that saving data to local files requires a little more effort on the user’s part than with traditional desktop applications.

Note: There is currently a bug in the latest beta of Flash Player 10 where any attempt to overwrite an existing file will result in that file being truncated to zero bytes, rather than being filled with the data you specified. This is a known issue, and you can track the bug over at Adobe’s issue tracker.

To illustrate this new feature, I’ve knocked up a simple application (including source code) that I’m somewhat unimaginatively calling FlexPad for you to play around with.

If you want to build your own projects that make use any of the new features in Flash Player 10, you’ll need to grab a recent stable copy of the Flex SDK. See Targeting Flash Player 10 Beta with Flex SDK 3.0.x for more information.