Matthew Fabb’s blog

Some of the coolest, groundbreaking stuff at MAX is shown in very raw form at Adobe’s Sneaks (last year they were called Sneak Peaks). This is where you get to see the type of things Adobe is doing R&D on straight from the engineers.

UPDATE: Looks like for the first time Adobe has put all Sneak videos online on AdobeTV here in HD!!

So listing all the YouTube videos aren’t necessary anymore, so I have gone ahead and removed them all. All the videos are really quite cool, however ActionScript developers will likely be interested in seeing:
- Reverse Debugging in Flash Builder.
- Monocle that demos the upcoming profiler and shows how powerful Telemetry is in providing internal data from the Flash Player.
- GPU Parallelism demoing ActionScript processes on the GPU. Thibault Imbert mentions in another MAX session that this example is part of a team looking into ways of expanding ActionScript language into new directions

Now the rest of the non-developer related Sneaks are really quite cool, but the following sneak of a Photoshop example of deblurring an image is just mind blowing and more so when you can see it in HD. It’s something that could literally change photography. While I imagine we will first see it in Photoshop CS6 or CS6.5, it’s the sort of feature that I hope makes it into more Adobe consumer products, as I can see it as something that people would pay for just that feature on it’s own.

I figured I would give a quick update on multithreading in Flash, as since I wrote about the subject last year, around 80% of the search engine traffic coming to my site are using keywords “multithreading in Flash”, “concurrency in Flash”, “threads in Flash” and literally hundreds of other variations. If you follow the latest Flash news then some of this might be old news, but I figured I would summarize it and then make some guesses about the future.

What will the API look like?
So earlier this year at Flash Camp Brazil, Arno Gourdol from Adobe had a future of Flash presentation. He covered quite a few things including what the concurrency API likely would look like. Here is the slides for that presentation (PDF) and bellow is the code sample found in that presentation:

myworker.swf

Note this is not finalized and could change but for now it’s basically the Web Workers API from JavaScript.

The presentation notes mention that this will allow developers to leverage multi-core CPUs, you can have multiple workers at the same time and it is a shared-nothing isolation model.

Also note that Adobe has also been working on putting other Flash processes on a separate thread. Example they put bitmap decoding on a separate thread. This was added to Adobe AIR in version 2.6 and added to the Flash Player in the 10.3 update.

What do developers think of this?
There’s been some interesting discussion on whether this is adequate enough for developers here on bugs.adobe.com (if you haven’t already please vote for that feature request). Joa Ebert in particular has some interesting comments. I agree with these and other comments that a low level API is still need, but this current solution is enough to solve the most common problems of UI locking in Flash. However, with Molehill/Stage3D coming in Flash Player 11, we are likely going to see a lot more complicated 3D games that could use a better system later down the road.

When?
So concurrency is finally coming to Flash!! The next question big question is when is this happen? Many including myself though it would be in Flash Player 11, but unfortunately this worker API is not in the Flash Player 11 beta currently out.

I asked Thibault Imbert, the Product Manager for the Adobe Flash Runtimes about this on Twitter and he confirmed that worker threads would not be coming to Flash Player in version 11.0.

Which is unfortunately to hear after waiting for this feature such a long time. Now this doesn’t mean we are going to have to wait for Flash Player 12 for this feature. As Adobe also announced earlier this year is Flash is now on a quarterly release schedule. Which is why we have seen new features in minor updates of Flash with 10.2 then a 10.3. Flash Player 11 is likely to be released by the end of this year but we should be getting a Flash Player 11.1, 11.2, etc. with new features each time before we hit another big upgrade with Flash Player 12.

So how close is this API from being released in a future version of Flash Player? Close enough that there is a session at Adobe’s MAX conference in October 2011, called “Concurrency in Flash Runtimes“. So I would guess it will be available with Flash Player 11.1, possibly 11.2 at the latest. Either way, we should find out a lot more information after Adobe MAX.

Either way, concurrency is coming to Flash, it’s just taking a long time to get here.

So the new Flash Player Incubator program is really quite exciting seeing the Flash Player while it’s still in development and before it reaches beta. Now a lot of the attention so far on the incubator builds of Flash Player have been on Molehill, the new 3D API but I’m also curious about what else is in there.

