Flex Doc Team

Plugins for Ion search

2008-06-03T18:17:05Z

If you use the http://community.adobe.com/ion/ search engine for finding Flex information fast, then you might find the following useful: A plugin for FireFox and a Google Toolbar custom button for IE that give you instant access to the search engine from within you browser.

FireFox plugin for Ion

Download the ion.xml file.

Save this as ion.xml in your {Mozilla}\searchplugins directory (for
example, "c:\Program Files\Mozilla FireFox 3 Beta 5\searchplugins")
and it should show up in your list of search plugins.

Goole Toolbar custom button for IE

Go to the Ion home page: http://community.adobe.com/ion.

Select Flex from the product drop down list.

Right-click on the text input in the Ion search and click "Generate
Custom Search...".

The Google Toolbar Custom Button Generator dialog appears.

You can replace "community.adobe" in the first text input with any
name you want to appear in the toolbar. In the second text input, you
can replace "Adobe Community Help - Search Results" with any
description you want.

Click the Replace button and click OK.

That's it. You can now select "community.adobe" (or whatever string
you specified) from the toolbar, and then execute a search directly.

The Security Sandbox in Flex Builder 3

2008-06-02T17:42:53Z

We recently received a question from a user about Flex Builder security sandbox settings. I thought the answer to this question would be of general interest.

Question: In Flex Builder 2, the security sandbox settings for both debug mode and release mode was local-trusted. In Flex Builder 3, why is release mode now local-with-network?

Short Answer: Whether a given SWF, when run locally in a non-trusted location, is local-with-filesystem or local-with-network is a compilation setting. This setting is stored as a flag in the SWF header and is the only compiler flag. The default is local-with-network and has not changed in Flex Builder 3.

What is new with Flex Builder 3 is that we no longer put the release SWF inside the trusted debug output folder by default. The advantage to the developer is that the release SWF will run in the same security sandbox in which it will be deployed. Thus you get accurate application behavior instead of the more permissive local-trusted, which is only available to the developer.

Detailed Answer: In Flex Builder 2 we put the release SWF alongside the debug SWF, which was inside an output folder that we configured the flash player to trust for the following reason:

You could click, debug, and launch your application and have it access network services without first configuring the project to host the SWF on a web server (and thus have to launch it with a proper http:// URL). Basically, you can launch your application from the file system using file:/// URLs.

The problem with this approach is that when testing the release SWF, even if you edited the launch URLs to use http://, you would be running the application out of local-trusted instead of the actual deployment sandbox (remote).

There are other problems with this arrangement, such as facilitating the accidental deployment of both debug and release SWFs in the output folder.

So, for Flex Builder 3 we separated the notion of the Run button from the release SWF. The Run button merely launches the debug-capable SWF with debugging turned off. The Export Release Wizard creates the actual release SWF. Flex Builder 3 encourages you to put the release SWF somewhere other than your debug output folder. Thus, to test the release version, you must launch and test it as an end user would using a browser and web server (that is, unless you actually want the end user to try to run it locally).

Note: Use the custom compiler option, use-network=false, if you want to override the Flex Builder default compiler option. This would change the settings to local-with-filesystem.

Master-Detail Flex Application

2008-04-30T21:50:54Z

I’m an Adobe writer assigned primarily to Flex Builder and the Flex SDK. I joined Adobe in October of 2007 and have spent the first few months learning and using Flex and Flex Builder.

I’ve recently completed my first Flex application, and am using this blog to write about my learning experience, and also to describe some of the concepts behind the application that make it work. Actually, these are two applications that work together, vRadio and RadioLoginDB.

These applications illustrate how to use Flex to create a master-detail application that accesses data from a PHP server, and also incorporates PHP sessions.

At the end of this posting is a list of documentation sources I used to learn how to create the applications. I also have links to the source files.

vRadio and RadioLoginDB applications

I have always been a fan of Community Radio, and in the past I’ve Googled “Community Radio” to find new stations to listen to over the web. I created the vRadio application to provide a Flex alternative that lists Community and Talk radio stations, providing details about each station including station name and location, station graphic, and clickable links to open the station. RadioLoginDB is a CRUD application to update the database of radio stations used by vRadio.

vRadio is a Master-Detail application, and corresponds to many type of applications that present stored data in a variety of presentation formats, and also provide forms for updating the data.

What is interesting about the the vRadio application is the way Flex handles XML data using the E4X format. By providing an XML feed into the vRadio application, the application displays the XML data in a tree view. When the user clicks a node in the tree, details are displayed.

]]> The vRadio application stores the radio stations in a MySQL database, accessible from PHP calls on the web server.

