Note that these are basic demos so if you know pretty much anything about animation in ActionScript, these may not teach you anything.

All these scripts do pretty much the same thing. They draw a square on the stage. When you click on it, it moves horizontally from x=100 to x=400. Each of these is a class that you can run as the main class of an AS3 application.

1. The wrong way

The wrong way, of course, is to use a for loop:

package
{
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.display.Sprite;
    public class BasicAnimation extends Sprite
    {
        // ------- Constructor -------

        public function BasicAnimation()
        {
            _createChildren();
        }

        // ------- Child display objects -------

        private var _rect:Sprite;

        // ------- Private constants -------

        private const START:int = 100;
        private const END:int = 400;

        // ------- Private methods -------

        private function _createChildren():void
        {
            _rect = new Sprite();
            _rect.graphics.beginFill(0xff0000, 1);
            _rect.graphics.drawRect(0, 0, 100, 100);
            _rect.graphics.endFill();
            _rect.x = START;
            addChild(_rect);
            _rect.addEventListener(MouseEvent.CLICK, _rect_click);
        }

        // ------- Event handling -------

        private function _rect_click(event:MouseEvent):void
        {
            // wrong way:
            _rect.x = START;
            while (_rect.x < END)
            {
                _rect.x++;
            }
        }
    }
}

The right way (most basic)

Of course, this one runs very slow since it’s moving at a rate of 1 pixel per frame.

package
{
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.display.Sprite;
    public class BasicAnimation extends Sprite
    {
        // ------- Constructor -------

        public function BasicAnimation()
        {
            _createChildren();
        }

        // ------- Child display objects -------

        private var _rect:Sprite;

        // ------- Private constants -------

        private const START:int = 100;
        private const END:int = 400;

        // ------- Private methods -------

        private function _createChildren():void
        {
            _rect = new Sprite();
            _rect.graphics.beginFill(0xff0000, 1);
            _rect.graphics.drawRect(0, 0, 100, 100);
            _rect.graphics.endFill();
            _rect.x = START;
            addChild(_rect);
            _rect.addEventListener(MouseEvent.CLICK, _rect_click);
        }

        // ------- Event handling -------

        private function _rect_click(event:MouseEvent):void
        {
            // right way (very basic):
            addEventListener(Event.ENTER_FRAME, _enterFrameBasic);
        }

        private function _enterFrameBasic(event:Event):void
        {
            if (_rect.x < END)
            {
                _rect.x++;
            }
            else
            {
                removeEventListener(Event.ENTER_FRAME, _enterFrameBasic);
            }
        }
    }
}

Adding velocity as a variable

The solution to the slowness is to add a velocity variable. The value (in units of pixels per frame) will determine how quickly the animation moves. Basically you just try different values until you’re happy with something. Like the previous example, this is a purely linear animation — the velocity stays constant.

package
{
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.display.Sprite;
    public class BasicAnimation extends Sprite
    {
        // ------- Constructor -------

        public function BasicAnimation()
        {
            _createChildren();
        }

        // ------- Child display objects -------

        private var _rect:Sprite;

        // ------- Private constants -------

        private const START:int = 100;
        private const END:int = 400;

        // ------- Private methods -------

        private function _createChildren():void
        {
            _rect = new Sprite();
            _rect.graphics.beginFill(0xff0000, 1);
            _rect.graphics.drawRect(0, 0, 100, 100);
            _rect.graphics.endFill();
            _rect.x = START;
            addChild(_rect);
            _rect.addEventListener(MouseEvent.CLICK, _rect_click);
        }

        // ------- Event handling -------

        private function _rect_click(event:MouseEvent):void
        {
            // right way (very basic):
            addEventListener(Event.ENTER_FRAME, _enterFrameBasic);
        }

        private function _enterFrameBasic(event:Event):void
        {
            if (_rect.x < END)
            {
                var velocity:int = 5;
                _rect.x += velocity;
            }
            else
            {
                removeEventListener(Event.ENTER_FRAME, _enterFrameBasic);
            }
        }
    }
}

Adding acceleration

Once you’ve separated out velocity, it becomes easy to make the animation non-linear by adding an acceleration value that causes the velocity to change over time. We’re just stepping back one level of complexity — the acceleration is now linear instead of the velocity.

package
{
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.display.Sprite;
    public class BasicAnimation extends Sprite
    {
        // ------- Constructor -------

        public function BasicAnimation()
        {
            _createChildren();
        }

        // ------- Child display objects -------

        private var _rect:Sprite;

        // ------- Private constants -------

        private const START:int = 100;
        private const END:int = 400;

        // ------- Private methods -------

        private function _createChildren():void
        {
            _rect = new Sprite();
            _rect.graphics.beginFill(0xff0000, 1);
            _rect.graphics.drawRect(0, 0, 100, 100);
            _rect.graphics.endFill();
            _rect.x = START;
            addChild(_rect);
            _rect.addEventListener(MouseEvent.CLICK, _rect_click);
        }

        // ------- Event handling -------

        private function _rect_click(event:MouseEvent):void
        {
            // right way (very basic):
            addEventListener(Event.ENTER_FRAME, _enterFrameBasic);
        }

        private var _velocity:int = 0;

        private function _enterFrameBasic(event:Event):void
        {
            if (_rect.x < END)
            {
                var accel:int = 3;
                _velocity += accel;
                _rect.x += _velocity;
            }
            else
            {
                removeEventListener(Event.ENTER_FRAME, _enterFrameBasic);
            }
        }
    }
}

Interpolating values over time

This next example doesn’t build on the previous ones but instead takes a completely separate approach to creating animation. This animation is time-driven rather than frame-driven. Instead of adding a particular number of pixels to the x value each frame, it calculates how much time has elapsed since the start and what the x value should be at that moment in time, then sets the x property to that value. A consequence of this approach is that regardless of the frame rate of the SWF, the animation will always last the same amount of time.