Poking around in the docs one of the interesting things that I found is mention of a Flash Player 10.3 and AIR 2.7. So while these incubator builds are a sort of alpha of Flash Player 11, there’s going to be another Flash Player and AIR release between now and Flash Player 11 & AIR 3.0.

Another interesting thing is the classes in the flash.hid directory. HID stands for Human Interface Device, which is likely the game controller support Adobe has been talking about. It’s not working just yet, but you can see the devices Adobe has been playing around with, some of them really quite different and strange (like a Magic Carpet Simulator device, to VR gear). Some of them with references to DVDs and VCRs, I wonder if it has to do with Flash being on tvs now. Also those following the PlayBook development might realize it’s OS is called QNX. QNX is a company that RIM bought out and still provides it’s OS for everything from cars to equipment on NASA’s Space Shuttle. With QNX running Flash it running on cars, I wonder if that’s where things like variables referring to car alarms comes from.

So I used NotePad++ to do a complete search through the files to find any reference to Flash Player 10.3 & 11 and AIR 2.7 & 3.0. From that search I grabbed all the HTML code and dumped it into a document and have copied and pasted it bellow. It’s not formatted the best, but it’s not something I wanted to spend too much time on and it links to where I’ve uploaded the docs on matthewfabb.com, so you can see how it’s supposed to look like or just to get more details on a class without having to download and unzip the docs yourself.

Here’s how it’s set up, I’ve listed classes bellow with new methods, properties and constants all listed underneath. You can tell which classes are brand new by the fact that I linked to them. Anything not taken from the docs bellow I tried to highlight the fact by putting it italics. I start with Flash Player 10.3 & AIR 2.7, then move into Flash Player 11 & AIR 3.0, then finally Flash Player 12 (??) & content without mention of any version of Flash. Remember I’m not including any of the 3D classes here and also it’s quite possible that I missed some of the new stuff in putting it together so quickly. If you come across that let me know and I’ll update this post.

NOTE:This is based off of the docs from the February 27, 2011. There’s likely other incubators builds of the Flash Player in the works and at that point all of this is likely to be quite dated.Also realize that Adobe has clearly pointed out again that a number of these APIs are still experimental and anything could be pulled out or renamed.So don’t go building something new expecting everything to make the final release.

Flash Player 10.3 & AIR 2.7

FontMetrics
lineGap : Number
The lineGap value is the suggested gap between lines.

EastAsianJustifier
composeTrailingIdeographicSpaces : Boolean
Specifies whether ideographic spaces at the ends of lines should be composed or dropped during justification.

Microphone
enhancedOptions : MicrophoneEnhancedOptions
Controls enhanced microphone options.
getEnhancedMicrophone(index:int = -1):Microphone
[static] Returns a reference to an enhanced Microphone object.

MicrophoneEnhancedMode
FULL_DUPLEX : String = "fullDuplex"
[static] Acoustic echo cancellation operates in full duplex mode.
HALF_DUPLEX : String = "halfDuplex"
[static] Acoustic echo cancellation operates in half duplex mode, which represents a simpler processing when compared to full duplex mode.
HEADSET : String = "headset"
[static] Headset in use.
OFF : String = "off"
[static] All enhanced audio functionality is turned off.
SPEAKER_MUTE : String = "speakerMute"
[static] Use this mode when the speaker is muted.

MicrophoneEnhancedOptions
The MicrophoneEnhancedOptions class provides configuration options for enhanced audio.
autoGain : Boolean
Enable auto-gain control.
echoPath : int
Specify the echo path (in millisecond) used for echo cancellation.
isVoiceDetected : int
[read-only] Returns whether voice was detected for Microphone input.
mode : String
Controls enhanced microphone mode.
nonLinearProcessing : Boolean
Enable non-linear processing.

NetMonitor
The NetMonitor class has two functionality. It contains a single method listStreams(), that returns the vector of NetStream objects. Second, NetMonitor class dispatches NetMonitorEvent of NetMonitorEvent.NET_STREAM_CREATE type whenever a new NetStream object is created.
listStreams():Vector.<NetStream>
Retrieve all NetStream objects belonging to the same security context.
Event: netStreamCreate
Dispatched when a new NetStream object is created.

