Greg Wilson’s Ramblings

During the past several weeks, we have been adding new samples in the Flex Data Access category in Tour de Flex.  All of the samples were created by either Christophe Coenraets or Holly Schinsky.  Below is a brief overview of each.

Many of the samples described below utilize BlazeDS or LiveCycle DS.  If you are unfamiliar with these products, I recommend Holly’s Quick Start.

Basic Stuff

HTTPService – Basic Example
This one is fairly obvious – it demonstrates how to use the HTTPService to consume XML and other responses via HTTP or HTTPS.  This is the most basic type of data access in Flex.

HTTPService – HTTPService Events
This sample builds on the previous sample and demonstrates how to handle result and fault events from HTTPService.  Note that HTTPService calls are asynchronous so understanding these events is key.

HTTPService – E4X
This sample also uses HTTPService but specifies that the result format will be E4X

HTTPService – Using the Proxy Service (BlazeDS and LCDS)
All of the prior samples used the out-of-the-box HTTPService component to directly connect to the data source.  Sometimes it is not practical to connect directly to the data source due to it being on a different domain (and lacking a crossdomain.xml entry) so a proxy service is needed.  BlazeDS/LCDS can provide this proxy service with a some simple configuration as described in this Tour de Flex sample.

WebService – Basic Example
Using the WebService tag, you can invoke SOAP-based web services. Objects returned by a web service are automatically de-serialized into ActionScript objects.  Going the other way,  ActionScript objects are passed as arguments to a web service operation and are serialized according to the WSDL description.

WebService – Using the Proxy Service (BlazeDS or LCDS)
Similar to our HTTPService Proxy section above, it is sometimes not practical or possible to connect directly to the service.  Once again, the BlazeDS/LCDS proxy service provides a simple solution.

Blazingly fast remoting

RemoteObject – Basic Java Remoting (BlazeDS or LCDS)
If you are connecting to a Java backend, it is possible to directly invoke methods of Java objects using RemoteObject.  In addition to the obvious benefits of being able to call Java methods directly, you also get the benefits of AMF that is used to pass data back and forth.  AMF is a compressed, binary format that is dramatically faster than verbose XML or other text formats.  Lee Brimelow wrote a great blog post on AMF here.  This Tour de Flex sample does a simple call to Flex.samples.product.ProductService, a simple Java class, a displays the data in a datagrid.

James Ward has created a great application that benchmarks AMF and compares it to several other data loading techniques.

RemoteObject – Basic Java Remoting 2 (BlazeDS or LCDS)
This sample is similar to the previous sample but also demonstrates handling result and fault events from the remote call (RemoteObject calls are asynchronous)

RemoteObject – RemoteObject Events (BlazeDS or LCDS)
Another good example of handling RemoteObject events.

RemoteObject – Strongly Typed Object (BlazeDS or LCDS)
This RemoteObject sample demonstrates how an ActionScript object is mapped to a remote Java object.  The readme contains links to the backend Java source so you can see how each data attribute is mapped.

Almost magical – Data Management

Basic Data Management  (LCDS)
LiveCycle Data Services ES Data Management Service feature provides an efficient approach to synchronizing data across multiple views and between multiple clients.  With LCDS, you don’t have to keep track of changes made to the data, nor do you have to invoke remote services to notify the backend of the changes (create, update, delete) made on the client side.  To demonstrate this, the sample prompts you to open a link in two different web browsers (the browsers can even be on different computers).

Each browser will display a data grid with a few rows of data.  As you update the data in one browser, you’ll see the changes immediately reflected in the other browser, keep the views in sync.  This type of functionality typically requires rather complex code, but as you can see in the Tour de Flex sample, it’s easy to implement using LiveCycle Data Services.

Conflict Management (LCDS)
This sample is similar to the previous sample in that you open a link in two browsers and each of the views stays in sync but this one also adds code to handle conflicts between the two users. Change data in a field on browser #1 AND in browser #2.  When you save the data in one of the browsers, the other one will notify you of a conflict.  This is another example of where LCDS can save a LOT of coding.

