As a conference, WebDU is dear to the hearts of Flash, Flex and ColdFusion developers in Australia — up until very recently, it was the only event that specifically catered for their platform of choice. Starting out as MXDU, Sydney-based Daemon have been delivering a solid two day event focused around Macromedia/Adobe products for seven years. And they’ve been doing a damn fine job.

In recent years however, the WebDU team have added additional streams aimed at general web development and online user experience (and changed their name accordingly), as well as sessions about team work and some labelled “safe for managers”. Which brings us to WebDU 2009, back at Star City Casino, with five separate streams: Team/UX, Web I, Web II (not, as some might suggest, Web two-point-oh), Flash/Flex, and ColdFusion. That’s a total of 46 sessions over two days — and for the generalist attendee, the daunting task of choosing just 12 to physically attend.

Day 1 Keynote

The Fluff
There are two different types of opening keynotes from Adobe staff: there’s “look at what people are doing with our products” and there’s “look at what you will be able to do with the next version of our products”. With CS4 released fairly recently, this year’s keynote session saw Mike Chambers, Principal Product Manager for developer relations for the Flash Platform at Adobe, doing the former — showing off some funky leading edge things from out in the wild right now. A 3D sasquatch danced across the Mike’s screen, balancing on a sheet of paper he held in front of his webcam, courtesy of Augmented Reality and Papervision 3D; on the more practical side, there are a number of AIR-based Twitter clients and over 12% of tweets on the service come from Tweetdeck, an AIR app; and the New York Times use Flash and AIR to deliver specialised content and an enhanced experience as a value-add to their paid subscribers. The integration of AIR with the Facebook API will no doubt lead to some interesting applications — the Jackass “pranking” game shown off will definitely be one to watch.

The local Adobe office got a look in with Andrew Spaulding showing off a locally produced web/AIR hybrid music store, built by local developer Andrew Muller in a timeframe comprising weeks rather than months — an impressive effort. Andrew Muller later presented an entire session on AIR application development, drawing on his experiences with bandit.fm and other projects.

The Meat

Adobe’s Mike Chambers
(photo by Pete Ottery @webdu)

The plenary session then took at turn to the other “type” of keynote: sneak peaks of upcoming products, what every developer in the room was waiting to see. Adobe’s Steven Heintz showed off Flash Catalyst, the Flex skinning tool that Adobe have been demoing alpha versions of for quite a while now. Catalyst is a design to code tool for Flex — layered elements can be imported from Illustrator, Fireworks or Photoshop and applied to Flash components as skins. Steven showed a really fast but complete demo where he built a basic but functioning application in a matter of minutes, without writing any code — to many oohs and ahhhs from the audience.

Catalyst will be the tool that stops Flex applications from looking like Flex applications and start to give designers some freedom to innovate, and will no doubt make a big splash in the RIA sphere. What was interesting was that I hadn’t realised, up until now, that Catalyst was Eclipse-based — from what I saw onscreen it certainly doesn’t look or behave like an Eclipse IDE, but rather like part of Creative Suite. A public beta is apparently going to be available at some point in the not-too-distant future so everyone can get their hands dirty.

ColdFusion, the comeback kid
The keynote wasn’t all going to be Flash, however. Next up, Terry Ryan, new to the ColdFusion evangelism team but certainly not new to ColdFusion, showed off Bolt, the long-awaited Eclipse-based IDE for ColdFusion, and some new features that will be included in the forthcoming ColdFusion 9. He started off by admitting that Adobe has a bit of an image problem with CF, but that the platform was far from stagnating with over 700,000 developers world-wide. He then quickly demoed some of the code generation features in Bolt that tie into the ORM features new in CF9 with Hibernate.

Time was running out but the point of the keynote was clear: Adobe’s aim is to have a complete workflow for rich internet applications deployed to the browser via Flash player or the desktop via AIR: from design tools like Photoshop, Fireworks and Illustrator; through Catalyst, which is a kind of rapid prototyping tool; into Flash Builder (the renamed Flex Builder) for writing the hardcore ActionScript; and Bolt for writing the backend services code to interface with ColdFusion server.

Geeky indulgence: web services, dependency injection, Yahoo pipes and more than hot AIR

Andrew Muller
(photo by Pete Ottery @webdu)