NetStreamInfo
isLive : Boolean
[read-only] Returns whether the media being played is recorded or live.
metaData : Object
[read-only]Retrieve last meta data object associated with media being played.
resourceName : String
[read-only] Return resource name used when NetStream.play() was called.
uri : String
[read-only] Return the URI used when NetConnection.connect() was called.
xmpData : Object
[read-only] Retrieve last XMP data object associated with media being played.

NetMonitorEvent
NetMonitorEvent object is dispatched whenever a new NetStream object is created. There is only one type of event: NetMonitorEvent.NET_STREAM_CREATE.

See class for properties, methods and constants

NetDataEvent
NetStream dispatches this event when message is processed.

See class for properties, methods and constants

Security
pageDomain : String
[static] [read-only] Get the page domain containing the swf.

SWFVersion
FLASH11 : uint = 11
[static] SWF file format version 11.0. – Runtime Versions: Flash Player 10.2
FLASH12 : uint = 12
[static] SWF file format version 12.0. – Runtime Versions: Flash Player 10.3

Flash Player 11 & AIR 3.0

DisplayObjectContainer
removeChildren():void
Removes all child DisplayObject instances from the child list of the DisplayObjectContainer instance.

MovieClip
isPlaying : Boolean
[read-only] A Boolean value that indicates whether a movie clip is curently playing.

Event
TEXT_INTERACTION_MODE_CHANGE : String = "textInteractionModeChange"
[static] The Event.TEXT_INTERACTION_MODE_CHANGE constant defines the value of the type property of a interaction mode event object.

HIDConsts
This is class is way too big to list all of the many, many constants in this class. Check the class definition for the full list of HID (Human Interface Device) that Adobe is looking into. I just pulled out some of the more interesting ones:
HIDPage_BarCodeScanner
HIDPage_BatterySystem
HIDPage_Digitizer
HIDPage_KeyboardOrKeypad
HIDPage_Telephony
HIDPage_VR
HIDUsage_BS_iDevicename
HIDUsage_BS_SMBAlarmWarning
HIDUsage_BS_ThermistorCold
HIDUsage_BS_ThermistorHot
HIDUsage_Button_1 (up to button_4)
HIDUsage_Csmr_ALLANOrWANBrowser
HIDUsage_Csmr_FanEnable
HIDUsage_Csmr_FireAlarm
HIDUsage_Csmr_MediaSelectCD
HIDUsage_Csmr_MediaSelectDVD
HIDUsage_Csmr_MediaSelectSatellite
HIDUsage_Csmr_MediaSelectTuner
HIDUsage_Csmr_MediaSelectTV
HIDUsage_Csmr_MediaSelectVCR
HIDUsage_Csmr_MediaSelectVideoPhone
HIDUsage_Csmr_MediaSelectWWW
HIDUsage_Csmr_MPX
HIDUsage_Csmr_NumericKeyPad
HIDUsage_Csmr_OrderMovie
HIDUsage_Csmr_PoliceAlarm
HIDUsage_Csmr_RoomTemperature
HIDUsage_Csmr_SleepMode
HIDUsage_Csmr_Treble
HIDUsage_Csmr_VCROrTV
HIDUsage_Dig_Armature
HIDUsage_Dig_FreeSpaceWand
HIDUsage_Dig_LightPen
HIDUsage_Dig_StereoPlotter
HIDUsage_Game_3DGameController
HIDUsage_Game_GunDevice
HIDUsage_Game_PinballDevice
HIDUsage_GD_GamePad
HIDUsage_GD_Joystick
HIDUsage_GD_Keyboard
HIDUsage_LED_CameraOn
HIDUsage_LED_FastBlinkOnTime
HIDUsage_LED_NightMode
HIDUsage_LED_PaperJam
HIDUsage_LED_PaperOut
HIDUsage_PID_ET_SawtoothDown
HIDUsage_PID_ET_Square
HIDUsage_PID_ET_Triangle
HIDUsage_Sim_AirplaneSimulationDevice
HIDUsage_Sim_AutomobileSimulationDevice
HIDUsage_Sim_AutopilotEnable
HIDUsage_Sim_BarrelElevation
HIDUsage_Sim_BicycleSimulationDevice
HIDUsage_Sim_MagicCarpetSimulationDevice
HIDUsage_Sim_MotorcycleSimulationDevice
HIDUsage_Sim_SailingSimulationDevice
HIDUsage_Sim_SpaceshipSimulationDevice
HIDUsage_Sim_SubmarineSimulationDevice
HIDUsage_Sim_TankSimulationDevice
HIDUsage_Sprt_BaseballBat
HIDUsage_Sprt_GolfClub
HIDUsage_Tfon_AnsweringMachine
HIDUsage_Tfon_Headset
HIDUsage_Tfon_OutsideDialTone
HIDUsage_Tfon_PhoneDirectory
HIDUsage_VR_AnimatronicDevice
HIDUsage_VR_Belt
HIDUsage_VR_BodySuit
HIDUsage_VR_Glove
HIDUsage_VR_HeadMountedDisplay
HIDUsage_VR_HeadTracker
HIDUsage_VR_Oculometer