Notice the link to Update Station List in vRadio. This link takes you to a log in page for the RadioLoginDB CRUD application. Upon successful login, you can update the MySQL database information inline in a Flex DataGrid, delete records from the DataGrid, or open a form to add new stations.

Using E4X to Access XML Data

The vRadio application implements an HTTPService that uses E4X to read XML generated by the php2xmlService.php on the server. php2XMLService reads a MySQL database containing details on radio stations. This allows the vRadio application to display the master-detail information about the radio stations.

To implement this feature, I first used a static XML file, radio_stations.xml, as the data source for the HTTPService. radio_stations.xml contained the information for a few radio stations, and allowed me to understand the structure of the XML document that was needed. I then put the radio station data into a MySQL database, and wrote the php2xmlService.php to echo the XML stream.

Flex Builder: Generating a CRUD Application from Database Wizard

Most of the working parts of the RadioLoginDB application are generated by the Create Application from Database Wizard, available in Flex Builder. The Database Wizard generates the CRUD application from the MySQL database of radio stations. This wizard generates the CRUD application in just a few mouse clicks, and is the starting point for the RadioLoginDB application, described below.

To run the wizard, first create a Flex project that access a PHP database. Then invoke the wizard in Flex Builder by selecting Data > Create Application from Database. The wizard guides you through creating the CRUD application. (Note: you can also use the Wizard for Flex projects that contain J2EE and ASP .NET database applications.)

The wizard generated the following files, which I subsequently modified:

radio_stations.mxml

radio_stationsScript.as

Radio_stations.php

The wizard also generates the following files, which do not need customization for this application. However, to further refine this application, you might want to modify some of these generated files as well.

Localhostconn.php

XmlSerializer.class.php

functions.inc.php

Customization of the Flex Application

The most significant part of customizing the application is providing a minimal level of security. I also customized the application to provide some ease of use features. Here are the customizations I made to the application:

Added a Log In screen
Access to the database is only allowed for authorized users.
Implemented PHP sessions
Prevent unauthorized access after a connection to the database has been made.
Customized the DataGrid to make it more readable
Customized the database update Form to enforce the correct entry of data into the database

Note: This example illustrates how to communicate between Flex and your PHP server. It does not illustrate a security model to use for your applications.

Implementing PHP Sessions

I want to take advantage of session support available with PHP to avoid unauthorized access to the database. Upon successful login with auth_login.php, a PHP session variable is set. I modified the generated Radio_stations.php to check for the session variable before allowing access to the database. If the session variable is not set, then the login screen from radio_stations.mxml appears.

Customizing the DataGrid

The generated DataGrid is a quite useful interface. It allows in place editing of database fields, allows you to delete entries, and opens a form for adding new entries. I made the following modifications to the DataGrid View:

For each of the columns in the DataGrid, I customized the width of each columns. This improved the readability of the DataGrid
I added a logout Button, to log out of the PHP session.

Customizing the Database Update Form

The database wizard generates a form to add new entries to the database. I modified this form to ensure that new entries are correctly formatted.

Here are the modifications I made:

A dropdown list for the type of radio station (Community Radio, Talk Radio, etc.)

A dropdown list for selecting the state (CA, MD, etc.)

I could also add validation to the URL fields and the fields for entering the height and width of the station graphic. I plan to implement this at a later date.

