First off, I need to thank Ricky Bacon for bringing this to the attention of the Flashcoders list. Click on the image below to see the full-size screen shot, and you’ll see what happens at this particular AOL page when you visit it using the Debug version of the Flash Player. Make sure to read the error message carefully.

Pretty funny, no? In any case, this should serve as a lesson to all of us: Write useful and professional error messages! It was always a good idea anyway, but now that anyone with the Debug version of the player can see what you wrote, it’s an even better idea. Otherwise, one day the joke may be on you…

One of the great advantages that Flash (and by extension Flex) has over Ajax is that you don’t have to worry about browser idiosyncrasies or versions: If your application heavily depends on JavaScript and/or CSS, you could find major issues whenever a new browser version comes out. By contrast, Flash 4 movies that I built 8 years ago still run in the Flash 9 player without issue.

However, that is no longer true for all developers or all applications. There is a significant difference in the way that the Flash 9 player handles swf’s that are loaded in at runtime. Grant Skinner details it thoroughly in this excellent blog post, but to put it succinctly: When you attempt to unload a dynamically loaded swf, the Flash player probably won’t release it from memory.

(more…)

Cliff Hall has released a new version of PureMVC with various improvements which you can read about here. In conjunction with this release, Cliff has also unveiled the Manifold Project, which provides numerous demos and ports of PureMVC to languages other than ActionScript 3. I am proud to say that I am participating in the open-source Manifold Project, and my Flex-on-Rails application, “Index Cards,” is now a Manifold demo application. From this point forward, you can keep abreast of the development of Index Cards, report bugs, and suggest new features via its Manifold project site.

Kudos to Cliff, who had to do a tremendous amount of work to pull this off. I suspect that a lot of developers will benefit from the effort.

If you haven’t been to the FlexManiacs conference website, you should check it out. The conference is much bigger than last year, plus they’ve added ColdFusion and AIR sessions.

I’m particularly glad that Harris Reynolds will be speaking this year, and he has some pretty sweet topics: “Design Patterns and Architecture Frameworks” and “Highly Coordinated Visualizations using Charting.” I didn’t get to see him at 360Flex last year, so I’m really glad that his FlexManiacs sessions don’t conflict with mine.

What’s that you say? You detect an ulterior motive in this post? Well, OK, I’m excited to be speaking again this year, and I’m happy with my topics, too. Here’s what I’ll be doing…

Making Large Applications Manageable with Modules: Modules were pretty cool in Flex 2.0.1, but they’re even cooler in 3.0.

Introduction to ECMAScript for XML (E4X): There will be two versions of this - a lecture and a hands-on. E4X is amazing.

Building Accessibile Applications with Flex 3: This is important for everyone, but especially developers in the D.C. area.

I noticed that the abstracts haven’t been posted on the conference site yet, but you can see them by clicking here.

Come to the conference if you can make it. It looks like it will be a great use of your time - not to mention a lot of fun. Take a look at the conference site and I think you’ll agree. And you might want to think about registering soon, because the prices go up on Friday.

**UPDATE (02/01/08):

• The early-bird pricing has been extended two weeks, to February 15. The price difference is significant, so if you’re reasonably sure that you’re going to attend it’s worth registering now.

Jason has posted a very useful list of Flex Builder tips & tricks. He doesn’t just list them, however; he takes the trouble to show us how to implement them, even including screen shots. Check them out.

Well, I had a three-day weekend right after the conference, and then a very busy week, but I’m finally getting around to posting some of the highlights of day three.

Air Bootcamp

In this 3.5-hour session, Mike Chambers and company walked us through the essential steps for building desktop applications using Flex Builder 3, Flash CS3, Dreamweaver CS3, and the command line compiler. I picked up a number of useful hints and tips, and came away even more impressed with the power and ease of use that Adobe has built into AIR (creating a desktop application from Flash CS3, for example, is insanely simple). However, there are still a couple of weaknesses. For example, Flex Builder 3 still does not support keeping a Web app and its corresponding AIR app in a single project; you need to create a separate project for each application, which can create maintenance headaches. Also, AIR printing is simply Flash printing, so we’re stuck with the accompanying limitations for the time being.

One particularly good piece of news - which was also mentioned in one of the general sessions - is that AIR now ships with database support (SQLite).

Beyond the Basics of LiveCycle Data Services