HIDDevice
controlCount : int
[read-only] returns the number of controls available
name : String
[read-only] returns the name of the device
usage : int
[read-only] property containing the usage
usagePage : int
[read-only] property containing the usage page

HIDControl
device : HIDDevice
[read-only] returns the device that owns this control
hasCenter : Boolean
[read-only] property is true if the control has a center position (joystick for example)
hasNullState : Boolean
[read-only] property is true if control has a null state
input : Boolean
[read-only] property is true if the control is a input control
linear : Boolean
[read-only] property is true if the control linearly change from min to max
max : Number
property containing ther maximum value of a control
min : Number
property containing the minimum value of a control
relative : Boolean
[read-only] property is true if the control value returns a relative change since last event
type : int
[read-only] property containing type of control
units : Number
[read-only] property containing the unit of value
usage : int
[read-only] property containing control usage
usagePage : int
[read-only] property containing control usage page
value : Number
property containing the value of the control.

HIDManager
deviceCount : int
[static] [read-only] returns the number of devices currently attached
focused : Boolean
[static] [read-only] property containing the focus state of the manager
names : Array
[static] [read-only] retruns the list of devices names

Matrix
copyColumnFrom(column:uint, vector3D:Vector3D):void
Copies a Vector3D object into specific column of the calling Matrix3D object.
copyColumnTo(column:uint, vector3D:Vector3D):void
Copies specific column of the calling Matrix object into the Vector3D object.
copyFrom(sourceMatrix:Matrix):void
Copies all of the matrix data from the source Point object into the calling Matrix object.
copyRowFrom(row:uint, vector3D:Vector3D):void
Copies a Vector3D object into specific row of the calling Matrix object.
copyRowTo(row:uint, vector3D:Vector3D):void
Copies specific row of the calling Matrix object into the Vector3D object.
setTo(aa:Number, ba:Number, ca:Number, da:Number, txa:Number, tya:Number):void
Sets the members of Matrix to the specified values

Matrix3D (all of Matrix’s methods above plus)
copyRawDataFrom(vector:Vector.<Number>, index:uint = 0, transpose:Boolean = false):void
Copies all of the vector data from the source vector object into the calling Matrix3D object.
copyRawDataTo(vector:Vector.<Number>, index:uint = 0, transpose:Boolean = false):void
Copies all of the matrix data from the calling Matrix3D object into the provided vector

Point
copyFrom(sourcePoint:Point):void
Copies all of the point data from the source Point object into the calling Point object.
setTo(xa:Number, ya:Number):void
Sets the members of Point to the specified values

Rectangle
copyFrom(sourceRect:Rectangle):void
Copies all of rectangle data from the source Rectangle object into the calling Rectangle object.
setTo(xa:Number, ya:Number, widtha:Number, heighta:Number):voidSets the members of Rectangle to the specified values