Documentation Links

Here are links to Flex documentation that I used to research creating this application:

Using an E4X Expression in a Data Binding Expression

Displaying XML-based DataGrids Using Dynamic E4X Expressions

PHP5 Quick Database E4X Queries
(I didn’t use this technique, but I think this article is useful.)

Creating Flex Projects
(For creating a Flex project that accesses PHP.)

Automatically Generating Database Applications

Getting Started Experience - ViewStack

ViewStack Navigator Container

Using HTTPService Components

Flex Quick Start Guide for PHP Developers

Source Files

vRadio Application (vRadio.mxml )
php2xmlService.php, server side application which accesses a MySQL database of radio stations, returning the contents encoded as XML. This service is used to populate Tree listing in the vRadio Radio Stations Pane
auth_login.php, which authenticates users and sets a PHP SESSION Authentication variable upon successful login.
RadioLoginDB Application, the CRUD application generated by the Flex Builder Create Application from DB wizard, and later modified to implement authenticated PHP sessions. Here are the files generated:
- radio_stations.mxml
- radio_stationsScript.as, which creates the gateway HTTPService that provides access to the MySQL database and contains various functions to perform the CRUD services. I modified this file to perform PHP SESSION authentication to the MySQL database
- Radio_stations.php, generated by the Create Application from DB wizard to provide the PHP calls into the MySQL database.

Alternatives to using the Fade effect with text

2008-04-25T18:38:58Z

Someone recently asked if there were any ways to fade text out in a Flex app without having to embed the font for that text. Currently, if you want to appkly the Fade effect to any controls that contain text in a Flex app, you have to embed the font so that Flash Player can do the fading properly.

This question led to an interesting thread that revealed a couple of alternatives to fading text without embedding the font. The result is that the SWF file size is smaller because it doesn't contain any font symbols.

First, here's code that embeds a font and defines a fadeIn and fadeOut effect:



[Embed("assets/MyriadWebPro.ttf", fontName="MyMyriad")]

public var myriad_font:Class;

...






            fontFamily="MyMyriad" fontSize="24"

            hideEffect="{fadeOut}" showEffect="{fadeIn}"/>

Here's the running example:

This app is 190K. It works very well because the Fade effect is applied directly to the control that uses an embedded font to render the text.

If you didn't embed the font, then the Fade effect would appear to fail: instead of a slow fade, you'd get a single instant where the text disappears. Non-embedded fonts don't include bitmap information for the Player to apply a Fade effect to.

Here's a running example that shows the failing fade on non-embedded text:

Now for the alternatives.

The first alternative is really clever: Apply the BlurFilter to the text before attempting to fade it in and out. When you apply a BlurFilter to text, Flash Player converts the text to a bitmap. Once the text is a bitmap, it can be faded in and out with the Fade effect. So instead of actually blurring the text with the BlurFilter, you just apply the BlurFilter with some dummy settings (0,0,0), and then you can fade the text with the Fade effect.

Here's the code that applies a BlurFilter to the text when the app initializes:



  private function addBlurFilter():void {

  var bf:BlurFilter = new BlurFilter(0,0,0);

  var myFilters:Array = new Array();

  myFilters.push(bf);

  label3.filters = myFilters;

}

When you toggle the checkbox, the Fade effect now appears to work seamlessly. Here's the running example:

The SWF file size is 165K. Adding the BlurFilter does not increase the SWF file size because you don't have to embed the font symbols. It might increase runtime memory usage because Flash Player now has to keep bitmap data in memory for that text, but it's still a damn clever trick, I think.

The second alternative is to use the Dissolve effect rather than the Fade effect. The Dissolve effect actually creates a rectangle over the target area, and applies a dissolve to the rectangle so that the underlying content appears to fade in and out.

Dissolve effects are set up and applied just like Fade effects:








     hideEffect="{dissolveOut}" showEffect="{dissolveIn}"/>

Here's a running example:

As with the Blur effect, using the Dissolve effect does not increase the SWF file size because you don't have to embed the font symbols.