package
{
    import flash.utils.getTimer;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.display.Sprite;
    public class AnimationIntermediate extends Sprite
    {
        // ------- Constructor -------

        public function AnimationIntermediate()
        {
            _createChildren();
        }

        // ------- Child display objects -------

        private var _rect:Sprite;

        // ------- Private constants -------

        private const START:int = 100;
        private const END:int = 400;
        private const TOTAL_TIME:int = 5000;

        // ------- Private methods -------

        private function _createChildren():void
        {
            _rect = new Sprite();
            _rect.graphics.beginFill(0xff0000, 1);
            _rect.graphics.drawRect(0, 0, 100, 100);
            _rect.graphics.endFill();
            _rect.x = START;
            addChild(_rect);
            _rect.addEventListener(MouseEvent.CLICK, _rect_click);
        }

        // ------- Event handling -------

        private var _startTime:int = 0;

        private function _rect_click(event:MouseEvent):void
        {
            // right way (intermediate):
            _startTime = getTimer();
            addEventListener(Event.ENTER_FRAME, _enterFrameIntermediate);
        }

        private function _enterFrameIntermediate(event:Event):void
        {
            var elapsedTime:int = getTimer() - _startTime;
            var fractionComplete:Number = elapsedTime / TOTAL_TIME;

            if (fractionComplete < 1)
            {
                var totalDistance:int = END - START;
                var offset:int = Math.round(fractionComplete * totalDistance);
                _rect.x = START + offset;
            }
            else
            {
                _rect.x = END;
                removeEventListener(Event.ENTER_FRAME, _enterFrameIntermediate);
            }
        }
    }
}

The main point of this example is to demonstrate the idea that you can plug in an algorithm that calculates position given time, and by varying the algorithm you can vary the animation. This is a direct lead-in to the idea of using tweening functions to vary an animation, as demonstrated in the next example.

Using an animation library

This example shows the use of a third-party animation library (in this case Grant Skinner’s GTween library). The commented-out lines demonstrate how a library makes it easy to synchronize animation and vary the animation. Note that this is only meant as a very basic demonstration of the concept of using a library for animation — GTween and the many other animation libraries that are out there all provide many additional features.

package
{
    import com.gskinner.motion.easing.Bounce;
    import com.gskinner.motion.easing.Sine;
    import com.gskinner.motion.GTween;
    import flash.events.MouseEvent;
    import flash.display.Sprite;
    public class AnimationTween extends Sprite
    {
        // ------- Constructor -------

        public function AnimationTween()
        {
            _createChildren();
        }

        // ------- Child display objects -------

        private var _rect:Sprite;

        // ------- Private constants -------

        private const START:int = 100;
        private const END:int = 400;
        private const TOTAL_TIME:int = 5;

        // ------- Private methods -------

        private function _createChildren():void
        {
            _rect = new Sprite();
            _rect.graphics.beginFill(0xff0000, 1);
            _rect.graphics.drawRect(0, 0, 100, 100);
            _rect.graphics.endFill();
            _rect.x = START;
            addChild(_rect);
            _rect.addEventListener(MouseEvent.CLICK, _rect_click);
        }

        // ------- Event handling -------

        private function _rect_click(event:MouseEvent):void
        {
            var tween:GTween = new GTween(_rect, TOTAL_TIME);
            tween.setValue("x", END);
//            tween.setValue("alpha", .5);
//            tween.ease = Sine.easeInOut;
//            tween.ease = Bounce.easeOut;
        }
    }
}

Summary

New job. New city. New house. Moving tomorrow. Offline for a week or two. Don’t say anything important while I’m gone. (Sorry FATC, especially Reflex: no breaking announcements or innovation allowed. =)

1. Job

I am now no longer working for Adobe. I have started a new job with Dedo Interactive, Inc., as a Flash/Flex/ActionScript/AIR developer and also as an active collaborator with the UX design group. As Danny and Jonathan have already described, this is an exciting opportunity with a group that’s pushing the boundaries of hardware and software solutions. It’s also exciting for me to be a “regular developer” like everyone I hang out with and pretend to fit in with at conferences. Of course that’s where my roots are — in being a Macromedia/Adobe customer first before being an Adobe employee — so I’m just going back to the place that I’ve tried my best not to leave anyway.

2. Location

Since Dedo is located in Plano (N. Dallas) Texas, naturally it seems that I need to be located there too. Danny has been really great about letting me start as a remote employee. Nevertheless, I am typing this while mostly surrounded by cardboard boxes, as well as a few too many things that I should have already packed into cardboard boxes. In approximately 32 hours a moving truck will pull up to my house and load everything up. Then I’ll pack my family into a minivan and drive for many hours and days until we get to our new house. (Just signed the mortgage papers today — ack!)

3. Family

Fortunately, my family has agreed to accompany me on this crazy journey. I feel sad for my three young children. They’re obviously not happy to leave their friends and school and the life that they’ve known for the last three years. (My youngest doesn’t remember anything before California, and my middle child barely remembers anything else, in spite of the fact that they were both born in Indiana.) I’m grateful to have a wonderful wife and special children who make the hard times worth it, and who make the good times good.

4. Blog, Twitter, open source projects, conferences, etc.

Frankly, I have no plans to change what I’ve been doing with any of those. I’ve never been the most regular blogger or twitterer, and my projects don’t get updated as often as I’d like. That probably isn’t going to change with a new job and a new city. But the vast majority of my work on them has been on my own time anyway, so the fact that I’m no longer an Adobe employee shouldn’t make that situation any worse. In fact, the owners of Dedo said that they’re pleased with my community involvement, and want it to continue. I’m definitely still using AIR, ActionScript, and SQLite in my work, so I keep finding new things and ways to improve my projects.

5. Blah blah sentimental stuff

Adobe is a great employer, and a great company. In spite of all the negativity and mud-slinging that’s happening right now, I can say that I never felt bad or guilty about working for Adobe. On the contrary, I am proud to have worked for Adobe. I feel like Adobe is a good, ethical company that tries to make business decisions that lead to mutual benefit for partners and customers. (Don’t bother sharing your experiences to the contrary. I’m sure I could tell you plenty too. In spite of that, this is my opinion of the company and employees overall.)

In addition to my great employer, living and working and associating with the community in the San Francisco bay area has been a tremendous experience, and I consider myself very fortunate for it. I’m definitely sorry to leave, especially because of the great opportunities (being near Adobe HQ), the great community (I’m looking at you SilvaFUG), and the great weather =)

To all of you who I’ve met and become friends with over the last 3 years, farewell, and I look forward to seeing you online and at conferences of the future. I only regret that I didn’t get to come to one last meeting and tell you goodbye in person.

Meanwhile, I’ve been amazed to learn how many talented and community-oriented developers call the Dallas-Fort Worth area home. I’ve already attended one users’ group meeting and plan to attend many more. I look forward to getting to know you better.