Managing Associations and Lazy Loading (LCDS)
This sample demonstrates how LCDS can load data on an as-needed basis (lazy).  In this code, there are multiple many-to-one data relationships defined so that LCDS loads the associated data on demand.

Data Paging (LCDS)
This sample demonstrates automatic paging of large data sets.  Rather than loading the entire query result set, the data is loaded on demand while keeping up with the latest changes to the data.  Data paging speeds application response times and minimizes memory requirements client-side.  The sample displays a simple datagrid that loads 100 rows at a time.  As you scroll through the data, you will see brief delays as the next 100 rows are loaded.  This is yet another example of LCDS saving the developer from having to write a lot of complex code.

Backend Persistence Options (LCDS)
At the end of the Data Management category is a subcategory demonstrating 3 different ways to manage data persistence used by the data management features.  There is a sample that uses SQL, a sample that uses Hibernate and a sample that demonstrates how to build a more complex custom assembler.

Real-time publish/subscribe messaging

Chat (BlazeDS or LCDS)
This sample demonstrates how to build a simple chat client that utilizes the publish/subscribe messaging provided by BlazeDS or LCDS.

Collaboration (BlazeDS or LCDS)
This sample uses publish / subscribe messaging to build a simple collaborative application.  The sample prompts you to open a link in two or more browsers.  When you click the button to switch the graph from company one to company two, the other clients will also switch.

Real-time Dashboard (BlazeDS or LCDS)
This sample shows how to subscribe to a real-time data feed produced by the Tour de Flex server.  The data is real and is produced by the Tour de Flex server.  Each row in the data grid is produced when a sample is viewed in Tour de Flex.   This is the foundation for the much more graphical dashboard found at http://www.adobe.com/devnet/flex/tourdeflex/planetary_dashboard

More samples will be added to the Flex Data Access category very soon to demonstrate how to connect Flex applications to ColdFusion, .NET, PHP and other backends.  Stay tuned!

UPDATE:  .NET and PHP samples added by MidnightCoders – http://gregsramblings.com/2009/06/24/using-weborb-to-connect-flex-to-net-and-php-backends/

I’m speaking this Thursday, June 25th at the Tampa Bay ColdFusion User Group meeting at the offices of Kforce.  I will be giving extensive demos of the upcoming release of ColdFusion, code named Centaur and the new ColdFusion IDE, code named Bolt.  There are some amazing new features to show so you don’t want to miss this.

I’ll also be bringing some great door prizes to giveaway at the end of the meeting.  For more information, go to the Tampa Bay ColdFusion User Group Home Page

I’ve received several request to extend the end date for the Flex Data Visualization contest.  The blog post has recently received a bunch of traffic so a lot of people are late getting involved.

The new deadline is Tuesday, July 7th at noon EDT.

Contest details at http://gregsramblings.com/2009/06/08/flex-data-visualization-contest/

During the past few months, I have often needed to share a small code snippet or other content that is impossible or impractical to paste into a tweet, blog comment or email.  On several occasions, I created a temporary page on my blog or on one of my public servers.  I also tried out a few services such as pastebin.com, txtb.in and snipt.org but all of these wrapped their own content around mine.

I decided to spend a few hours building a simple service for creating single page HTML content.  I also integrated Alex Gorbatchev’s SyntaxHighlighter to  make code look great.

To see the results, go to http://tblurb.com, enter your content, choose a URL (a random string is used by default) and click save.   Content can be entered via a rich text editor or entered as raw HTML.  The code paste feature can be used to paste in ActionScript, C++, C#, ColdFusion, CSS, Delphi, Flex, Java, JavaScript, PHP, Python, Ruby, SQL, VB.NET and XML/HTML.  You can even mix and match languages with other content.  Your content remains online unless it goes for 90 days without being accessed.

Here’s an example that has some simple text combined with an ActionScript code snippet and a block of XML. – http://tblurb.com/Bfmb77 (sample of how to use LiveCycle Data Services data paging feature)

The service is free and now available for your use.  There is no charge but I do reserve the right to eventually add some light-weight ads at the bottom of the page.  Suggestions are welcomed.