Other sessions throughout the day presented opportunities for this developer to nourish and indulge her inner geek: Kai Koenig contemplating the state of play with web services (conclusion: interoperability still sucks!), Dennis Clark demonstrating dependency injection with the ColdSpring framework for ColdFusion, and Phillip Tellis showing us how to get down and dirty with Yahoo pipes, remixing and republishing RSS feeds in a rather dry but example-heavy session. Particularly cool was Andrew Muller’s 98 cups of Tea, an interesting session which ran over tips and tricks for developing AIR applications from someone who has built some very successful ones. My favourite take-away from Andrew’s session was to include automatic updates in your application, right from the beginning — it only takes a few lines of code, and makes sure that throughout development your client and testers always have the latest version of the app. Smart thinking!

The day ended with birds of a feather sessions on AIR, mobile development, and ColdFusion, where groups of like-minded developers had a casual discussion on topics of interest, led by one of the speakers. Then it was off to Oscars Lounge Bar, a short walk away, for drinks sponsored by Gruden.

Stay tuned for a wrap-up of Day 2!

It appears that many others have had the same problem. Fortunately, I found a solution for anyone who has experienced problems upgrading to v2.2.2.

1. Repair the installation
Launch “Programs and Features” (Vista) or “Add and Remove Programs” (XP) from the Control Panel. Click VirtualBox and choose Repair.

If the repair works, you should be able to upgrade without problems. Otherwise, proceed to step 2…

2. Extract the VirtualBox files
Repairing can display a message saying that a VirtualBox installation file could not be found. If this occurs, find your old installer - if you have deleted it, download it again from the VirtualBox old builds page.

Open a command prompt (cmd.exe) and ‘cd’ to the folder where the installer resides. Run it using the “-extract” parameter, e.g.

VirtualBox-2.2.0-45846-Win.exe -extract

After a few moments, a dialog will appear saying that the VirtualBox files have been copied, normally to a temporary folder in the Users (Vista) or Documents and Settings (XP) folder. Make a note of the folder’s location!

3. Complete the repair
Start the repair again. When the ‘missing file’ dialog appears, click “Browse” and navigate to the folder noted in step 2. The repair should now complete successfully.

If the repair still fails, try re-installing the old version. If the normal installer does not work, navigate to the folder above and you will find two files: an x86 and AMD64 version of the VirtualBox installer. Run the version that is suitable for your system - if an error occurs, try the other one!

4. If all else fails…
Uninstall the previous version before upgrading.

Hopefully, your upgrade will go smoothly without needing to do any of this! VirtualBox is still a great product, regardless of any installation issues.

See also: VirtualBox Virtual Machine Software: A Hands-On Review

About the Book

Getting Started with Flex 3 is a must-read for any Flex developer. It consists of multiple mini-tutorials that are presented step-by-step, showing you how easy it can be to develop Rich Internet Applications using Flex 3. Having this handbook in your library is an asset if you want to be able to build Flash applications of any magnitude; from a simple widget to a complicated, multi featured RIA. Instructing you on the basics to more advanced applications using the Flex SDK and Flex Builder 3, no matter if you came from an Visual Studio-intensive or open source background.

The last time we offered a book prize like this, all 100 copies were gone within hours, so get in quick before you miss out!

Learn More with a Free eSeminar

Adobe are running a bunch of free online learning sessions over the next couple of months, including one related to this tutorial titled Adobe Flex 3 and Adobe ColdFusion 8, and there are other topics covering development with Flex and Flash. These eSeminars are a great way to expand your skillset — and best of all they’re free.

A huge thank you to our sponsor, Adobe, for making this prize available!

Though Chrome may be stable enough to drop the beta tag, the browser is still far from complete enough to be a truly viable competitor to other alternative browsers like Firefox and Safari. Chrome still lacks support for basic features like form autofill and RSS, and perhaps more crucially, has no official support for the Linux and Mac platforms.

Another major feature that Chrome currently lacks is extensions. Adding support for browser plugins is a priority, though, and a Google recently published a document that details their plans for extensions for the Chromium project (Chromium is the open source project behind Chrome). We predicted earlier this month that once Chrome adds extensions support, the browser will become instantly more attractive to early adopters and will start to pull more users away from Firefox.

Chrome’s share of the browser market is still tiny, but Google has not been shy about putting a download link on Google.com, even when the product was still in beta. With that kind of exposure, and with Chrome now proclaimed stable, Chrome could start to creep up from its current ~1% share (Google claims 10 million active users — including on Antarctica, apparently). That could be especially true once some of the feature we mentioned above make an appearance.