As I’ve been preparing to move, I’ve been trying to go through my many boxes that I haven’t touched since the last time I moved across the country. I was a little astounded to find so many of my college (and even a few high school) notes, papers, textbooks, etc. among my possessions. I’m getting older and more cynical now, plus we have to pay the movers by the pound, so I tried to get rid of as much as I could bear. I was amazed at how much I’ve forgotten from what I once knew. (Some of my academic papers were quite impressive to me — and it was astounding to find my 2nd year Hebrew notebook and later my calculus notes, and consider the fact that I wrote all the scribblings in there. =) I also couldn’t help but think over the many people I’ve met and known and worked with in Houston (where I grew up), Salt Lake City (where I did my undergraduate), Bloomington Indiana (grad school and my first “real” job), and of course most recently the bay area. It’s quite astounding to consider the path that life has led me on, and how I’ve ended up where I am today.

My application has thousands of records in one particular table that I need to populate the display with. I was wondering if I can implement paging to speed up the retrieval of those records?

In fact he specifically wanted to know if it was possible to do data paging with the SQLRunner class in my air-sqlite library. The answer is yes it works, without even needing any changes to the library. See below for how to do that.

The easiest way to implement data paging (in other words, getting only a subset of a query’s results at a time) in a SELECT statement is to use the LIMIT..OFFSET clause in the SELECT statement.

In summary, you can put a LIMIT clause at the end of a SELECT statement and the result set will only include the specified number of rows:

SELECT * FROM myTable
LIMIT 3

Then to get the next 3 rows, you add an OFFSET value:

SELECT * FROM myTable
LIMIT 3 OFFSET 3

Fortunately, you can use statement parameters for the LIMIT and OFFSET values (although the docs don’t mention this — shame on me!):

SELECT * FROM myTable
LIMIT :limit OFFSET :offset

Then you just specify values for those parameters and you’re good to go.

I tested this using the SQLRunner class by adding a new set of unit tests and it worked just fine without any changes to the library. (Hooray for unit tests and FlexUnit support in Flash Builder 4 — they made it nice and easy to test this out since I already had the infrastructure in place.)

Here is the SQL statement I used for the unit test using LIMIT..OFFSET with parameters:

SELECT colString,
colInt
FROM main.testTable
LIMIT :limit OFFSET :offset

And here is the line of code that calls the statement (modified slightly for readability). test_result is the result handler function. The parameters object specifies that I want 7 result rows, starting with row number 3 (i.e. skipping 2):

_sqlRunner.execute(SQL, {limit:7, offset:2}, test_result);

As Peter points out in the comments, another approach to do something similar to data paging with AIR is to specify a number of rows to retrieve as the first argument to the SQLStatement.execute() method, then call the SQLStatement.next() method to retrieve additional rows from the same statement. This technique is described in the documentation so I won’t go into more detail about it here except to say that it does have a couple of drawbacks (mentioned in my comment below) that make it less suitable for data paging (but still very useful).

The next 360|Flex conference is coming up quickly — March 7-10, 2010 in San Jose, California. As I’ve been preparing for the conference and reading some of the things other people are saying about it, I’ve been reminiscing about past 360|Flex (and other) conferences I’ve been to, and about how much they’ve impacted me professionally and personally. (Hint: a lot.)

But I’m not here to talk about the past. (Or about what I’m presenting at the conference, since I’ve already mentioned that.) Instead, I’d like to talk to you about this 360|Flex, and why I’m excited to attend and what I’m looking forward to most. These fall into two categories: Sessions I’m looking forward to, and people I’m excited to meet (or see again).

The sessions (in schedule order)

I combed over the whole schedule, and there is literally not a single time slot that I’m not looking forward to. Except the ones where I have to choose from two or three awesome-sounding presentations. Frankly, what I’m not looking forward to about 360|Flex is that I’ll have to choose not to attend some sessions that I’m really anxious to see.

Sunday

Sunday afternoon: Joel Hooks: Hands-on development with the Robotlegs AS3 framework (I’ve mentioned I’ll be helping with this, but I’d definitely attend if I wasn’t)

Monday

Keynote: Is this Deepa’s first keynote, now that she’s a Flex Product Manager and not an engineer anymore? She spoke to my users’ group last week talking about Flex “next” (i.e. after 4). I have no idea what she’ll talk about here, but I’m looking forward to it!

Monday 1: Already there are too many to choose…Michael Labriola (Flex components), Chase Brammer (analytics) or Richard Lord (“Designer Last” architecture)?

Monday 2: Drew McClean and RJ Owen - Rules engine with AS3 and Hamcrest (time to find out what the buzz is about), although if I was doing more video work I’d definitely hit expert David Hassoun’s session (OSMF), or maybe I should broaden my horizons/prepare for the future with Bryce Barrand (How to find and keep top developers)

Monday 3: Again, I can’t decide…Garth Braithwaite on skinning, or Jesse Warden on Robotlegs and Gaia?

Tuesday

Morning panel discussion (“Principles for RIA design”): Don’t discount this because it’s early. Keith is a great facilitator (he’s a co-manager of my local users’ group) and from the things I’ve heard, there will be lots of great ideas shared in this session.

Tuesday 1: Alas, I’m speaking in this slot so I’ll miss Deepa’s Flex 4 talk and Aaron Pedersen and James Polanco’s Flex 4 lifecycle talk. Will anyone notice if I just skip out and go to their sessions instead?

Tuesday 2: Jacob and Tyler Wright (and Ben Stucki, I think!): “Reflex: Rethinking Component Design.” I got to hear about the ideas behind this component/layout framework in conversations at the last 360|Flex conference, and I’ve been dying to try it out since then. Revolutionary stuff will appear here!

Tuesday 3: Yet another tough choice: Elad Elrom on TDD, Randy Troppman and Adrew Westberg on GPS in Flex, or Aaron Hardy on Queue and Cache?

Wednesday

Keynote: always fun and informative — hear the behind-the-scenes of the conference, and win prizes too!

Wednesday 1: Why do they have to make it so hard to choose! Renaun Erickson (“AS tips for iPhone games”), Jeff Tapper (don’t even know but always extremely valuable), or Sim Bateman (“Getting Git”)?

Wednesday 2: I think I may go to the dark side for a bit, and learn more about Silverlight from Jun Heider. But Nate Beck’s “Flexible games” looks mighty tempting too…

Wednesday 3: Eric Fickes with Silverlight, part 2, Shashank Tiwari on multi-touch, or Andy Powell on UX? John and Tom, you’re making this so hard!

Wednesday 4: (at least) two presentations worth sticking around for: Matt Guest on Flex text with TLF, and Huyen Tue Dao on Greenthreading