Thank you Todd Williams for converting my terrible home-made 1996 UI design into something much better looking!

I’m heading to Nashville  to speak at the following events:

---

• Thursday, 06/18/2009 7PM CDT – Nashville ColdFusion User Group – I’ll be showing some amazingly cool features in the upcoming release of ColdFusion.
  



---

• Friday, 06/19/2009 7PM CDT – 615 Flash / Flex camp & Flex Adobe Tour – Cool Flex 4 and Catalyst demonstrations as well as some other coolness.  If you have the time, come earlier and join the half-day Flash/Flex Camp
  

I’ll be giving away some great software and other items.  BE THERE!

We just rolled out 8 new samples in Tour de Flex in the Data Visualization category from Axiis, an open source data visualization framework. These are some great looking charts! Thanks to Tom Gonzalez for adding them to Tour de Flex!  Check them out.

Two weeks ago, I blogged about the Tour de Flex Live Planetary Dashboard, an example of taking a simple real-time data stream and making it into a cool dashboard.  The guys from the ILOG Elixir team did a fantastic job! (see their dashboard here).

Now it’s your turn to impress!  Today we are announcing a contest for the coolest dashboard using the real-time data feed from the Tour de Flex server.

Contest rules:

• The contest starts today and ends on Tuesday, July 7th at noon ET (was originall 6/26/09)
• Submissions will be judged myself, Christophe Coenraets, James Ward and Ben Forta
• The winner will receive a copy of ILOG Elixir and a copy of Adobe Creative Suite 4 Web Premium.
• All source code must be submitted with the sample.  We plan to showcase the winning entry along with the source code so others can learn.  We might also include several entries in the Tour de Flex Data Visualization category.  Feel free to include a brief paragraph about yourself in the comments of the source code.
• All 3rd-party dependencies must be clearly identified.  In other words, I need to be able to build and run your project.  I will mask out any included API keys, etc. from your source before posting.  Feel free to mask it out yourself.
• Commercial product dependencies (e.g. ILOG) are acceptable as long as a trial version is available to users that want to try the code.
• The project must be built using Flex 3.x.  It’s ok to also include non-Flex SWFs as well, just be sure to include the FLA.
• The application can either be a web app or a desktop app deployed on AIR.
• Judging will be based on creativity and the cool factor

All submissions and questions should be emailed to gregsramblings at gmail.  Submissions should include the following information:

• Your name, company name and daytime phone number
• A brief description of what you submitted
• Any special instructions on building and running the application
• List of any 3rd party dependencies or libraries
• Flex project ZIP file

Making it all work

We have created two sample applications for you to use as a foundation:

• Simple real-time data grid – http://tourdeflex.adobe.com/remotesamples/DataAccess/dashboard/tdfdashboard.html – VIEW SOURCE is enabled
• Simple historical data grid – http://tourdeflex.adobe.com/remotesamples/DataAccess/tdfhistory/tdfhistory.html – VIEW SOURCE is enabled
• Once you receive the sample ID, you can look up the sample name and other information from http://tourdeflex.adobe.com/download/objects-desktop.xml

Key source code

Below are the key elements of the source code that you’ll need to have in your application.  You should be able to copy/paste the code directly into Flex Builder and get started.  There are no dependencies unless you enable the RTMP channel which requires fds.swc.

Plugging into the data:

    <mx:ChannelSet id="channelSet">
        <!-- RTMP channel (requires fds.swc, part of LiveCycle Data Services) -->
        <!-- Uncomment out the following line if you have fds.swc, otherwise, simply leave the next line commented -->
        <!-- <mx:RTMPChannel id="rtmp" url="rtmp://tourdeflex.adobe.com:2037"/>   -->
        <!-- Long Polling Channel -->
        <mx:AMFChannel url="http://tourdeflex.adobe.com:8080/lcds-samples/messagebroker/amflongpolling"/>
        <!-- Regular polling channel -->
        <mx:AMFChannel url="http://tourdeflex.adobe.com:8080/lcds-samples/messagebroker/amfpolling"/>
    </mx:ChannelSet>