Sound
loadMP3FromByteArray(bytes:ByteArray, bytesLength:uint):void
load MP3 sound data from a ByteArray object into a Sound object.
loadPCMFromByteArray(bytes:ByteArray, samples:uint, format:String = "float", stereo:Boolean = true, sampleRate:Number = 44100.0):void
load PCM 32-bit floating point sound data from a ByteArray object into a Sound object.

TextField
textInteractionMode : String
[read-only] The interaction mode property, Default value is TextInteractionMode.NORMAL.
textInteractionModeChange Event
Flash Player dispatches the textInteractionModeChange event when a user changes the interaction mode of a text field.

TextInteractionMode
A class that defines the Interactive mode of a text field object.
See class for properties

Flash Player 12
Strange labeling here, which I’m guessing is the Flash Team’s way of pushing elements out of a build. So I’m guessing these functions were pulled in last minute:

Graphics & GraphicsPath classes both have:
cubicCurveTo(controlX1:Number, controlY1:Number, controlX2:Number, controlY2:Number, anchorX:Number, anchorY:Number):void
Adds a new "cubicCurveTo" command to the commands vector and new coordinates to the data vector.

Flash Player ???
Now the following is that are not marked what runtime version they are in. I imagine these are the most experimental of the APIs. Unfortunately, there’s nothing marking them so that they are hard to find via NotePad++ or any other program using just search. To find them there would require to write or script to compare the docs to an older version of the docs. The one property that I found added to Socket was only because Adobe’s Thibault Imbert pointed it out on Twitter.

Socket
bytesPending : uint
[read-only]bytesPending

After many years of developers asking for the feature, at Adobe is talking about adding multithreading, or at least some sort of concurrency system to the Flash Player!

I’m surprised it wasn’t bigger news at Adobe MAX 2010, perhaps putting it into the second Adobe MAX keynote. Instead, the news was slipped into the Flex Roadmap session at MAX. Which again is a bit strange, rather than to see it in the Flash Platform Runtimes Roadmap session. The MAX session can be seen online here on Adobe TV and they start talking about it shortly after the 40 minute mark.

In the session Deepa Subramaniam, the Flex SDK Senior Project Manager went over the different ways of how Adobe could implement concurrency into the Flash Player. As the Adobe Flash Player team seems to be still looking to a system that is easy enough for new developers but complex enough for more experienced developers (from scripters to developers to software engineers is how they put it in the presentation).

Speaking of new developers, if you don’t know what multithreading or concurrency is, let me take a moment to explain why this is such a big deal.

One of the issues that you might have experienced in creating Flash content, is creating something where the responsiveness of the Flash UI slows down or stops. This has been documented by Ted Patrick and others as the elastic racetrack. Basically in each frame, there is only so much time to render graphics and to handle code. Too much of either being done in each frame and the famerate slows down and the Flash content lags. Typically it’s having too much code running in a single frame, as the code keeps running until everything that it’s asks to be done in that frame is done. This especially becomes an issue when say parsing a large piece of data, or encoding a PNG file and the UI freezes until this is complete.

There are plenty of tricks and hacks to get around this issue, even a green-threading (simulating multiple threads in a single thread environment). However, ultimately, having some sort of concurrency system creates a proper solution. Then when Flash content does something very intensive, it can do this separately, in a different thread and have the rest of UI still respond to the user, then deal with the results when the process is finished. Also if it’s a multi-core system, the thread can run on a separate core from the main thread, speeding up the process than if it was running on a single core.

Now this is one of the few areas that Adobe had been really falling behind in Flash. As Siverlight has had multithreading since version 2. Also HTML5 introduced something called WebWorkers, to allow JavaScript to run background threads, however it might still be a while before it’s supported on all browsers (Internet Explorer being the one as usual lagging behind, even the latest Internet Explorer 9 betas apparently don’t support it yet). For major applications, this is a serious enough of a issue I’ve personally seen decisions to use Silverlight for a large application being made largely because of the ability to run background threads.