So yes, I’ve realized I’m going to have to make two clones of myself (at least) in order to attend all the sessions I want to see. And then I’ll have to merge them back together somehow. I’ll get back to you on how that one turns out…

The people

Richard Lord really nailed it when he said that the best part of conferences, especially smaller ones like 360|Flex, is getting to meet and talk with and throw ideas around with other developers. I’ve learned some good things in the sessions at past conferences, but by far my best memories and most valued times are the ones I spent between sessions and evenings/nights kicking around ideas with others.

These are my “conference friends” (and a few “users’ group friends) who I’ve met at conferences and always look forward to hanging out with again. I’m sure you know their names, and like me you may wonder why they’re actually willing to talk and hang out with someone like me =) But I’ve never gotten any attitude from these (or other) “superstars” that I’ve met in person at conferences. That’s reason 1 I love the Flash/Flex community — these people welcome ideas, and are just excited to meet people and share:

• Renaun Erickson
• David Hassoun
• Jun Heider
• Doug McCune
• Clint Modien (C’mon Clint, you know you want to be there)
• Tom Ortega (his last 360|Flex as an organizer!)
• Andy Powell
• Todd Rothe
• Ryan Stewart
• Ben Stucki
• Bryce Barrand
• Jac Wright
• Tyler Wright

And these are the people who I’ve learned from whose work I’ve admired online, who I’m hoping to meet and get to know “in real life”:

• Sim Bateman
• Garth Braithwaite
• Joel Hooks
• Kevin Hoyt
• Richard Lord
• Jesse Warden
• Yakov Fain

And the best part is, there are plenty of others that I will meet, that I don’t know (or even know of) yet, but who will be on my “conference friends” list for the next 360|Flex =)

It turns out that my thinking on that topic isn’t going to become anything in the Adobe documentation. So I’ve sort of just been sitting on my ideas with the idea that someday I’ll probably share them.

Which brings me to this post.

Aside: upcoming presentations on multi-screen development

This is really a side note to the main ideas here, but I thought I’d mention it since it’s the reason I actually stopped to write this. In one of my mind-wandering moments this morning, I realized that at the upcoming 360|Flex conference (San Jose, March 7-10) I’ll be involved in two presentations that are directly related to practical aspects of building multi-screen apps:

• As part of the pre-conference free training, Joel Hooks and I are doing a four-hour training on using the Robotlegs micro-architecture. (Joel is the main speaker, fortunately, because he’s one of the core Robotlegs developers and the main “evangelist.” I’ll be helping out, to try and help save his voice and maybe to help find typos. =)

  If you’re wondering what a Robotlegs session has to do with multi-screen apps…keep reading, it’s explained below.

• On Tuesday and Wednesday, Renaun Erickson and I are giving (two separate) presentations about building iPhone apps using Flash Platform tools. My session is more of an intro into the workflow, how it’s similar to other app building, and how it’s different. (Plenty of code to look at — don’t worry!) Renaun is going to get more into specifics of building a game, as well as some more intermediate/advanced topics like performance.

Funny that I never really made that connection until this morning. I guess subconsciously I knew this is a direction I want to move in, and that’s why I’ve been focusing my learning (and hence my presenting) on these topics =)

Background

While I was partially trying to keep my thinking abstract, from a practical perspective I centered my thoughts around developing using the Flash Platform. So conceptually, what I was thinking about was the idea of making a single “app” for multiple screens, which would mean that (in the technology of the next year or so) it could be potentially take several forms:

• a browser/computer app (Flash Player)
• a browser/mobile app (Flash Player)
• a desktop app (AIR)
• a mobile (iPhone) app (Publisher for iPhone, similar to AIR)
• a mobile app for other devices (AIR)
• a TV app or widget (Flash for the digital home)

(Obviously many of these are only out in public beta, some have only been vaguely publicly acknowledged, and others may or may not ever exist as actual Adobe products =)

One app, or many?

Back when I started thinking about this, there seemed to be two main camps. One group was a strong advocate for the “single source” idea: you would build one SWF or one AIR app and distribute that same app on any platforms (desktop/mobile/TV). Obviously a key element to that, especially for desktop/mobile apps rather than browser apps, would be having code that detects screen size and device capabilities and adapts the UI to the device.

The second group felt that it was more likely that developers who are creating an app for multiple screens would actually create multiple apps (from the perspective of the IDE). The apps would obviously share some code, visual assets, etc., but would be different enough that they’d be created separately and distributed as separate file types. (In the case of apps created for the iPhone, of necessity this has to be true, at least in terms of the publishing part.)

Since I try to be pragmatic about things unless I have a really good reason, I favored the second viewpoint. However, I acknowledge that in some circumstances the first approach might be used. As always, I think that developers are going to use a mix of approaches.

For example, suppose I’m building an app and I want to create a version for desktop computers, a version for the iPhone, and a version for other mobile devices. Personally I see this not just as an issue of “porting” the app from one platform to another. I think that each device has its strengths, and more importantly, each device is used for different purposes and in different contexts. If I’m building an app for a device, I should definitely be taking that notion of context into account as I’m designing the app. That pretty much rules out the possibility of using the exact same app (UI and everything) for both computers and mobile devices, unless I want it to run as a widget-type app on the desktop.

Also see: Adobe Flash Platform contextual applications developer center

Adaptable code to the rescue

On the other hand, that doesn’t mean that developers will always create completely separate projects. For example, suppose I’m creating an app for iPhone, and another for another mobile device. Or perhaps I’m using the Publisher for iPhone to create an iPhone version of my app and an iPad version. If my app is a game where I can more freely discard the conventions of the platforms, perhaps the only platform difference I need to consider is the difference in screen dimensions and pixel density. In that case, it’s quite possible that I can .

Even for a more line-of-business or productivity app, one of the key ideas in Slider, the future Flex mobile framework, is to (as much as possible) abstract away platform convention differences. For example, if iPhone usually puts the back button on the top, and another platform puts it on the bottom, and another platform puts it in a menu, and another platform has it assigned to a physical button on the device, then Slider might have a “back” event that you can hook into, and you can make your app perform the necessary “back” tasks regardless of platform.

Design patterns to the rescue

And, of course, in some situations you’ll almost surely need to create different versions of apps for different screens. For example, suppose you’re building a desktop Twitter client and a mobile Twitter client. Chances are good you’ll put some functionality into the desktop version that doesn’t go into the mobile one — such as previewing images, or maybe Facebook integration. On the other hand, adding a feature like automatic location tagging would make lots of sense in the mobile version, but not so much in the desktop one.

