Macromedia's Flash format is everywhere on the web. Uses range from
the (by now) passflying text to full form-based entry systems. Part
of the benefit of Flash is that the files used to describe a picture
are very compact. This is achieved by using bit-level fields and
compression within these SWF files. This made working with SWF fairly
hard.

Recently, Macromedia released the source code for a library that can
be used to create SWF files. It comes under a strange license: you can 
use it to create products as long as those products are themselves
used to create SWF files. You aren't allowed to distribute the source
of their library, and you must meet certain correctness criteria.

I downloaded a copy of the library. It comes with two distinct
APIs. The low-level API gives you access to the full power of Flash,
but is really little more than wrappers around the different tags that 
appear in SWF files. The high-level API has considerably less
functionality, but is a lot simpler to use.

As a proof of concept, I wrapped the high-level API and made it
available to Ruby programs. (I translated the sample programs that
Macromedia produced into Ruby and put the results up at
http://www.pragprog.com/flash. Don't expect anything fancy, these just 
exercise each of the different APIs). I don't think it would be hard
to move forward to wrap the low-level API.

Now, here's what I'm thinking. Currently, most of the Flash animations 
you see are produced once, and then served to clients multiple
times. A developer or designer creates the SWF file, sticks it on a
web server, and then we get to see it when the associated HTML is
accessed.

But, wouldn't it be cool if you could generate animations on the
fly? Say you wanted to produce a graph based on a database table. The
columns could be formed from animations. Each column could have
associated Flash actions, perhaps popping up details as the cursor
moved over them. You could have the graph change over time to show
trends.

Or perhaps you want to show a picture of a product, and then pop up
dynamic facts (such as price and availability) when the user clicks on 
it.

And so on.

Macromedia has a product that does this, Generator. It costs (I
believe) something like $1,000 (and over $30,000 for the enterprise
edition). It is fancy, and has a UI, and probably comes with lots of
drag'n'drop goodies to make attaching databases to movie elements
child's play.

But we could produce something which could do the same. Initially we
don't have (or need) a GUI, or lots of other goodies. Initially, we're 
simply a scripting extension, running under mod_ruby, that inserts
dynamic Flash objects in HTTP streams. We use Ruby's existing
libraries to link these to back-end data sources via CORBA, XML,
databases, and so on. And we use the flexibility of Ruby to make this
intuitive and easy.

I'm not a web designer, but it strikes me that this could be a major
application area for Ruby: Ruby's Zope.

So, what do people think? Is this worth putting effort into? How could 
it be developed. Is the Macromedia licensea problem? Could this be a 
killer app?


Regards


Dave




Footnotes: 
 http://www.macromedia.com/software/flash/open/licensing/fileformat/