Subscribing to the feed:

    <mx:Consumer id="consumer"
        channelSet="{channelSet}"
        destination="tdf.sampleviewingfeed"
        subtopic="flex"
        message="messageHandler(event)"/>

Handing each new data event:

            private function messageHandler(event:MessageEvent):void
            {
                items.addItem(event.message.body);
                // Do your magic here!  This will be called upon each sample viewed in Tour de Flex
            }

Getting historical data

IMPORTANT:  No more than 7 days of historical data may be retrieved in any one call.  Please don’t make unnecessary repeated calls to our server (for obvious reasons).

Creating the RemoteObject:

    <mx:RemoteObject id="srv" destination="sampleRequestDAO" channelSet="{cs}" showBusyCursor="true">
        <mx:method name="find" result="resultHandler(event)"/>
    </mx:RemoteObject>

Passing dates and handling resulting rows:

            [Bindable]
            private var items:ArrayCollection;

            private function find():void
            {
                // A MAX of 7 days can be requested.  More than 7 days will throw an exception
                srv.find(dateFrom.selectedDate, dateTo.selectedDate);
            }

            private function resultHandler(event:ResultEvent):void
            {
                items=event.result as ArrayCollection;
            }

You can find more information about the existing dashboard in my previous blog post and Christophe’s recent blog post.

GOOD LUCK!!

Right on the heels of Tour de LiveCycle comes LiveCycle Cafe, a desktop tool to help you stay in touch with the LiveCycle community, receive news, find information, and aggregate content related to Adobe LiveCycle ES (Enterprise Suite).  Targeted at developers and technical staff, LiveCycle Café is the one tool you need to search across the entire community knowledge base and stay in touch with the Adobe LiveCycle teams.

Between Tour de LiveCycle and LiveCycle Cafe, you will be hooked up with LiveCycle goodness.  Check it out at http://www.adobe.com/go/cafe.  It only takes a few seconds to download and provides immediate value.

Now that you have downloaded the new Tour de LiveCycle tool and became an instant fan of LiveCycle ES (Enterprise Suite), you are probably wondering where you could learn even more, right?  Well, earlier this week, we announced a new program at Adobe MAX 2009 called the “LiveCycle @MAX Bundle”.  Designed for enterprise developers, this program combines 1.5 days of introductory pre-conference training with a full MAX conference pass.

Pricing and additional details are available here.   I suspect that this will fill up quickly so signup!

As members of the Adobe Evangelist team, we are often asked, “What is LiveCycle Enterprise Suite (ES)”? That’s not an easy question to answer! The challenge is that LiveCycle ES is not a typical product with a typical list of features.  It’s an extensible platform that offers a wide array of services, each with its own set of capabilities. In addition, LiveCycle ES provides the infrastructure to manage and deploy these services as well as the ability to combine them into a business process where they can be integrated with other technologies as well as with people.

After the success of Tour de Flex, we decided that a similar interface could be useful as a means of exploring the features of LiveCycle.  We combined forces with Avoka Technologies’ LiveCycle gurus and created a vast collection of content including samples, videos, whitepapers and more.

You can grab Tour de LiveCycle from http://www.adobe.com/devnet/livecycle/tourdelivecycle. (BACKUP LINK: http://tourdelc.adobe.com/badge). It is built on Adobe AIR and will run on Windows, Mac and, Linux.  All of the content is hosted so the installer is only about 1.5MB.  We do plan to offer more content locally as part of the application in future versions so that it will be available offline and load faster.

If you are curious about LiveCycle ES, this is a great first step.  If you are an existing LiveCycle ES customer, you will find that Tour de LiveCycle is a valuable reference tool. And if you are a Flex developer who thinks that LiveCycle ES is only about data services, I’m betting that you’ll be surprised to find that LiveCycle ES is much, much more.  It goes well beyond <mx:RemoteObject>!

If you blog frequently on topics related to LiveCycle ES, please share the install badge by adding the following HTML:

<iframe width="216" height="182" frameborder=0 scrolling="no" src="http://tourdelc.adobe.com/badge/"></iframe>

Ok, it’s technically not “planetary” since only one planet is involved… but… this is still pretty cool.   Check out the new ILOG real-time activity dashboard here (screenshot below).   What you are seeing is LIVE data from Tour de Flex.  Every time someone views a sample, a new dot appears.  Chances are if you go view a sample, you will see yourself on the map almost instantly!  Keep in mind that the geolocation is not perfect, but it’s pretty good!  See below for the scoop.

History

When we first launched Tour de Flex in November 2008, we built in a simple HTTPService call to a tiny backend PHP file that uses a database to log which sample was viewed.  We did this so that we could rank Tour de Flex search results by popularity and so that we could keep track of how many samples our application was serving up (see my recent post about reaching 5 million!).

In early March, I was looking at the latest ILOG Elixir components in their 2.0 release and I was especially fascinated by their heatmap visualization component.  That’s when I had an idea!  What if we could plot who was using Tour de Flex on the heatmap?!  Christophe Coenraets and I started talking about the potential and quickly determined that it was indeed possible.  We had to first find a way to convert IP addresses to latitude and longitude in real-time.  After a little research, we found MaxMind’s GeoIP technology and purchased their GeoIP City Database.

At this point, we had a source of constant data and a means of converting it to something that the heatmap component could use.  The next challenge was to figure out how to distribute the data so that multiple clients could subscribe to it and process it.  That’s where the publish and subscribe messaging features of  LiveCycle Data Services (or BlazeDS) come into the picture.

Christophe configured LiveCycle Data Services and created a Java servlet to handle the backend messaging.  He then created a simple Flex app that subscribes to the message topic and displays the data in an auto-updating datagrid that shows a new line every time a new sample was viewed in Tour de Flex.  Every second or two, I saw a new line of data appear.  The coolness was already starting to show.

I then sent the data grid code to our friends at ILOG with a short note that said, “Would you guys like to try and make a cool heatmap or other visualization of this data?” (the bait!).  A few days later, they sent us the dashboard that is linked above.  I was totally impressed!  Not only did they implement the heatmap, they also included other visualizations to really put it over the top!  I shared the link with a few internal folks and the reaction was fantastic; although a few people complained that they spent too much time staring at the dashboard instead of working. 

How it works

The diagram below provides a high-level description of how everything fits together.

• Christophe Coenraets provides all of the details including source code related to the messaging in his blog post.
• Damien Mandrioli from ILOG provides the source code in the dashboard itself (right-click the application and choose “View Source”)

Future possibilities

As you can see, this application was fairly easy to build.  There are some intriguing possibilities created by combining pub/sub messaging with data visualization.  I’m already thinking about building a similar dashboard to monitor traffic to Flex.org as well as my blog and other sites!  I’m sure that you are already thinking of other applications.

A big THANKS to the guys at ILOG for building the dashboard!  We are already working with them on adding historical data analysis to the dashboard.

Another THANKS goes out to Christophe for building the backend infrastructure and helping me quadruple my knowledge about pub/sub messaging!  (By the way, a good starting point on pub/sub messaging is Christophe’s Adobe TV video)

A few of the guys that helped us build Tour de Flex and several other projects have entered the world of iPhone applications and have just released a cool, addictive game called “Box of Sox”.  It’s fantastic for kids and adults.

Check it out on iTunes here or at their home page http://www.reallymedia.com/

They are also working on a lot of cool new Flex and AIR projects at http://hdinteractive.com.

Since we launched Tour de Flex at MAX last November, we’ve had fun watching the count of samples viewed climb to unforeseen heights.  Now we are quickly approaching 5 million views so we’ve decided to have a little fun.

Recently, I added a live sample counter to the quick start page  (We will blog about how we used LiveCycle DS publish/subscribe messaging to create the counter very soon).

Here’s the deal:  If you are one of the first three people to email  a screenshot of the counter at exactly 5,000,000 to the email address below, you win a Mino HD Flip Camera!  Depending on the time of day we reach 5,000,000, this might be tough!  The rate of samples being viewed peaks at about 80 per minute!  The winning number may only display for a fraction of a second.