As I was thinking, many months ago, about the idea of efficiently creating different versions of the same app for different devices, a thought hit me like a ton of bricks. This is exactly the use case that the oft-mentioned “separation of concerns” is designed for:

Over several years, various “micro architectures” and “application frameworks” have emerged and waxed and waned in popularity. Many of these architectures are modeled around the “Model-View-Controller” design pattern (or its many variations).

One of the key benefits that these architectures claim is that it helps you keep the pieces of your application separate, without explicit links and dependencies between them. I’ve looked into and even tried out several of these over the years. One example that is frequently used to describe the notion of separation of concerns, which I always struggled with, goes something like this:

Suppose you’re creating an app, and you build the user interface and the other logic like server communication and data processing. If you use MVC/separation of concerns, then it’s really easy to just rip out your whole user interface layer and replace it with a new one.

They usually lost me with that one. As much as I tried, I couldn’t imagine a situation in which I’d want to build my app and then just rip out the UI and replace it with a different one note 1.

Until now.

Suddenly I had discovered, for myself at least, a real-world use case for the separation-of-concerns-so-you-can-swap-out-the-UI argument. If I’m building an app for the desktop and mobile, I’d like to be able to reuse my code where I can. At the same time, some functionality is only going to apply to one app or the other, so it’d be nice to be able to plug it in cleanly. Oh and by the way, the user interfaces are going to be different, so being able to swap those out is an absolute must.

I’d always liked micro-architectures in general, if only because I like knowing that I’m building my app using some pattern or structure that is based on developers’ real-world experience. It’s much nicer than trying to invent it myself and having to deal with all the pain points they’ve already gotten over. Now that I am imagining a world where I create multiple versions of the same app, with similar functionality but different user interfaces, suddenly micro-architecture patterns have become indispensable in my mind.

Conclusion

These are only just a few of my thoughts about the future world of multi-screen, contextual applications. Like Lee Brimelow, I believe that going forward building multi-screen, multi-context apps is going to be a much more common scenario. From my perspective as someone who thinks a lot about user experience design, and trying to optimize tools for the task and context, I think this is one of the most exciting aspects of the current technology revolution. I’ll definitely continue to share my thoughts and ideas in the future (hopefully more practical ones, too, not just abstract ones like this =)

Notes

Note 1: Just to be clear, I’m not trying to sound negative about MVC or micro-architectures/frameworks. Most of them provide many benefits, many of which are also related to the idea of separation of concerns, such as making code easier to test, making code cleaner, reducing boilerplate code, providing structure so that teams or developers who inherit a project can get going more quickly, etc. Swapping out the view layer is just one little benefit they mention. (back)

For lack of a better name, I call it my “AIR SQLite utility library”

The code currently contains one major piece of functionality (well, two different variations on one bit of functionality), which is a SQL “query runner” library. This is a wrapper for the AIR SQL classes that allows you to run a SQL statement by just passing a few bits of information:

• The text of the SQL statement itself
• An object containing properties with the values for any statement parameters in the SQL
• A Function to call when the operation completes
• A failure Function
• (optionally) a class to use as the data type for the data returned from a SELECT statement

The library does all the work of creating SQLStatement objects and caching prepared queries, as well as pooling SQLConnection instances so you can execute multiple statements simultaneously. It also has a variation that allows you to specify a “batch” of statements to execute, and they are executed in order in a transaction.

I’ve also got an additional utility to add to the library. It’s a “database copy” utility that allows you to create a “deep copy” of a database — all it’s tables, views, etc. — with or without data. The key reason why this is useful is that you can use it to create an encrypted database from an unencrypted database (and vice-versa). It’s written and tested, but I decided to modify the structure slightly before releasing it, so it’s not checked in yet.

I’ve put the details about how it works and why it’s designed that way in the project page. In case you’ve ever wondered how I design apps, I think the examples and this library give some insight into how I actually do my database-driven AIR app development. At least, how I structure the data-access part of my apps.

On (another) personal note, this project is also my first project that I’ve posted to my Github repository (as opposed to projects I’ve forked). It was actually posted-but-not-advertised on Google code for a month or so, but I decided to move to Github because the collaboration and checkin-without-network-connection features are so awesome.

Normally in SQL, including in AIR’s built-in SQLite database engine, you can only add data to one table at a time using an INSERT statement. In some cases, particularly when you’re doing a “bulk loading” operation such as importing data from a text file into a database, it’s convenient to be able to insert data into multiple tables using a single INSERT statement.

For example, suppose you have XML data to import into a database such as the following:

<?xml version="1.0"?>
<employees>
    <employee firstName="Bob" lastName="Smith"
        location="San Francisco" country="USA"/>
    <employee firstName="Harold" lastName="Jones"
        location="San Francisco" country="USA"/>
    <employee firstName="Tom" lastName="Donovan"
        location="Boston" country="USA"/>
    <employee firstName="Mike" lastName="Wilson"
        location="Calgary" country="Canada"/>
    <employee firstName="Steve" lastName="Thomas"
        location="London" country="UK"/>
    <employee firstName="Joe" lastName="Nelson"
        location="London" country="UK"/>
    <employee firstName="Juan" lastName="Varga"
        location="Buenos Aires" country="Argentina"/>
    ...
</employees>

The XML data isn’t normalized, so there is duplicate data between the various records. We will import it into a database with the following (normalized) structure:

Assuming the data is going to be imported as a single user operation, it would be painful to need to prompt the user or throw errors for every duplicate entry.

Using the technique described here, you can use a single SQL statement to add an employee and if necessary any related data including office location and country. (You would still loop over the data and execute one INSERT statement per employee record — but you wouldn’t need to execute three INSERT statements per employee record, or need to check for duplicate office locations and countries for each employee record to be inserted.)

As mentioned above, this technique is probably only appropriate when you’re doing “bulk importing” of data. If you’re just adding a single conceptual record (even if it includes data in multiple tables) you’ll most likely want to use a series of INSERT statements to add the data, so that you can have more precise error checking and handling.

How to do it

In an attempt to “cut to the chase” I’m going to put the necessary code here. For more detailed explanations on how this works and why it’s necessary, see the “details” section below.

This technique for inserting data into multiple tables using a single SQL statement consists of three elements:

1. A view in the database that groups the data to be inserted (from all the tables) into one “table”
2. An INSERT statement to add the data, using the view as the destination “table” in the INSERT statement. This is the INSERT statement that you’ll run from your application while importing the data
3. A trigger defined on the view, which runs when any INSERT statement is executed against the view. This trigger does the actual work of checking for existing data and inserting data into individual tables.