Now I think a good way to introduce threading to Flash that a range of developers would be able to understand and is to use a similar API as found with HTML5′s WebWorkers. Similar APIs means developers switching back and forth between JavaScript and ActionScript don’t have much new to learn and new developers can learn the ActionScript API knowing that their skills are transferable. Also from what I understand WebWorkers having read just a bit about it, is that it’s a simple model that fits Adobe’s guidelines of something that novice developers can handle. Also Jim Corbet from the Flash Player team has hinted in the past at FITC Toronto that something like WebWorkers is likely the way Adobe will.

Before I managed to publish this post, Thibault Imbert from Adobe updated the multithreading feature request on bugs.adobe.com saying the following (just a participial quote, go to the link for full comment):
“…yes bringing MultiThreading to the runtimes would be sweet. But even if the idea of having a full multithread API in the Flash runtimes looks great on the paper, I do believe that this is not hat most of the people expect and want to leverage. A low level implementation would add complexity (locking, shared memory, code marshaling with the display list, etc.) and do not fit most of the cases that people have today on web apps.

So, today we are looking at an incremental approach with a first implementation similar to the BackgroundWorker API in C# or WebWorkers in JavaScript. You want to pass content to it, have the code run in a separate thread, dispatch events (begin, progress, complete) and hide the complexity and expose something easy. This would be valuable for Flex developers (heavy data parsing, number crunching, etc) but also game developers (vector rasterizing to bitmaps, etc).”

It would also make the API similar to what other languages or platforms expose and make transition easier for everyone.”

Many have already responded quickly on the feature request, which many were tracking, that this would be a great implementation that would fit most of their needs. However, well known Flash developer Joa Ebert (one of the main developers of AudioTool) has brought up the possibility of having a low level API which a more simple framework could be built over. So the framework could be built with a WebWorkers model and if that’s not enough for any of the more experienced developers, they could dive into the lower API and even perhaps more complex frameworks could be built. This would be the more ideal solution, unfortunately going on how Jim Corbett has talked about how the Flash Player is built, this might not be possible. As I’ve asked Corbett about multithreading at FITC Toronto years ago and he’s said for proper multithreading it would require a complete rewrite of how the Flash Player works. That such a rewrite might eventually happen but is currently very far down the road. So it might be that WebWorkers model is something that can be built into the Flash Player now until that re-write comes off in the future. Also the fact that Thibault said they are “looking at an incremental approach with a first implementation” sounds like the initial implementation won’t be very advanced.

It’s also interesting, that this topic was introduced by the Flex Product Manager during the Flex Roadmap session. I’m speculating that the reason for this is because Flex Hero SDK uses multithreading. As the reason that Flex Hero SDK does not yet have nightly builds is because it is using functionality built into a future version of the Flash Player that is not yet public. Also the Flex Hero SDK has 3 main goals, one of them being improving large applications development from improving the Flex infrastructure. Currently there are a few things working towards that goal such improving RSLs, but overall not much has been done in this area compared to making the mobile framework and adding new Spark components. However, including multithreading directly into the Flex framework would certain be a huge improvement for Flex developers working on large applications.

Note I give an update on multithreading in Flash here.

As I blogged about earlier, one of the highlights of FITC these past couple of years has been going to Jim Corbett‘s presentations on the internals of the Flash Player. They are like Tinic Uro’s posts on the Flash, a behind the scenes look at what goes on in creating the Flash Player, straight from one of the engineers on Adobe’s Player team, with tons of great info for Flash developerment. This was his third such presentation at FITC Toronto and this time the focus was what was done for the mobile version of Flash Player 10.1.

Now Corbett doesn’t have a blog and so he won’t be posting his slides unless FITC or someone from Adobe possibly post them for him. I knew this from previous years and also realized that content can be quite helpful to other Flash developers. So I’ve taken pictures of almost every slide (I arrived slightly late after lunch so I‘m not sure if there‘s any missing slide from the beginning) which you can go through on your own here on Flickr.

Some quick highlights on new things about Flash Player 10.1 that I’ve yet to hear elsewhere. Now Tinic Uro’s already blogged that Flash content scrolled out of view or on another tab will be paused or throttled to 2 frames per second, to save resources on the computer or device. Corbett expanded on this saying that there will be a new HTML parameter to control this called hasPriority. The default of this boolean value is set to false and setting it to true will stop Flash content from being paused or throttled. Tinic Uro also mentioned previous that Flash content with running audio and video doesn’t get paused or throttled. Check the slides for more details, but this is obviously important for people to be aware of since it is one of the few times where Adobe has done something to the Flash Player to effect existing content.