Jeff Vroom, Adobe’s Principal Scientist, presented a truly brain-filling discussion of LiveCycle Data Services. One useful tidbit is that managed associations are preferred over hierarchical values whenever IDs are available for the referenced objects. I’ll try to write more on this later, because it really merits its own post.

Flex Roadmap

Ely Greenfield blew us all away again. In this discussion of how the Flex team are re-thinking the framework in order to accommodate future innovation, he presented an idea that is simply brilliant. By reducing each component to its essence, and then implementing supplemental features and behaviors as discrete elements (which can often be re-used across multiple components), the framework can become virtually limitless in its potential for extensibility, customization, and innovation. The essence of a button, for example, is a label and a click event. Everything else (e.g. skin) can be left open to modification by the application developer. Using this simple premise, Ely demonstrated how the Flex framework might be changed to enable the application developer (or tool such as Thermo) to create a tremendously engaging UI control from a simple List component. This idea is inspirational not so much because of what it says about the future of Flex, but rather because of the ways we can apply this idea in all of our development work. For more thoughts along these lines, see Anatole Tartakovsky’s post.

I actually wrote the following on Tuesday night, but WordPress was broken so I couldn’t post it. Apparently some files had somehow become corrupt; I re-uploaded them, and now it appears to be working again. Anyway, here are some of the highlights from Tuesday’s sessions.

Building Global Ready Flex Applications

Long-time Adobe employee Craig Rublee gave a solid presentation with plenty of easy-to-follow code samples. He demonstrated the localization process in Flex 2, and then showed two different methods available in Flex 3. In Flex 2, it turns out that you need to compile a separate application swf for each locale (language) that you want to support. This made me sad. However, in Flex 3 you can compile multiple locales into a single application swf, or you can compile locale swfs that have nothing but locale-specific information and load them as modules into your application at runtime. This makes me happy. Of course, the Flash Player still doesn’t support right-to-left text, but as was announced yesterday that will change with the release of version 10 next year. When that happens Flash and Flex will have complete localization capabilities. Meanwhile, I hope to post some code samples illustrating the different options in the near future.

Continuous Integration with Flex, FlexUnit, and Ant

Daniel Rinehart of Allurent provided a good introduction to FlexUnit, Ant, and continuous integration for those who weren’t familiar with them. He then stepped through the process for automating the build, testing, and publishing processes using Antennae. I was pleased to see that the best practices that Daniel (and Allurent) promote via Antennae are consistent with our practices at Eye Street. I also noticed that Daniel does his development work in emacs, which should make Ryan McGeary happy.

Building Rich Internet Applications with Cairngorm and LiveCycle Data Services

This presentation was a real shocker. Peter Martin told us that he and the other members of the Adobe Consulting Team are in the midst of a complete re-thinking of the Cairngorm framework. In their recent work with mfg.com, in fact, they dispensed with the CairngormEvent paradigm altogether, and had the View act directly on the Model instead. Peter went so far as to say that they are considering eliminating the Controller. If you’re familiar at all with Cairngorm, then you know that these are radical changes that are sure to offend Cairngorm religionists. For my part, I’m glad that they are thinking this way, because I have been thinking along the same lines (thanks in part to some prodding from Ryan M). I applaud the Adobe folks for their willingness to re-examine their own assumptions and practices, and change direction when they believe they have discovered a better way of doing things.

Update: Steven Webster has made it clear that the Adobe Consulting Team’s “deep thinking” applies only to applications that use LiveCycle Data Services, and not to applications built with service-oriented architectures. (At MAX Matt Chotin had told me privately that he beleived this to be the case, but now it’s in writing.) This is disappointing, because as noted above Cairngorm could use with some trimming down regardless of what’s being used server-side.

Building Accessible Applications with Flex

Andrew Kirkpatrick and John Bennett provided a comprehensive overview of accessibility, touching upon everything from its importance to why it is often overlooked to suggestions on how to sell it to managers and clients. They also presented some clear and simple code samples to illustrate how to implement Flex’s accessibility features.

Thanks to them I finally know why JAWS has non-Forms Mode. Until today I thought that this mode was nothing but a nuisance, since it seemed to me that it rendered the accessibility features in Flash completely useless. However, Andrew and John explained that this mode is required to read text that cannot receive input focus. So, while it may not be the best way of implementing this functionality, at least it does have a purpose. I also learned of Inspect32, a tool that reads and displays the MSAA data that screen readers use so that you can see how your application looks to the screen readers. This provides a great way of testing accessibility without needing to listen to JAWS.