Here’s the code for each part:

A view grouping the data to insert

This combines all the tables that potentially need data inserted into a single “table” for the INSERT statement. You run this statement once to create the view in the database.

CREATE VIEW employees_for_insert AS
SELECT e.firstName,
    e.lastName,
    l.name AS locationName,
    c.name AS countryName
FROM employees e
    INNER JOIN locations l ON e.locationId = l.locationId
    INNER JOIN countries c ON l.countryId = c.countryId

An INSERT statement that “inserts” the data into the view

This code isn’t actually run, but it passes all the data to the database engine for use in the trigger. You execute this SQL statement once for each record to add to the tables.

INSERT INTO employees_for_insert
(
    firstName,
    lastName,
    locationName,
    countryName
)
VALUES
(
    :firstName,
    :lastName,
    :locationName,
    :countryName
)

An INSTEAD OF trigger defined on the view

This is the code that actually runs when the INSERT statement above is executed. You run this code once to create the trigger. Then the database runs the code in the trigger body automatically. If a location or country doesn’t exist it is inserted. However, if they do exist, nothing happens (no duplicate record is created). Then the main employee record is inserted.

CREATE TRIGGER insert_employees_locations_countries
INSTEAD OF INSERT
ON employees_for_insert

BEGIN

INSERT INTO countries (name)
SELECT NEW.countryName
WHERE NOT EXISTS
    (SELECT 1 FROM countries
     WHERE name = NEW.countryName);

INSERT INTO locations (name, countryId)
SELECT NEW.locationName, countries.countryId
FROM countries
WHERE countries.name = NEW.countryName
AND NOT EXISTS
    (SELECT locationId
     FROM locations
     WHERE name = NEW.locationName);

INSERT INTO employees (firstName, lastName, locationId)
SELECT NEW.firstName,
    NEW.lastName,
    locations.locationId
FROM locations
WHERE locations.name = NEW.locationName;

END

Details

The SQL language is designed for working with relational databases, so in a SQL database you usually use multiple tables to represent a single piece of data. That means that in a normal scenario, if you want to add a new record to a table, you may need to add a new row of data to additional tables that the main data is related to.

In this example, we are using a database with the following structure:

This data represents employees in a large company that has multiple office locations, identified by records in the locations table. In fact, this company is an international company that has offices in different countries, including multiple offices in some countries (represented by the countries table.

Each employee is associated with their primary office location by the locationId field in the employees table, and each location is defined as being in a certain country by the countryId column in the locations table.

In order to add a new employee you would generally have to perform several steps:

1. Check whether the country where the employee’s office is located exists in the countries table
2. If not, add it; if so, get its id to create the relationship with the locations table
3. Make sure the office location exists in the locations table
4. If necessary add the location record, and get its id to use in the employee record
5. Add the employee record to the employees table

This is a fairly complicated process because a single SQL INSERT statement can only operate on one table at a time. In a simple case where you are adding a single employee record, this complexity isn’t unbearably difficult. You can execute the series of SQL statements in sequence in a single transaction. If an error occurs, you can break out of the sequence and display an error message or handle the error as desired.

However, if you’re importing a large set of data it’s not convenient to throw errors or display dialogs to the user. Instead, it would be nice to be able to just add any dependent data where appropriate, and insert all the data in one step.

The technique that’s described in this article makes use of database views and a SQLite feature known as INSTEAD OF triggers.

A view is a predefined SELECT statement that’s saved in a database so it can be used in queries as though it was a table. Because it usually includes data from multiple tables, and doesn’t necessarily include all the data from any given table, a view is generally read-only — you can use a SELECT statement to retrieve data from a view, but you can’t use an INSERT, UPDATE, or DELETE statement to modify the view data.

However, in SQLite (and consequently in AIR) you can define a special type of trigger that’s associated with a view known as an INSTEAD OF trigger. (A trigger is a set of SQL code that’s associated with a table. The code is executed when a data manipulation operation is performed on that table.) When a SQL statement attempts to perform an INSERT, DELETE, or UPDATE operation on the view that has an INSTEAD OF trigger defined for that particular operation, the trigger is executed instead of the specified operation. You can only define INSTEAD OF triggers on views (it wouldn’t make sense to use one for a table). For more information about triggers, see the Adobe AIR SQL reference documentation for the CREATE TRIGGER statement.

In this example, a view is defined that includes all the data in all the tables that potentially need data inserted. When the INSERT statement is executed the database runs the trigger instead. The trigger contains code that checks whether related data in the locations and countries tables already exists, and adds it if necessary. Then it adds the employee record with the related key values.

Apparently the article got lost in the shuffle, and about a week ago they found it and asked me to review their changes. I just found out that the article was published today.

Although it’s grouped under the “quick starts” category, it has a lot of detail. Also, it’s included in the Flash developer center but Flex developers shouldn’t be put off by that. It’s really about a core ActionScript class that’s available anywhere you’re writing ActionScript. (I’ve always found the ADC’s forced boundaries between Flash, Flex, and AIR to be too constraining for reality.)

I personally think the article provides a good, in-depth introduction to various aspects of working with the Vector class. In particular, it has guidance on areas that some people find problematic, such as the type parameter syntax and the fact that you have to provide your own custom sorting code (and of course the article includes examples to copy). I personally think it’s better than the developer guide documentation on the Vector class. (And I wrote them both so I’m not just showing a bias for my own work =)

My boss asked me to review a report he’s been working on. He wrote it in a wiki page. I reviewed it mostly while I was riding on the train to work this morning (without network connectivity), so I didn’t make any changes to the wiki page itself but instead wrote notes in a Word document. Once I had finished my notes, I wanted to discuss them with my boss, but I was having a bit of trouble figuring out how to do it. Although I don’t think I was explicitly thinking about it, in retrospect I think I was looking at the situation with a few requirements:

• I wanted to share my comments in person, rather than (for example) sending them by email.
• I wanted to be able to share them in context, i.e. while actually looking at the report.
• I wanted to minimize the disruption to my boss. We didn’t have a planned meeting (it wasn’t a formal review) so I planned to go to his cubicle and didn’t want to have to ask him to come back to my cubicle just to see my notes.

That was the problem in a nutshell. The notes were in a Word file on my computer in my cubicle. I wanted to go to my boss’s cubicle to discuss the notes so I needed a way to bring the notes with me to his cubicle. I had pretty much resigned myself to the idea that I would need to carry my laptop over to my boss’s cubicle and read my notes from it while we looked at the report on his monitor — but I wasn’t completely happy with that idea. (I’m not that lazy — my laptop is just hooked into a docking station and it’s really flaky about running on battery power unless you disconnect it in just the right way, which involves putting it to sleep twice and logging back in twice, among other steps. So there was a reason I didn’t want to have to go through that process.)

Suddenly I thought of a straightforward solution — so basic in fact that it really struck me that it wasn’t my first instinct (whereas previously it would have been).

Are you ready for it?

Here it comes…

I printed my Word document and carried the paper in my hand to my boss’s cubicle, together with a pen for taking notes.

Genius! The perfect solution for my requirements! The only thing noteworthy about it is that I realized it’s so extremely rare for me to print anything that it is apparently no longer an obvious course of action for me. I guess on a personal level at least I’m getting close to a paperless world.

And just in case this story makes me sound really unproductive, I should point out that this whole train of thought probably took no more than a couple of seconds. I wasn’t really investing that much time into it =)