Corbett also explained in detail how Flash handles running out of memory on smaller devices, especially when there’s multiple instances of Flash and instances need to be shut down to save memory. If memory is low, new instances of the Flash files will not start up and need to be clicked on by the user to be then activated. He mentioned that Adobe was working on giving developers a chance to load in an image in place of the SWF, until the users clicked on it. Not sure if this last feature is coming with the initial release of the mobile Flash Player 10.1 or in later updates.

He also went into detail about how Flash is supporting hardware acceleration, with mobile getting some advances first. He also refused to answer any questions about Apple recently adding API support for video that Adobe had been asking for quite some time. Which is unfortunate, especially since Tinic Uro was able answer the question just days after FITC ended. That would have been cool info to have mentioned first at FITC. This is not a complaint directed towards Corbett, who’s obviously smart enough not to release anything before it’s supposed to be. This is directed at Adobe, who used to give small little cool tidbits first at Flash conferences like FITC.

Corbett also confessed that Adobe was late to the game in getting a proper 3D engine into Flash, however they were working on it, but he couldn’t say when it would be implemented in a public version of the player.

Before ending the presentation, he showed the abstract art that his young kid was doing in the Flash IDE, to the amusement of everyone and going along with FITC playground theme.

At the very end of the presentation up went a slide saying “What we want from you – What should the player do next?” where Corbett asked the audience that question. He then got out a piece of paper and wrote down requests from the audience, at times mentioning they were on their own wish list on the Flash Player team. One of items of interest to me which I think has been needed now for years is multithreading. He said true multithreading wouldn’t be coming Flash, as it would require a complete rewrite of the way ActionScript is handled, but they looking into having worker threads. Hopefully this is a feature that will make it out in Flash Player 11. I also asked about the direction of ActionScript with ECMAScript 4 being dead and he mentioned that no one wants an ActionScript 4 right now. That Adobe will continue what they have been doing, which is making modifications and additions to ActionScript 3. Colin Moock had an interesting suggestion, which was to have some sort of open forum to discuss the evolution and direction of ActionScript. Many of the feature requests people asked for were already in the Adobe’s JIRA Bug and Issue Management system, but it was still great to see someone from the Flash Player team take such interested in what developers wanted. Corbett wrote down everyone’s suggestions, filling up a page and half of audience suggestions.

Now FITC Toronto has been finished for over a week, but hope to get at least one more blog post about the conference.

Today begins the 9th annual FITC Toronto convention (although the workshop part began yesterday). I’ve been going to FITC since the 2003, although I missed 2 years (made up for it by winning tickets to FITC Hollywood one year I didn’t go). It’s always been a great time of learning combined with being inspired by what others are doing with Flash. I’m extremely lucky to have such a great conference where I live, rather than having to travel to go to conferences. I don’t think I would be the Flash programmer I am today without both FITC conferences and monthly FlashInTO user group meetings.

If you don’t already go to user group meetings in your area, check out Adobe Groups to see where they are organized in your area. If there isn’t one and you know of other Flash creators in your area, consider organizing one yourself.

Back to the conference, last year I was blogged for FITC and never posted the links on my website. However, checking now the links to the old FITC blog seem to be dead. Perhaps, I’ll achieve those posts later in my own blog.

This year it won’t be officially blogging for FITC, but will still be writing a few article for my own blog instead.

I’m really looking forward to seeing Jim Corbett’s 3rd FITC presentation on Flash Player internals, with this year a focus on mobile Flash. Learning behind the scenes info on how the Flash Player works from someone from the Flash Player engineering team is always geeky fun. Plus it’s great being able to ask him some questions after the presentation. Last year I asked about the future of ActionScript and ECMAScript, plus the chance of multi-threading happening in Flash Player. I may follow up on him with about the future of ActionScript and perhaps ask him about Sherlock (although that might be outside of the Flash Player’s team domain).