Andrew and John also indicated that they will soon be posting some tools on Adobe Labs that will help simplify building accessible Flex applications, particularly with respect to video.

General Session / Sneak Peeks

There was way too much cool stuff demonstrated and announced to fit in one blog post, so I’ll write more later. For now, let me simply say this: Thermo will blow you away.

As expected, the first day of MAX was full of useful, interesting, and exciting information. Here are some of the highlights from various sessions:

General Session / Keynote

Kevin Lynch announced that an upcoming release of the Flash Player will include support for the H.264 video codec. This was particularly timely for me, because just a couple of hours earlier another attendee told me that he used QuickTime for Web video instead of Flash primarily because QuickTime supported this codec. Along these same lines Flash Player will also support HD video to 1080p.

Emmy Huang and Justin Everett-Church gave a preview of some of the features coming in Flash Player 10, code named “Astro” (don’t you love Adobe’s code names?). Emmy has a video of the talk on her blog, but I’ll just mention the main points here for convenience:

• Advanced text support, including right-to-left text and columns
• Out-of-the-box 3D effects
• Support for custom filters

Customizing the Flex Framework

Deepa Subramaniam did an excellent job on this presentation. There wasn’t a lot of new information for those who are experienced at extending Flex, but I really appreciated her clear and easy to follow style. And I did learn something new: I learned why developers might want to tell the compiler to preserve metadata. I was aware that this compiler option existed, but had no clue as to what it might be used for. Deepa explained that it comes in handy for shops that roll their own testing and / or automation tools.

Flash Player Internals

Jim Corbett and Lee Thomason provided a wealth of useful information about the Player. For one thing, it turns out that the new display list model, which I sort of complained about here, helps to improve performance because it’s array based and doesn’t allow empty layers.

They also pointed out the Flash Player emulates the version of the SWF that is currently playing, so that a Flash 6 SWF still plays like a Flash 6 SWF even if it’s running in Player 9. One consequence of this is that any bugs that existed in Flash 6 will continue to manifest themselves even if the bugs have been fixed in subsequent versions. In order to get rid of the effects of the bugs, the SWF needs to be re-published to a later version.

You may already know that Flash uses retained mode rendering, and that this helps to enhance performance. Well, it turns out that in the case of the Flash player it also precludes multi-threading. That being the case, we won’t be seeing support for multi-threaded Flash apps any time in the foreseeable future. We can, however, look forward to some upcoming improvements to the Player’s performance, including support for multi-core processors and GPU acceleration. There will also be cross-domain caching of the Flex framework code (and perhaps other code signed by Adobe), so that any given client will only need to download the framework once.

Case Study: ESRI Geospatial Application

Mansour Raad of ESRI demonstrated the use of their new Flex API, which is now in Beta. It looks like it will be extremely easy to build geospatial Flex apps with this solution, and the apps are very fast and responsive because they use vector graphics rather than downloading large image files. The only downside I see is that ESRI data does not come cheap, so this solution may remain out of reach for smaller organizations.

BOF: Flex Interface Guidelines

Rob Adams and Narciso Jaramillo introduced a new initiative to raise the bar for Flex UI design and development called Flex Interface Guidelines (FIG). You can read about FIG here. One gem I gained from Rob’s presentation was an acronym for the Windows GUI paradigm: WIMP (I think it stands for Windows Icons Menus and Pointers). For all I know it may be an ancient acronym, but it was new to me, so I enjoyed it.

BOF: Meet the Team: Flex

I didn’t get a lot of new info from this session, but it was really encouraging to see so many members of the Flex team hanging around till 9:30 PM and later to answer our questions. It speaks well of Adobe’s commitment to their user base, and the character of the people on the team.

BOF: Flex Component Panel

I learned (or was reminded?) of a cool site for Flex skins: scalenine. Check it out, if you haven’t already.

Partner Pavilion

I enjoyed talking to some of the Adobe partners at their respective booths, and it was great to learn a little about the cool stuff they’re doing. It was particularly nice to meet folks at Universal Mind who are friends of my friend Harris. They also had a good blues band (didn’t get the name) at the Sponsor Reception.

Free Stuff!

I really liked the free stuff that they gave me. I got several cool things from Adobe and partners, but one item deserves special mention: the green foam hand that I got from HostMySite. It’s not every day that I get one of these babies!

There’s more that could be said, but it’s wa-a-a-ay past pumpkin time, and I don’t want to sleep through breakfast tomorrow (which reminds me - the food was great).