A couple of years ago, before AIR beta 1 (“Apollo”), I wrote a tool for testing SQL statements in AIR. Later (I can’t remember exactly when) I released it under the name “Doppler.” I had plans to make it a full-fledged database management tool, but those plans never really panned out. I’ve told this story lots of times now, about how I now use (and even help develop) David Deraedt’s “Lita” SQLite admin tool.

However, “Doppler” in its current form served a different need than Lita — Lita is great for creating and managing database structure (you’ll never have to write a CREATE TABLE statement again), but it isn’t as strong for testing individual SQL statements. Over the past several months I’ve been doing some “serious” app development, working on an AIR app that makes heavy use of SQLite. I found my little tool to be quite handy, and also found and implemented a number of small improvements that make it much more useful.

Since my original intentions were never going to come to fruition, and I had new future plans for the app, I decided a new name was in order. Since it is for running SQL statements, “run” was an easy and obvious choice. So now, (several weeks after posting it), allow me to officially introduce you to the Run! AIR SQL query authoring and testing tool — the next generation of Doppler.

If you look at the full feature list for the latest release, you’ll see that I’ve added several types of changes. A few of the ones that I’ve found most useful in my day-to-day work are:

• Auto-update and badge install — no more downloading the .air file (admittedly not a big deal) and no more uninstall and reinstall each time there’s a new version (a big deal)
• “Recent SQL files” and “Recent databases” menu items
• Opening and saving SQL files (plus keyboard shortcuts)
• “Row count” and “execution time” displayed for SELECT statements
• Line numbers and auto-indent in the SQL panel

And yes, I did say “day-to-day” work. On some days, Run! has been my primary IDE, as I’m writing and testing and rewriting large SQL statements. It’s been kind of strange and kind of fun building a developer tool and using it as much as I use Run!.

I’ve already gotten a bug report and I’m working on features for the next big release, so if you have thoughts or comments please comment on the project page!

A few years ago I was working as a developer for a computer training department at a large midwestern university*. I also wrote and taught training courses for them. As jobs tend to do, the work was often in cycles — sometimes I’d spend a few months doing mostly coding, then perhaps I’d be working on a new workshop so I’d spend most of my time writing for a few months.

At one point I was in the transition phase, moving off of a “coding” cycle and into a “writing” cycle. One day while I was writing (in Adobe Framemaker — the word processor we used) I realized that each time I reached the end of a sentence my first instinct was to type a semicolon rather than a period. Too many lines of code written, I guess!

Anyway, I was reminded of that today when something kind of similar took place. Nowadays of course most of my writing, whether code or documentation, is done on a computer. In fact it’s fairly common that when I reach a stopping place while writing in a web browser (such as editing a wiki page) I instinctively type Ctrl+S to “save” (even though that just opens up a dialog to save the HTML of the page, rather than actually saving my work in the wiki or whatever. Today, however, this instinctual behavior was taken to a new level.

I was in a meeting and I had a thought about something I’ve been brainstorming since yesterday. It’s a new project I’m starting on (a documentation architecture project, not a coding one) so I’ve started by just jotting down thoughts in a notebook as they occur to me. I pulled out my notebook and wrote down my ideas. Then I felt a sort of funny twitching in my left hand — my left pinky and middle finger were instinctively trying to perform some sort of repetitive action, and couldn’t quite figure out whether it was appropriate or not. I realized that since I had just finished writing down a thought, my hand was trying to make the gesture for Ctrl+S in an attempt to “save” my “document”. Because of this my brain was momentarily confused — like it somehow knew this action didn’t quite fit in this context (pen and paper) but couldn’t figure out exactly why that was the case. Since of course, mentally I knew I needed to hurry and save my work so that it wasn’t lost.

Anyway, that’s my funny story for the day. Probably for the rest of my life, at least in terms of publishing at this url. So I hope you enjoyed it =)

* Note

My use of the term “large midwestern university” is also an attempt at humor — its an academic inside joke. I went to graduate school at Indiana University (the same “large midwestern university” where I later worked) and we students often read academic papers published by our professors or their former students. In the spirit of anonymity, when they described the participants in their research studies they never described their study participants as “students at Indiana University” or something like that. Instead they always described them as “students at a large midwestern university” although the authors’ biographies would always indicate their affiliation with Indiana University, so there really wasn’t any anonymity about it at all.

But not any more. A few days ago I checked in a beta (barely tested) version of that adds support for Flash Player 10 (browser) projects. It’s not linked from the main google code project page yet, but you can get to it from the GZIP encoder project downloads page.

The download that adds Flash Player 10 support is “ascompress-.2.0.zip”. It now includes two SWC files:

• GZIPEncoder_AIR.swc is the full package, with all the same features as the previous release (.1.0.2).

• GZIPEncoder_Flash.swc is the Flash-Player-only version. It only compresses/uncompresses ByteArrays, and doesn’t have any support for files.

  Of course, since Flash Player 10 also adds local file opening/saving support that uses ByteArray data for the files, you could easily write your own code to prompt the user for a gzip file, or compress a file and prompt the user to save it. For an example of opening and saving files from Flash Player 10, see my quick start article: “”

As I implied when I described this as “beta (barely tested)” I haven’t done a lot of testing of this code yet. I don’t actually anticipate that there will be issues — really all I did was refactor the code into two classes instead of one — but that doesn’t mean there won’t be any issues, of course. =) If you’re interested, and especially if you’re one of the people who’s asked for this support, I would love it if you try it out and let me know how it works for you. If you’re willing to test it out, I’ll be happy to quickly make any fixes necessary.