There’s other presentations that I’m really looking forward to, but the first session at FITC is about to start.

Also if anyone is interested I have a handful of free promo stickers from my work StickerYou, which say “code is beautiful”. If you see me at FITC, feel free to ask me for a sticker if I have any left.

So I’ve finally added my first feature request to the Flash Player in Adobe’s Bug and Database Management System. I’ve voted on quite a number of bugs and features, but never added added my own feature before.

It’s issue #FP-3889: “In the right-click context menu include a link to the player’s bug system”. So that users could see in the context menu something like “Report a Flash Player bug” which goes to http://bugs.adobe.com/flashplayer/

I think making more of the general public aware of the bug system would result in catching more bugs, which would result in a better Flash Player. I don’t think that the Flash Player is nearly as bad as many complain that it is, but I think this would be helpful. It could even help the image of the Flash Player to those who think it’s buggy.

Perhaps a step further would be to help less technical people in reporting bugs and include a Flash Player version detection that filled in the form with their version number, browser and operating system. It would also obviously mention if their Flash Player was out of date.

I’ve thought this would be a good feature for quite some time but finally got around to submitting it, as I got thinking about reporting bugs because of Ted Patrick’s recent campaign to get more Flash developers to report bugs in the Flash Player 10.1 and AIR 2.0 betas. Which is great, as I unfortunately still come across a few Flash and Flex developers and quite a number of Flash designers who aren’t even aware of bugs.adobe.com. Perhaps adding this to the context menu would not only help the general public more aware of the bug database, but could also make more of the Flash community aware of it.

So please vote for issue #FP-3889. If you don’t already have an account Adobe’s Issue database, and you are a Flash developer or designer, do yourself a favour and take the time to create an account. Not for the purpose of voting for my feature request (as that would be nice) but so that you can influence the future of the Flash Player (plus Flex SDK, BladeDS and more) plus bring attention to any bugs you might have come across.

Ted Patrick recently blogged that the betas for Flash Player 10.1 and Adobe AIR 2 is winding down. Beta #3 for Flash and AIR is set to come out in a couple of weeks, with the release version set to come out within 60 days.

So now is the time to report any remaining bugs, so that Adobe can fix them before the next big release. As the Flash Player team can only fix bugs if they are aware that they exist. While Adobe does do a lot of QA internally looking for bugs, there’s such an incredibly huge amount of Flash content out there on such a wide variety of platforms, that it’s impossible for Adobe to thoroughly test everything themselves. Which is why it’s important for people to discover and report any bugs they discover.

So here’s the link for Flash Player 10.1 Beta 2, and here’s the link for Adobe Air 2.0 and if you find any bugs they can be reported at bugs.adobe.com. Make sure you do a search before adding a new bug, as someone else might have already included that bug. In which case, you can vote for it to give the bug more priority.

This particularly relevant, with the recent discussion lately about Flash the result of the iPad launch and talk about HTML5, as part of these online discussions there are some who think that the problem with Flash is that it’s too buggy. There are groups who complain about the proprietary nature of Flash, yet I imagine few of these people realize that Adobe does have an open bug and issue database.

So it would be great, not just to test content with the betas, but to pass this along (via Twitter, Facebook, email, blogging or old fashion verbally mentioning it) to others. Perhaps even go beyond just Flash developers but also other technically inclined people who might take the time to report bugs. Non-Flash developers aren’t likely to be able to pin-point the cause of bugs without access to debug the source code, but they could still point to any Flash content causing any major bugs or crashes.

The more people are aware of bugs.adobe.com and the more bugs get reported before a major release is shipped, the better off the next version the Flash Player and with it Adobe AIR will be. It’s actually too bad that there isn’t a “Report a Flash bug” in the right-click context menu, so that more people outside of the Flash community could be aware that they can report bugs. Perhaps when I have time later this week, I will add that as a feature request, which is the other great side of the Bug & Issue database.

One last thing, if you look between the lines of Ted’s announcement that the release version of Flash Player 10.1 will be available within 60 days, that means CS5 will likely be out within 60 days. As a new release version of Flash has always come out within a few days of the new version of the Creative Suite.