Welcome to my blog’s new home. As Jason informed me in his comment, the RSS is not working at present. I hope to have this resolved soon; meanwhile, take a look at the photo in the header and see if you can spot the item that doesn’t fit with the others.

Update: The RSS is working again. If you’re a WordPress user and you’re interested, you can learn as much as I know about what went wrong at this forum post. Otherwise,  just click the RSS icon in the right menu (or click here) and you should be good to go. Let me know if you run into an issue.

Ryan McGeary is a co-worker who, paradoxically, is both a Flex skeptic and a nice guy. In fact, he was good enough to attend FlexManiacs in spite of his aversion to Flex / Flash so that he could provide me (and our CEO) with some constructive feedback. As I had hoped, he came away from the conference with a bunch of thoughtful comments and questions, some of which made me step back and re-evaluate my own attitudes and approaches.

I hope to write responses to several of Ryan’s points in the near future, but I’d like to start with an observation he made about the Flex developer community: he noted that we tend to be IDE dependent. I know that there are some Flex developers out there who do all their work with text editors and won’t touch Flex Builder with sterile gloves, but based on my experience I have to concede that they seem to be a small minority. (Whether they constitute a proportionally smaller segment of the Flex community than their counterparts in other development communities I have no idea. Someone should do a study on that.) As for me, I use Flex Builder every day, and I don’t see a need to change that habit. Let me explain why.

Memory

I have invested substantial effort in developing a knowledge and understanding of the Flex framework. I’m sure that if I were to put the effort into developing a few applications using just TextPad and mxmlc I would end up with even more of the Flex framework committed to memory, and in fact I would need to have it committed to memory in order to be as productive with TextPad as I am with Flex Builder. But I don’t know why I would want all that stuff in my memory when it’s already in my laptop’s memory.

Don’t misunderstand me. I’m not among those who think that it’s a waste of time to teach arithmetic to children now that we have calculators. On the contrary, I strongly believe that everyone should learn to think and act independently - which is one of the reasons my wife and I home school our children. However, I’m not convinced that memorizing highly transient data is of any lasting value.

Like many other technologies, Flex is changing rapidly. While some people are just now discovering Flex 2, Flex 3 is in public Beta. By the time many of us are comfortable with 3, Adobe will be pushing 4 out the door. Who can tell what parts of the framework will change? Some properties and methods that are now private are likely to become protected. Some members - and even entire classes - that we now use every day will probably be deprecated. New methods, properties, and classes will be added that will provide native means of accomplishing tasks that we now hack for ourselves. It seems to me that memorizing all the details of the Flex framework in its current state would only make it more difficult for me to go with the flow of all of these changes, and hinder me from maximizing the benefit that could be derived from them. That being the case, it makes sense — having already built a strong familiarity with the framework — to allow the IDE to help with the details via code hinting.

Other factors

Besides memory helps, auto-complete is also a useful time saver. For example, it’s nice to be able to type “tabn” instead of “TabNavigator” all the time. Also, having the closing tag generated automatically is a helpful bonus. (Go ahead, call me lazy.)

Then again we have the annoying phenomenon of programmer error. I’m old enough to know that no matter how thoroughly I learn Flex (or any other framework) I will still make mistakes from time to time. When that happens, and the compiler fusses at me, it’s really nice to be able to double-click on the error message and be taken right to the very line of code where my error resides.

Another benefit of Flex Builder is the ability to quickly dive into the framework source. I can highlight a framework class or member identifier in my own code, hit F3, and be taken directly to the appropriate place in Adobe’s source code. This is a great help when trying to figure out why I’m getting unexpected side effects, or in determining the best way to extend a framework class.

Let’s not forget the other useful keyboard shortcuts: Shift-CTRL-C to comment a block of code; CTRL-O to open an outline of the current file; Shift-CTRL-O to sort and organize import statements; etc.

So far, I’ve only been dealing with benefits of the IDE’s source editor. The design view (WYSIWYG) makes it easy to quickly throw together a UI layout, and has saved me a substantial amount of time on a number of occasions.

Simply put, a well-built IDE is a useful tool, and Flex Builder - for all of its shortcomings - is a well-built IDE. I acknowledge that there may be some developers who are too lazy to learn the framework at all, and couldn’t even write HelloWorld.mxml without Flex Builder. However, the fact that some people misuse a tool is not an argument against using the tool. Murder has been committed using hammers, but when it comes time to drive a nail I don’t hesitate to reach for my Estwing.