Looking forward, Adobe believes that Flash is particularly suited for addressing the gaming and premium video markets, and will focus its development efforts in those areas. At the same time, Adobe will make architectural and language changes to the runtimes in order to ensure that the Flash runtimes are well placed to enable the richest experiences on the web and across mobile devices for another decade.So this is no huge surprise if you look at the effort Adobe has been putting into 3D rendering and graphics acceleration. I actually think this could be an awesome thing and would argue that the next big thing on the web will be multiplayer and social Flash based games. Not Farmville, but immersive experiences with lots of video and realism. I like the idea of architectural and language changes to speed things up. My first worry though is how the Apache Flex project will adapt to these changes. It will be imperative for the Adobe operatives in the Apache project to voice their opinions loudly, but it might become a debacle like the CFML steering committee. More on this later. The next point I'd like to make deals with:
Adobe believes that Flash Player will continue to stay at the forefront of online video by innovating in key areas. These include the following:Nothing here isn't exciting, and it all makes sense. I'm excited to see how they continue to innovate with DRM and analytics. Even more importantly, and so I don't geek out on the video stuff, is this line:
Adobe believes that Flash has a number of fundamental and unique advantages for video:
- Bringing Adobe's video streaming and content protection technology to more platforms in native formats
- Supporting the needs of premium content owners
- Closer collaboration with hardware vendors to provide high-performance quality experiences
- Single and consistent player and codec support across browsers, platforms, and operating systems
- Support for content protection (single DRM), which enables premium video content to be licensed for online distribution
- Mature, full-featured, proven solution that provides a "mission critical" video platform for premium content owners, including support for ad insertion and analytics
Single and consistent player and codec support across browsers, platforms, and operating systemsWhat I want to point out is that this closely mirrors my thoughts on why Flash and Flex are awesome. Why does Adobe embrace this with video, but they seem to forget that this is why Flex and Flash are awesome: penetration, cross-browser support, cross-OS support. I understand that Adobe is a tools company, but lets just see what Flash Next does to Flex. A few Flash Player roadmap nuggets to point out. These should be pretty exciting for game developers:
Now, here is an "are you freaking kidding me?" moment. I wish we could've done this with Flex applications for years:
- Support for more hardware accelerated video cards (from January 2008) in order to expand availability of hardware-accelerated content.
- New Throttle event API (dispatches event when Flash Player throttles, pauses, or resumes content)
- Multithreaded video decoding pipeline on PCs, which improves overall performance of video on all desktop platforms
Keyboard input support in full-screen modeThe possibilities for video delivery in full-screen mode with keyboard input are immense. It closes the gap between set top based AIR apps and their sister applications on the web. I am not sure how they decided to handle security, but I'd be interested in seeing how this plays out. Here is a language enhancement that will have a far reaching effect. Sit and chew on this one for awhile and you will understand:
ActionScript workers (enables concurrent ActionScript execution on separate threads)And now the meat:
Below are a few items being explored for the next generation of the ActionScript language and virtual machine:So it is no secret that I love ActionScript. I'm all about improvements and the improvements above are exciting (well except for the last bullet unless it is implemented passively as they promise). Here is the problem... we now have a language spec handled by a commercial organization, and a framework (Apache Flex) that is run by an open source group. What are the chances that these stay in line, especially given the fact that Adobe has stated ActionScript Next will not be 100% backwards compatible with AS3, which is what Flex is built on (anyone remember AS2 > AS3?). Here is my worry. As Apache starts considering their options and develops the Flex roadmap, how long until they say "We aren't going to compile to AS3 anymore, lets compile to Python or SmallTalk or ...". I'd be willing to bet you'll see a port in the near future, which means that innovation in Flex will need to take a backseat while the compiler is rewritten. I'd love to hear your thoughts!
- Stringent static typing as default, with optional dynamic typing: Most stretches of most programs are expected to benefit from static typing. However, ActionScript 3 tends to lapse into dynamic typing all too easily in places where absolutely stringent static typing would be preferable. This will be corrected. Dynamic typing will still be available when needed, but it will no longer be the default for ActionScript, and it will need to be enabled explicitly.
- Type inference: Type declarations will only be necessary in certain strategic places. Everywhere else the compiler will automatically infer suitable type declarations and treat the whole program as statically typed, even though the programmer does not have to state any types. Thus the convenience of untyped programming can be approximated quite well, while providing the performance advantages of typed programming.
- Hardware-oriented numeric types: For example, int, uint, float, float4, byte, short, long, etc. (the exact set of types is still under discussion). Currently in ActionScript 3 integer values can overflow into floating point values. This will be changed so that numeric operations will never change the underlying representation of the numeric. We foresee this addition greatly reducing implementation complexity and improving runtime performance.