Rules:

• The screenshot must be made of the desktop version of Tour de Flex.  Screenshots of the web version will not be accepted.
• The screenshot must contain the entire application window.
• NO photoshopped fakes!  We’ll know!  We have secret technology! 
• The screenshot must be emailed to tdfcounter@gmail.com within 5 minutes of being captured.  After prizes are awarded, we will delete all received emails from the gmail account to protect your email address.  Your email address will not be used for anything other than award notification.
• If you capture a perfect 5,000,000, the email subject should be “5 million”
• If you capture something very close, the email subject should be “So close!”.  We will ignore these unless nobody captures the perfect 5,000,000.

Prizes:

• The first 3 emails received with a screenshot of 5,000,000 win a MinoHD Flip Camera! ($200USD value!)
• If nobody captures the 5,000,000th view, the prizes will be awarded to the next closest attempts, so if you miss the 5 million mark but capture something really close, submit it.
• If the counter malfunctions or goes offline, no prize will be awarded.  We’ve worked hard to make sure that the counter can handle a large number of viewers but the load is unpredictable, so who knows what will happen!

Why are we doing this?

• For fun of course!
• To promote Flex and show off publish/subscribe messaging with LiveCycle DS and BlazeDS.  Just wait and see what we are going to do with the data feed next week!

Good luck!!

This morning, the New York Times launched a new desktop application for reading their newspaper built on Adobe AIR.   At first glance, you may ask, “What’s the big deal? – I can read the New York Times online already”.  When I first heard about this application, I asked the same question!

I’ve seen a few applications that have been deployed as AIR applications that honestly should have been deployed as a web app.  I’m much more particular about who I let in my programs menu than my bookmarks list. I blogged about this a few months ago when Pizza Hut launched their new AIR application – http://gregsramblings.com/2008/05/28/to-air-or-not-to-air-pizza-hut/

I’m happy to report that the New York Times reader is great example of an AIR app built for AIR for the right reasons.  The best reason can be illustrated in a quick screen shot from the new app’s settings page:

As you can see, the New York Times Reader application works offline.  I can store up to 7 issues of the New York Times on my machine and read them anytime I want, even when I don’t have an internet connection.   For example, you can download the application now and start reading yesterday’s issue of the paper.  The crossword puzzle also works offline and remembers your progress.

The application itself is fantastic.  It utilizes the new Text Layout Framework available in Flash Player 10 and AIR 1.5 so it can do much cleaner text display than a regular web page.   The page is dynamically formatted specifically for your screen size.  If you have a large screen, you get more columns and larger pictures.  If you have a smaller screen, it compensates very nicely with fewer columns and smaller images.  Download it and view some news and re-size the page a few times.  You’ll be amazed.

Don’t forget to check out the crossword puzzle – it has some interesting features of its own.

Because it’s built on Adobe AIR, it works on Windows, Mac OS and Linux.

I hope we see more applications like this soon.  You can download a copy from here.

Two months ago, I blogged about my new Panasonic DMC-LX3 camera.  Since purchasing the camera, I’ve taken it on multiple trips and use it almost daily.  After two months, I’m happy to report that I’m still loving it.

My favorite features are still the same:

• The 24mm f2.0 lens is fantastic
• The sturdy construction has held up well so far as I toss it into my bag during every trip
• The controls are intuitive and well placed
• The optical image stabilization is awesome
• The image quality is superb

My complaints are also still the same:

• I don’t like the separate lens cap.  It’s a miracle that I haven’t lost it!
• Battery life is not great, but it’s acceptable.  I purchased an extra battery that travels with me
• I wish it had more zoom, but for me, it’s worth the sacrifice to get the 24mm equiv wide angle
• The high-ISO performance is not great… BUT… it’s still a fantastic low-light camera.  See below

Shooting in low light and ISO