This ZIP file (2KB) contains the complete source MXML files for the three working examples in this blog entry.

New "Community Help" features for Flex

2008-04-25T18:24:55Z

The Adobe web team is rolling out new functionality to help Flex coders find the help resources they need.

Currently, the "Ion" project consists of a customized search engine that is populated with the best of the Flex-related resources on the web. You can access this new search feature directly at http://community.adobe.com/ion/. You can also search it by using the "Community-Powered Search" input on the Flex DevNet site.

Also part of Ion is the back end for commenting on Livedocs and DevNet articles. Prior to this, there was no commenting on DevNet articles, and the Livedocs commenting engine was much more restrictive.

This is just the beginning of the Ion project.

Extracting data visualization source code

2008-04-21T18:42:13Z

All users have access to the Flex 3 SDK source code. You can view the ActionScript source files for classes like Button and DataGrid. The source code is in the frameworks\projects\framework\src directory of your Flex installation. The source code for the data visualization projects does not come pre-installed, however. If you have a Flex Builder Professional license key, you can extract the data visualization source code, which include the charting controls, the AdvancedDataGrid classes, the OLAP classes, and the automation classes. To view your Flex Builder license key, select Manage Flex Licenses from the Help menu.

To extract the data visualization source code, you use the DMV-source.jar file. This file is located in the SDK's lib directory. If you are using Flex Builder, the lib directory is located at {Flex Builder 3}\sdks\3.0.0\lib.

The syntax to extract the data visualization source code is as follows:

> java -jar DMV-source.jar {license-file-location} {output-location}

The first argument is the location of the license.properties file. This file must contain a valid Flex Builder 3 Professional license key. The second parameter is the location that you want the data visualization source code to be extracted to.

If you installed Flex Builder 3 Professional, then the license.properties file is located at the following locations, depending on your operating system:

Windows: C:\Documents and Settings\All Users\Application Data\Adobe\Flex\
Mac OS: /Library/Application Support/Adobe/Flex/
Linux: ~/.adobe/Flex/

The following example extracts the data visualization source code to the c:\temp\dataviz_source directory on Windows:

java -jar c:\Flex Builder 3\sdks\3.0.0\lib\DMV-source.jar 
     "C:\Documents and Settings\All Users\Application Data\Adobe\Flex\" 
     c:\temp\dataviz_source

If you have a valid Flex Builder 3 Professional license key but did not install Flex Builder, then you can create a license.properties file anywhere, and point to it when you use the DMV-source.jar file. The syntax of the license.properties file is as follows:

flexbuilder3={license_key}

Using an HTML page as a data provider

2008-04-17T17:19:41Z

Here's a new example in the charting doc. It shows how someone might use some or all of an HTML page they load via an HTTPService tag as a data provider for their charting component. It includes logic to extract just the data from the target page.

The benefit to this is that if you have a wiki or blog that you can edit via a browser, you can build and update a data page without having to hit a database. The code extracts specially-tagged data from the HTML page, so even if it's part of a larger block of HTML, you can still extract just the data.

One thing to note: The target domain in this example works because it has a crossdomain.xml file. If you want to load a page from your own target domain, you must be sure that your target domain has a crossdomain.xml file in place, and that that policy file lets the domain on which the Flex app is running request data from it.

Here's the running example:

Here's the data page that drives this chart:
http://examples.adobe.com/flex3/exchangingdata/html/dataPage.html

You can download the source MXML file here:
HTMLDataProvider.zip (1KB)

The exact location of the data page is passed into the application as a flashVars property. To change the data page, you only have to edit the HTML wrapper for the SWF file.

In the HTML wrapper, we pass the target HTML page as a param in the tag:

And again as an attribute of the tag:

flashVars="dataPage=http://www.shallowpondestates.com/misc/dataPage.html"

Note that you can view the source of this blog entry page to see the complete object/embed tags.

In the Flex app, the data page is read from the Application's application.parameters property:

dataPage = Application.application.parameters.dataPage;

To initially get the page's contents into the Flex app, we use an HTTPService object:


        resultFormat="text" 

        url="{dataPage}"

    />

To get the HTML in a single string we get the lastResult property of the HTTPService in the ResultEvent handler:

var htmlBlob:String = serviceInput.lastResult.toString();

And to extract just the portion of the data page that we need (the part between the "data starts here" and "data ends here" comments), we use the slice() method:

htmlBlob = htmlBlob.slice( htmlBlob.indexOf("<!-- data starts here -->", 0) + 25, htmlBlob.length );

htmlBlob = htmlBlob.slice( 0, htmlBlob.indexOf("<!-- data ends here -->", 0) );

We then do a couple more passes on the remaining HTML string to replace HTML entities with angle brackets, so that we will end up with well-formed XML:



var tagPattern:RegExp = /<[^<>]*>/g;  

htmlBlob = htmlBlob.replace(tagPattern, "");

			

var ltPattern:RegExp = /</g;

htmlBlob = htmlBlob.replace(ltPattern, "<");

			

var gtPattern:RegExp = />/g;

htmlBlob = htmlBlob.replace(gtPattern, ">");

At this point, we just need to pass the XML to the XMLList constructor so that it can be used as a data provider in the chart:



chartData = new XMLList(htmlBlob);

That's it. If you compile and deploy this app, you can use the provided data page, or create your own. If your data page is on the same domain as the application, then you do not need a crossdomain.xml file.

Building Adobe LiveCycle Data Services ES Beta 2 Applications

2008-04-16T22:07:01Z

Adobe LiveCycle Data Services ES Beta 2 applications consist of two parts: client-side code and server-side code. Client-side code is a Flex application written in MXML and ActionScript and deployed as a SWF file. Server-side code is written in Java and deployed as Java class files or Java Archive (JAR) files. You can develop Adobe LiveCycle Data Services ES applications in Flex Builder, or in your own IDE. This article describes how to set up your development environment to compile, debug, and deploy LiveCycle Data Services ES applications.

Download the PDF: Building and Deploying LiveCycle Data Services ES Applications

Heads-up: Server maintenance this weekend

2008-04-12T01:48:34Z

I just wanted to let everyone know that on Saturday, April 12th, from noon to midnight PDT, our network team will be performing maintenance on the cluster that includes examples.adobe.com. Due to this work, applications running on the example cluster will experience 1-2 minute network outages throughout the service window.

ColdFusion and Flex LiveDocs are misbehaving

2008-04-09T22:53:59Z