We noted earlier this week that Chrome is an important part of Google’s 3-pronged Web OS strategy. Along with Gears (offline data store) and Native Client (local CPU resources for web apps), Chrome gives Google a compelling platform for the delivery of web applications. In that respect, Chrome is less an attack on Firefox and Internet Explorer, and more of a thrust at Windows. Google is pushing for a computing future in which applications are delivered from the cloud and the computer operating system doesn’t really matter. Whether the client is running Windows, Mac, Linux or something else is irrelevant for Google’s Web OS vision.

Open source enthusiasts were reeling this week when Sun Microsystems announced that it will be purchasing MySQL AB, the company behind the development of the popular MySQL database software, for US $1 billion.

The spin from both camps was positive, but what does the deal mean for web developers? And what impact is it likely to have on other open source projects?

To attempt to answer these questions, we need to look at a number of factors, including Sun’s history with open source technologies, its competitors, and the success of other open source technologies that have been commercialized.

While it’s not without its detractors, there’s no denying that Sun has a pretty solid history when it comes to involvement in the open source world. The company claims to be the biggest contributor to the open source community, a claim that, based upon its release of the Solaris source code in 2005, and the Java programming language in 2006, is difficult to refute.

But there is other evidence of Sun understanding the value of keeping software open source and free: projects like OpenOffice.org and NetBeans have healthy communities and promising road maps. In fact, if you examine Sun’s current offerings to the corporate world, the only key component missing from the portfolio (and one that competitors such as Oracle, IBM, and Microsoft already offer) is a database. MySQL, with over 10 million installations worldwide (including high-traffic sites such as Google and Facebook) is a natural fit.

One concern that web developers may have is that the licensing terms will change — what if Sun decides to start charging a licensing fee for each of the installations of MySQL?

In my opinion, this just won’t happen, simply because Sun realizes that it hasn’t bought a database — it’s bought a community. A community of employees, developers, and clients.

Related to this is the question of whether development of the cross-platform releases of MySQL will stagnate, with Sun’s energy being focused on compatibility with the Solaris platform. Here’s what MySQL’s VP of Community Relations, Kaj Arnö, had to say on the matter:

“I don’t expect (the development of MySQL on Solaris) in any way to be at the cost of other popular operating systems (Linux, Windows, Mac OS/X, other Unixes etc.) or development environments (PHP, Ruby on Rails, Perl, Python, ODBC, C++, C#, VB etc.). MySQL grew with LAMP, and MySQL without LAMP at its core is simply unimaginable. It was MySQL’s part of LAMP that interested Sun in the first place. Hence I don’t see Sun having a platform migration strategy, but to continue to be an integral part of the dot in .com.”

In short, Sun understands the business model around open source software, and it wouldn’t have invested $1 billion into a company only to screw over its users for a short-term profit when the long-term prospects — driving MySQL into the corporate arena with paid support — look so bright. There are plenty of other open source databases (PostgreSQL, for example) with comparable features and performance that customers would quickly migrate to if they were unhappy.

And as for the figure paid by Sun? While some would suggest the number was low given the size of the MySQL user base, $1 billion is a lot of money in anyone’s eyes. Let’s take a look at some other recent open source acquisitions [source]:

• US$210 million for SUSE Linux (Novell)
• US$400 million for JBoss (Red Hat)
• US$500 million for XenSource (Citrix)
• US$350 million for Zimbra (Yahoo!)

I’d say the MySQL team would be feeling pretty happy with themselves right now. Who said there was no money in open source software?

In this talk, Adam presented a number of methods for effective advocacy and for getting along with other developers. In other words, interacting with people is as important as interacting with hardware or software. Problems in this sphere have no technical solution — they require a social one. Thus, the idea of ‘people hacking.’

People hacking is not rooted in nefarious black-hat hacking, but simply in using tools of social jujutsu (sometimes on yourself, even) to gain traction for ideas you’re trying to advocate. Paying more attention to the people side of things can help you build the kind of integrated, smoothly functioning team capable of executing (to borrow a basketball metaphor) the “no-look pass.”

A few sample ideas included:

• Simply smiling — makes yourself and people around you feel more positive
• Avoid negativity — try the ABBA Method (see the slides for details)
• Avoid criticism
• Compliment before criticizing

Some ideas followed about how to deal with jerks in your organization, including the simple-but-effective “No Asshole Rule” (from the book of the same name) that encourages a zero-tolerance toward asshole behavior in your group — even from so-called superstar programmers.

Adam also encouraged a little self-evaluation to determine if your yourself may be a recovering jerk, and that by focusing on improving your ability to working well with those around you, you can also reform yourself.

Adam has his slides available online here.

Andy’s talk gave practical advice for catching up on all the tasks you put off until some later date (that inevitably never comes) — stuff like postponed docs, fixing broken tests (or just writing tests at all), backup regimes, TODOs in your code, etc.

He had a very simple and straightforward formula:

• Identify your debts
• Determine the costs
• Pay the most profitable
• Stop incurring new debt
• Repeat as necessary

The most important takeaway for me was the idea that you don’t try to fix all your problems at once. You figure out what fix will give you the most bang for your buck — not the easiest thing to fix, not the biggest problem. You fix whatever it’s the most profitable to fix.

There was also a lot of good discussion during this talk on how to convince a manager to allow you to begin reducing technical debt with things like refactoring, increasing test coverage, adding documentation, or actually testing your disaster-recovery plan. The best advice was the idea of putting it in terms that the manager can understand (often with a manager either in money or time).

For example, if managers know that investing two days testing disaster recovery would save weeks of rebuilding critical infrastructure, or that spending a week refactoring crufty old code would make it 20% faster to implement new features, it’s easier for them to justify the cost.

Andy has his slides available online here.

The days of one guy putting together all the hardware and software together by himself in his garage are long gone — working with computers increasingly means doing something very specialized in one of the layers between the hardware and the end-user.

Adam made a good case for the idea that despite this specialization people working with computers should develop at least a passing familiarity with the layers other than their own — e.g., a guy working in the database learning typography, and a Web designer learning about compilers.

Many developers may not have the interest (or the discipline) to spend time learning about subjects so far removed from their little piece of the pie, but a couple of the benefits to doing so that Adam described seemed pretty compelling:

• The ability to converse with the people you work with and understand better how your work interfaces with theirs.
• Gaining a new perspective that allows you to find unexpected or creative solutions to problems in your own domain.

Adam spent the end of his talk going over the two example layers just mentioned — CSS/layout/typography, and compilers. That might not have been something every developer was super-interested in learning about, but for a guy like myself who’s kind of all over the place from the database layer all the way up to end-user-facing design, it was really interesting stuff.

Adam has his slides available online here.

Photo Archiving: The Golden Rule

Store metadata in the image.

Actually should be more precise about the word metadata here - there are essentially three significant types of metadata when in comes to digital images, when it comes to who created it and where it’s stored.

First; the stuff your digital camera attaches to the image when you take a picture (e.g. camera make, time the picture was taken, exposure etc.), second; meta data you manually add to an image, typically at the time you download images from the camera to your PC (e.g. where the picture was taken, a description, keywords, name of the photographer etc.) and third; “grouping metadata” - how a collection of images relate to each other (e.g. they were all part of a single photo shoot or they are all family pictures). For the purposes of this discussion, the first two types of metadata can be regarded as a the same thing and it’s this information that you want stored in the image.

The third type - the “grouping” information is “relative” and, practically, can only work well if it’s stored externally from images. This may be as “lightweight” as a tree of directories on your filesystem with timestamp-based names, under which you store your images, but image archive tools may offer additional facilities in this area. Important is if you want to group a collection of images under a heading like “family”, you also want to have a keyword “family” stored in the image. In such case it may be the image archiving tool can build the groups automatically from your keywords.

But you want the first two types of metadata in the image, so that if you switch archiving tools, transfer your images to another system or forget to backup the archive database but remember the images, it won’t be lost. A decent archiving tool will probably generate it’s own database from this inline metadata, to make searches etc. efficient, but the final authority should be the image itself.

Inline Image Metadata Standards

The next question is how is data stored in an image. File formats like JPEG, RAW and TIFF, commonly used in digital photography / processing, allow additional metadata to be stored in the image file.

So here’s a “avoid too much detail” view: there are three significant inline metadata formats here - Exif, IPTC and XMP. Exif is used by most digital cameras to attach information like exposure at the point you take a picture and tools are available for adding information manually (or automatically) such as geocoding. IPTC “extends” Exif, providing a whole load more named “tags” for metadata. Both are fragile from a technical point of view (easy to destroy / corrupt) and problematic from the point of view of extending (if there’s no named “tag” for the metadata you want to store, you’re out of luck). Meanwhile, XMP, the work of Adobe, is the “holy grail”, providing XML / RDF / Dublin core goodness for storing metadata. It’s just not well supported yet, but starting to gain significant acceptance. And of course our friend IE has it’s own opinion about XMP…

In practice, you need to be able to work with all three formats for effective photo archiving.

Image Archiving Apps

There are a bunch of image archiving tools out there, for any and all operating systems. A good one will allow you to manually supply additional meta data about an image (e.g. keywords like “family”, “dog” etc.) but, from a straw poll, the majority store this data separately from the image, in some kind of database. Where Ubuntu is concerned GThumb does just this - stores any user supplied meta data externally from the image (if I remember right, it’s under ~/.gnome2/gthumb).

There’s a bunch of reasons why I consider this fundamentally wrong, which become obvious the moment an image leaves your filesystem (or perhaps even changes directory / filename) plus the fact that there’s no “clear winner” in the image archiving space - there’s a good chance you’ll switch tool more than once. Bottom line: storing metadata separately from the image it refers to is just not the way to do it.

In the Open Source / Linux space, there are a couple of contenders which are getting it “right”, namely F-spot (C# / Mono) and jbrout (python / wxpython). Both are capable of storing metadata in the image but there are limitations, e.g. jbrout has no awareness of XMP. Some worthwhile blogs (and comments) to read are How to manage EXIF, XMP metadata on linux gnome kde, Managing Photographs and Photo organizing in Linux.

Image Archiving Done Right

By contrast, the model application, IMO, for how to do it right (sadly Win32 only) but free to use is PixVue.

For starters, rather than being an monolithic application, it adds a bunch of Windows Shell Namespace Extensions meaning you can work with your images in Windows Explorer - e.g. right click and “annotate” with your metadata.

As I see it “Digital workflow”, in general, is all about procedures - you need “process oriented” applications that fit into your procedure, rather than monolithic windowed views of your images, which dictate how you work. PixVue gets this right by getting out of the way and hence my desire to extend Nautilus.

PixVue also stores almost all metadata in the image, understanding EXIF, IPTC and XMP. The exception is the “grouping” metadata, which it provides something called “galleries”, which are a virtual directory hierarchy - in Explorer you can drag and drop images into a gallery (or galleries) to organise them but these are only “symbolic links” to the original files on your filesystem. You can also export your gallery structures as XML, to allow at least the chance of portability.

Also the “templates” functionality it provides helps make attaching metadata to a large collection of images as fast and painless as possible.

Finally it has excellent search facilities (via the gallery view) plus it “integrates” with (populates the indexes of) Windows search and Google desktop.

The only downside of PixVue is the source isn’t available and there doesn’t seem to be an API (it does register some COM components but, from a quick scan, these don’t allow you to drive it with, say, a Python script), so if you want to extend it to integrate with some geocoding tool, you’re out of luck.

Open Source Image Metadata Tools

So, given a less-than-ideal situation for Open Source image archiving applications, what’s available in the form of libraries, so you can hack your own?

The long and short of it is more bad news. There’s a whole bunch of libraries that do a little bit, perhaps only (partially) understanding one format (typically Exif), read only - not write or lacking support for manufacturer Exif extensions.

The situation is particularly acute when it comes to Python, which is badly lacking - there’s a few “readers” out there, and the occasional writer (no XMP writer though) but nothing that’s really complete. That’s bad news for jbrout and even more bad news for Python on Series 60 phones, where being able to tag your pictures, while you sit on a train, would be a killr app.

There are exceptions though, the #1 being Phil Harvey’s exiftool (Perl - available via CPAN). ExifTool isn’t just good - it’s excellent. It’s basically got it all - EXIF, IPTC and XMP support (read/write), support for manufacturer extensions and a common dictionary of tag names that are, to an extent, metadata-format-independent. The only downside is there doesn’t seem to be (correct me if wrong) a GUI front-end for Linux that exposes all of Exiftool’s functionality - you’re either talking command line or writing your own Perl scripts.

Another noteworthy exception Evan Hunter’s PHP JPEG Metadata Toolkit, which has EXIF, IPTC and XMP support and awareness of some manufacturer quirks. The API is also pretty simple.

The is of course plenty of other stuff around, which offer part of the picture e.g. jempbox (Java) but YMMV.

Anyway - hopefully that saves someone some time in research.

Elein showed how to use timestamps to keep an audit trail of all changes in your DB. With this technique, you never actually delete records, you just give them an end date. Multiple copies of a record (again, with timestamps for each one) also allow you to track edits. (This is a pretty standard approach, especially in ‘validated’ environments, or in government-regulated industries.)

The value of using Postgres here is in the advanced features like triggers that you can use with your deletes and updates to offload the work needed to maintain this ‘time travel’ system — rather than forcing your app logic to keep up with all of it.

You can also use PostgreSQL’s views to query the database for only the current data, or write procedural functions to query the state of the database at a particular point in time in the past.

Elein has her slides available online here.