The DMC-LX3 allows the ISO to be set as high as 3200, however I would not recommend it.  With the amazingly fast f2.0 lens and the lens stabilization feature, I’ve never needed anything above ISO 800, even in very dimly lit scenes.  I don’t hesitate to shoot at 1/15th of a second shutter speed (although, I’ll take a few extra shots just in case).   If you own this camera, I highly recommend that you make the following setting change:  Go to the ISO LIMIT SET menu option and change it to 800.  This will prevent the camera from going higher than ISO 800 which will keep your photos looking great.  I’ve personally had better luck avoiding the “iA” mode on the camera.  I mostly shoot on either “P” or “M”.

Here’s an example. The following shot is at ISO 80, hand-held at 1/8th of a second. Click the image to see the high-res version.  I consistently get good low-shutter speed shots with the LX3.

On a recent trip to Seattle, I made a quick stop at the Seattle Aquarium.  I had my trusty Nikon D300 with both my 18-200mm lens and my 50mm 1.4 lens.  The 18-200mm lens was too slow (3.5-5.6) to get any good shots of the dimly lit aquarium life.  The 50mm 1.4 lens was more than fast enough but it has no macro capabilities so I found myself without a good lens for the situation!  I suddenly missed my old 55mm micro lens.  So, I put away my D300 and pulled my LX3 from my jacket pocket and found that it was perfect for the task.  Since aquariums have a wide range of lighting, I set the camera to manual (”M”), tweaked the exposure a bit and started shooting.  Below are a few results from the visit:

Below are a few more shots I’ve taken with the LX3:

All of the above photographs as well as tons of other shots are on my SmugMug site at http://gregorywilson.smugmug.com

Flash Camp Orlando is now open for registration!  If you register in the next 29 hours, you can get in at a discounted rate.  The event is Friday, May 29th, 2009 at the University of Central Florida Live Oak Event Center.  Registration details can be found at http://www.flashcamporlando.com

For those of you that attended Flash Camp Miami, you know that these are great events!  I’ll be speaking myself and will be bringing some good swag.

Load up the family, drop them off at Disney and then come play with Flash, Flex and AIR!

More details on speakers, etc. will be posted soon.

A few weeks ago, Holly Schinsky (one of the developers of Tour de Flex and other cool projects) did some research on becoming “Flex/AIR Certified”.  My first reaction was to roll my eyes because I’ve never really believed in certification programs.  I’ve always felt that they measure someone’s test-taking abilities rather than their ability to write solid code (two very different skills!).  However, Holly’s experience with it has changed my perception a bit.

• Holly wrote a blog post titled, “Adobe Flex/AIR Certification?” that had some interesting comments on the topic that helped me understand people’s motivation to get certified
• She then blogged about Attest, a tool she discovered for taking practice exams.  She actually jumped in to help build the latest version (which is free by the way)
• A few days ago, she took the test herself and is now certified

Holly provides some useful feedback on the experience that is a must-read for anyone considering taking the test.

We released new content on the Adobe Developer Connection covering the migration from ActionScript 2 to ActionScript 3.  If you are still using ActionScript 2, take a look at http://www.adobe.com/devnet/actionscript/migration.html

This new content includes “ActionScript 3 migration cookbook“, available online or as a 40 page PDF that is full of tips and tricks.

I spent some time today pulling statistics for the usage of Tour de Flex in the last 16 days (4/5/2009 – 4/20/2009).  The results were pleasantly surprising:

Last 16 days of data:

• 556,133 samples viewed (34,000+ per day!)
• Total of 4,213,937 viewed since we launched at MAX on 11/16/2008!
• Tour de Flex application was executed 68,096 times
  • 75% of the usage was from the desktop AIR version
  • 25% was from the recently released web version
• 1,368 installations of the Tour de Flex Eclipse plugin
• 500+ new downloads of the desktop version every day

We’ve been adding new samples every few days.  Many more are coming, including a ton of new samples that illustrate how to use Flex with ColdFusion, PHP, .NET, Ruby, and other popular server platforms.   We are also working on extensive samples around BlazeDS and LiveCycle DS, including the more advanced data management capabilities of LiveCycle DS.

Keep your contributions of samples and components coming!