As you may have heard among all the news that’s coming out from MAX right now, Adobe AIR 1.5 has just been released. Most of the features of AIR 1.5 are features that were introduced with Flash Player 10. However, one new feature in AIR 1.5 that helps address the easy-to-read database issue is AIR 1.5’s new support for AES encrypted databases.

I’ve had the interesting and at times complex job of writing the documentation for this new feature. The bulk of the new documentation is in a new section “Using encryption with SQL databases” in the SQL database chapter of the manual “Developing Adobe AIR Applications”.

It’s pretty straightforward to use an encrypted database. You have to create the database as an encrypted db. To create or open it, you call the SQLConnection class’s open() or openAsync() methods, just as you normally do, and there’s a new parameter where you provide a 16-byte ByteArray encryption key for the database. That’s all there is to it.

The SQLConnection class also has a new reencrypt() method, that you use to change the encryption key of an already encrypted database.

If you want to see some code examples, check out the documentation listed above, or see these quick start articles on the Adobe developer center:

• Working with the encrypted local SQLite database (Flex)
• Working with the encrypted local SQLite database (Flash)
• Working with the encrypted local SQLite database (HTML/JavaScript)

There are a couple of parts of the new documentation that I think are particularly interesting (although I’m obviously biased since I wrote it all):

• Considerations for using encryption with a database talks about some of the various reasons you may want to use an encrypted database, and some of the differences in how you might architect your application to account for the desired level of security and privacy.

• Example: Generating and using an encryption key goes into great depth into one technique for creating an encryption key for your database. You have to provide a ByteArray encryption key to encrypt your database. How you come up with that encryption key can have a big impact on the actual security of your app data.

  This was definitely the most involved example I’ve written for the documentation. the techniques it uses were specified to me by security engineers at Adobe. The documentation goes into lots of detail describing how these techniques are used and why. Both the code and the text went through a series of reviews by engineers and security experts.

  I ended up writing the example as a simple UI, plus a class that anyone can just pull into their own app (rather than having to pull apart the example and turn it into something you can use. I’m also excited to share that Mike Chambers and Christian Cantrell decided that this “encryption key generator” class is useful enough that it’s now included in the open-source ActionScript 3.0 core library (as3corelib) project.

Now that AIR 1.5 is out the door, I’ve updated my AIR database admin tool to support encrypted databases (when you try to open an encrypted database it prompts you for an encryption key, which you enter as a Base-64 string). I already mentioned that I wrote the encryption key generator class that’s now in as3corelib. I’ve also got at least one more new encrypted database-related open-source project that I’m about to release…but I’ll wait until the MAX “firehose” dies down a bit before I write more about that one. =)

As I mentioned briefly before, this week I presented at the 360|Flex San Jose (August 2008) conference. My presentation was titled “Adobe AIR SQLite: An optimization conversation.” As I mentioned in the presentation, the term “optimization” could mean a few different things — for example, optimization meaning improving performance, or optimization meaning improving developer productivity. While my presentation focused mostly on the first type of optimization, I included suggestions for tools, libraries, and strategies that fall in the “developer productivity” type of optimization as well.

Anyway, as always I’m happy to make my presentation materials available. Here are the slides (with some notes) from my presentation:

“Adobe AIR SQLite: An optimization conversation” slides (PDF in .zip - 504kb)

I don’t really have any specific code examples, apart from what’s in the slides, so there’s no “source code” download. However, I did link to a lot of external tools and resources (including a few of my own). To save you the trouble of digging into the PDF, here are the links:

Tools

• Cristophe Coenraets’ “SQLite Admin”
• My tool for testing queries
• “Lita” by David Deraedt (I learned about this one after the presentation, so it’s not discussed in my slides/video, but I thought it’d be worth mentioning anyway.)

Application architecture/patterns/libraries

• SQLite MXML wrapper classes (Peter Elst)
• Data access layer (Brandon Ellis)
• asqlib SQL statement generator (Miran Loncaric)
• “Command” classes (me) as demonstrated by my AddressBook sample application
• AIR ActiveRecord source and blog post explaining its usage (Jacob Wright)
• AIR SQLite Cairngorm services (Eric Feminella)
• Connection and statement pools, mentioned (with source code) in the article User experience considerations with SQLite operations (Daniel Rinehart)

Finally, as you may have heard, Adobe sponsored the recording of every presentation at 360|Flex, and they’re all going to be made available free of charge via a channel in Adobe Media Player. They’re rolling them out in phases, and mine isn’t available yet. When it is, I’ll update this post with the video as well. Update: the video is now available on Ted Patrick’s blog as well as in Adobe Media Player.

In the mean time, 360|Flex was full of awesome presentations. I wasn’t able to get to all the ones I wanted to see, due to conflicts and me trying to finish up preparation for my presentation. So I’m going to be spending some time watching many of those videos as well. If you’d like to see the videos, Ted Patrick has posted instructions on his blog:

How to view 360|Flex San Jose 8/08 session videos in Adobe Media Player

In all those presentations I promised to make my slides and code available. For those of you who attended my presentations these are a long time coming; for those who attended my session at Webmaniacs/Flexmaniacs, these are also somewhat overdue.

In any case, after deadlines, conference, and illness, here are the slides and files for my Webmaniacs session “Adobe AIR: Windows, Menus, and the System Tray” (and my two SilvaFUG presentations that were based on that session):

• “Adobe AIR: Windows, Menus, and the System Tray” slides and files (2.4 MB .zip)

The .zip file contains three files and a folder:

• Webmaniacs 2008 Slides for presentation.pdf: PDF “notes pages” printout of my presentation — each page contains one slide plus any notes that I added.
• Exercises.pdf: Since this is a “hands-on” presentation I created this document that contains step-by-step instructions for all the exercises. Using this plus the files below you should be able to work through all the exercises for the session.
• Code Snippets for exercises.txt: While all the code listings for the exercises are available in the PDF, a few of them are really long. In any case, if you’d rather copy and paste instead of type as you work through the exercises you can get the code from this file.
• Exercises_workspace_start/: A Flex Builder workspace with the “starting state” of some of the exercises for the session. Most of the exercises just start from a blank screen or continue a previous exercise, but for a few I set up the UI ahead of time to save time, and those files are in this folder.

Enjoy! As always, please leave comments and feedback.