We're currently seeing a caching corruption problem with LiveDocs in which random files display instead of the correct pages. You'll see a variety of symptoms:
* The wrong page displays
* Infinite loops in the TOC (this happens when LD loads a .js file instead of an HTML file)
* Bad formatting (when a CSS file doesn't load properly)

The good news is that our web team has identified the bug that causes this. The bad news is that they're still testing the fix and it won't get rolled out until April 17.

I've had fairly random results over the last few days. Sometimes changing browsers helps, sometimes it doesn't; sometimes clearing browser cache fixes it, sometimes it doesn't. One suggestion is to download the complete Flex doc zip file, which contains usage docs in PDF and the Language Reference in HTML and access the docs locally.
This is available at http://livedocs.adobe.com/flex/3/flex3_documentation.zip. Individual PDFs are available from the Flex Help Resource Center page: http://www.adobe.com/support/documentation/en/flex/

I sincerely apologize for the inconvenience this is causing.
Randy Nielsen
Flex Documentation Manager

Adding Java Development Tools to Flex Builder Standalone

2008-04-03T15:24:45Z

Many Flex, Adobe AIR, Adobe BlazeDS, and Adobe LiveCycle ES developers choose to use the Eclipse plug-in configuration of Flex Builder so that they can develop Java code in the same IDE that they use to develop the MXML and ActionScript code. While the standalone version of Flex Builder does not contain tools to edit Java code by default, you can install them as Eclipse plugins. That lets you use the standalone version of Flex Builder to edit Java code.

To install the Java development tools in the standalone version of Flex Builder:

1. Use the Help > Software Updates > Find and Install menu command to open the Install/Update dialog box

2. Select Search for new features to install.

3. Click Next.

4. In the results, choose Europa Discovery Site.

5. Click Finish.

6. Select the Java Development package to install.

7. Click Next.

8. Accept the license.

9. Click Finish.

Note: You might be prompted to install additional plugins required by the Java Development package.

To change perspective:

1. Use the Window > Perspective > Other to access all perspectives.

You can also click the Open Perspective button in the upper-right corner of the workbench window, then select a perspective from the pop-up menu.

2. Select Java from the list of perspectives.

Updated ColdFusion Using Flash Remoting Update chapter

2008-03-05T17:14:59Z

The Using Flash Remoting Update chapter of the ColdFusion Developers Guide documents how to integrate Flex and ColdFusion by using mx:RemoteObject tags to call ColdFusion Component (CFC) functions. It includes information on how to configure a Flex Builder project to compile an application that accesses ColdFusion, and describes how to specify and use CFCs in your Flex applications. Finally, it describes how to compile and run such applications.

The version of the chapter that was released with ColdFusion 8 was not updated correctly at that time, so it is not appropriate to use when integrating either Flex 2 or Flex 3 with ColdFusion 8. The updated chapter is (we believe) correct, and covers Flex Builder 2 and Flex Builder 3.

Download UseFlashRemotingUpdate_Blog.pdf

Creating ASDocs for Custom Adobe AIR Components

2008-03-03T22:10:18Z

The Flex ASDoc tool parses one or more ActionScript class definitions to generate API reference documentation for all public and protected methods and properties, and for all [Bindable], [DefaultProperty], [Event], [Style], and [Effect] metadata tags. By default, the ASDoc tool links in all of the Flex SWC files required to compile custom Flex components. However, to use ASDoc to generate documentation for custom Adobe AIR components, you must link in the necessary AIR SWC files.

For example, you create a custom component named MyAirComboBox that extends the AIR mx.controls.FileSystemComboBox component. The directory location of your custom component file is:

C:\myApplication\myComponents\MyAirComboBox.as

Use the following ASDoc command to generate API reference documentation for MyAirComboBox:

..\bin\asdoc -doc-sources C:\myApplication\myComponents\MyAirComboBox.as -library-path+=..\frameworks\libs\air -main-title "My AIR API Documentation" -window-title "My AIR API Documentation" -output air-asdoc

This command assumes the following:

You run the command from the directory C:\Program Files\Adobe\Flex Builder 3\sdks\3.0.0\asdoc in your Flex Builder installation directory structure. If you are using the Flex SDK, or have installed Flex Builder on another operating system, modify the paths in this command as necessary.

The AIR SWC files are installed in the directory C:\Program Files\Adobe\Flex Builder 3\sdks\3.0.0\frameworks\libs\air. This is the default directory location for a Flex Builder installation.

This command uses the library-path option to the ASDoc tool to specify the directory location of the AIR SWC files. The"+=" operator to the -library-path option specifies to append the AIR SWC files to the Flex SWC files.

The ASDoc tool writes the output to the directory C:\Program Files\Adobe\Flex Builder 3\sdks\3.0.0\asdoc\air-asdoc.

If you have created multiple AIR components, you can use the following ASDoc command to generate documentation for an entire package:

..\bin\asdoc -doc-sources C:\myApplication\myComponents -library-path+=..\frameworks\libs\air -main-title "My AIR API Documentation" -window-title "My AIR API Documentation" -output air-asdoc

See the Flex 3 documentation for more information on the ASDoc tool.

Migrating applications from Flex 2 to Flex 3

2008-02-29T17:00:36Z

Migrating from Flex 1.x to Flex 2 was -- how can I put it -- painful. We scrubbed the APIs to make them consistent; as a result, many properties, methods, events, and even some constants changed, and sometimes changed again. We added and removed classes and interfaces. Heck, we even changed the capitalization of "Void" to "void". In addition, the underlying language went from ActionScript 2.0 to ActionScript 3.0. There was no shortage of tasks for updating apps from 1.x to 2.

This time around, however, the APIs have already been through the scrubbing and many of the issues have been ironed out. Most of the migration duties you'll encounter will be related to updated features, like:

Localization -- The l10n system has changed alot (for the better!). It's now much simpler to implement, and it supports runtime locale-switching. You can use the same properties files, but you might have to rewrite the way they are accessed. Check out the localization doc.

Style properties -- A number of style properties have changed to support the new subcomponent style feature.

Deep linking -- This is a new feature, but if you were using the HistoryManager class, you really should switch to using the BrowserManager class to do all your browser/Flex app communication.

Compiler and configuration args -- A few compiler arguments have changed. If you use config file or ant tasks to do your compilation, you might have to modify your files.

Here are some resources that should help with migration issues:

Deprecated elements in the Language Reference -- A list of all the class elements that are now deprecated. The compiler will also warn you about these when you try to compile, but you can get a sense of what has changed from this list.

Backwards compatibility -- This includes a list of differences between the configuration files for SDK 2.0.1 and SDK 3, as well as a list of the changes to the framework.

Understanding Flex 3 Migration Issues on Joan Lafferty's blog: Part 1 and Part 2

It's also important to realize that with Flex Builder 3, you can compile your apps against the new compiler (version 3), or against any version of the compiler that you have installed. This way, if your code does not use any of the new features and you don't want to migrate yet, but you want to use Flex Builder 3, then you can without any issues. Of course, there's doc on that, too.

Flex 3 (and Flex 3 Documentation) is Live!

2008-02-25T03:55:54Z

We started shipping Flex 3 today. Wow! This has been quite a release and, although you're probably reading this on all the Adobe blogs, we think it's pretty special. I know that we've made a number of improvements to the docs, and am going to ask the writers to create their own posts to enumerate their personal favorites. For my part, I'll call out two:

The Flex 3 Getting Started Experience - With Flex 2 and 2.0.1, we had a lot of negative feedback from Flex newbies.My manager, in her infinite wisdom, gave us a lot of support in hiring Inquirium (an instructional design firm) to interview Flex developers, figure out their common patterns/problems, and create a new getting started roadmap. Some hurdles we knew about (understanding that Flex access data indirectly through a server), but others were a surprise (a lot of people got caught up with asynchronous events). We then hired Trilemetry (big thanks to Emily, Annette, and Bob) to "realize" the Getting Started Experience. This turned out to be bigger than we thought, but I think it works really well, and the Beta feedback has been extremely positive.
Revised table of contents (TOC) architecture for Flex Builder online Help and LiveDocs - In our work with Inquirium, it became clear that viewers weren't thinking about "books" in the online doc experience. The revised TOC feels more navigable and I think it makes it easier to find stuff. Please check it out and let me know what you think. Note that we only did this for the core Flex books, so Flex Builder, Data Visualization, AIR, and ActionScript are still presented as books. Also note that material is still available as books through the Flex Help Resource Center.

OK. I lied. Two more things:

Obviously, I'm focusing on Flex, but AIR went live today, too, and this is a significant milestone for Adobe. For Flex developers, it's pretty simple: Any app you write for the browser should just run in the AIR runtime (and the Flex 3 LiveDocs include Developing AIR Applications with Flex). You can also take advantage of the extended functionality inherent in a desktop application and I recommend scanning the discussions of windows, menus, taskbars, files, data, HTML content and Rich media content. In particular, I think the drag & drop and local SQL database discussions are cool.
Please use the public bugbase to report problems with the Flex 3 documentation. You can also search the bugbase to see if anyone else has already reported an issue.

Thanks everybody for your feedback during the Flex 3 Beta cycle. You made a difference.

On to Flex 4!