In all seriousness, I think the new 3D stuff is awesome, it’s going to be really amazing. If we can somehow utilise it for user interfaces then we’re off to a winner! That’s one of the major issues that I had and still have is that when it comes to rendering it just doesn’t cut the mustard. Hopefully this will change and it will give one less thing for me to bitch about. It’s sort of a love hate relation ship I have with the ecosystem that is Flash. One things for certain, I’m really thinking of leaving it and moving on to Java/Scala and even dare I say it Javascript (probably using haXe if anything)! Why I hear you cry, here be a list:

• ECMA 4 – I’m guessing Adobe are still in the spoils of the ECMA fallout, where Adobe aren’t 100% sure what to do. If that’s not the case, this is what is perceived from the dwindling hordes of developers. Is Adobe following ECMA Harmony or are they doing their own thing? The latest FP11 doesn’t look like it’s done any sort of move in any direction. The great rival that has appeared in the last couple of years (Javascript) seems to moving lightening fast, ok maybe they’re not all singing from the same hymn sheet, but at least they’re moving when it’s concerning the language (probably excluding MS here somewhat). Things that look appealing to me from a Javascript point of view or even original ECMA 4 document, which I believe should be in FP11. Even if there is no official ECMA 4 now, at least have the balls to follow it through!
  
  • Union types and the set of predefined union types
  • Type definitions
  • Subtypes
  • “like”
  • yield
  • let
  • Iterators
  • Map
• Enums – Why can ActionScript 3 not get enums, they’re basic simplicity that help reduce boiler plate.
• Abstract Classes – With all the functionality that ActionScript 3 is getting, it becomes a necessity to have more help from a language and I consider Abstract Classes part of that. Why can’t the compiler tell me I should override a class if I mark something as Abstract, hell it moans about something when I don’t override something which I should, it’s not like a massive leap?
• Private constructors – Why did we remove these again?
• Generics – Generics in ActionScript 3 is just decent, not good and not excellent, it’s just decent. It’s like they went, “we want to implement generics, but we don’t have the time. I know, lets implement it in a half arsed way!”
• Const – How about const keyword, is it implemented? Who knows? It’s not implemented in the Flash IDE, but is implemented the Flex SDK compiler, but you can create a swc file from the Flex SDK and use it in the Flash IDE? How have they managed to do this without changing the player or the Flash IDE? Well it turns out they only do a compile time (better than not I suppose!) and once the check is done, they use the var AVM2 Bytecode instead.
• Flex compiler – Why oh why is the Flex compiler aka mxmlc and compc two separate entities and why oh why do they not implement some really basic rules of optimisations.
  
  • Inlining
  • Constant propagation
  • Tail recursive optimistations

I really do hope this stuff is coming, because I think it really is make or break time. People that didn’t want to invest that much into Actionscript 3 are now moving or have moved on to other languages (Javascript). The people that are still riding it out for better language expressiveness to get down in code what’s on the tip of their fingers are thinking about it or have already done so!

Edit:
I was speaking with various colleagues about this thread and we all tended to agree, that most of this is syntax sugar. We use this language day in day out, I’ve invested a lot of time into this language and it would be helpful if this language could help us out as well.

You may as an observer say well this looks like language A or like B, I would love to work in A or B, but I’m on a project that requires AS3 and we don’t have to option to move to A or B. In the future though I think A or B is on the horizon, especially in these fast moving times.

Now I’ve come back, not much has changed! The speed of Javascript has improved tremendously, which annoys me slightly because I wish the AVM would improve with such radical pace.

With that in mind, with my time away from Javascript I have grown fond of more strongly typed languages i.e. AS3, Java and haXe. So I’ve been keeping my ears open about possible solutions that target Javascript where you don’t actually have to write Javascript (there are a lot!)[1].

So it weird that for a general purpose language, that features in every browser in some way or form there are a lot of ways to not actually write Javascript. This does tell me that a lot of people don’t actually like writing Javascript. So why are there a lot of people pinning their hopes on HTML5, when developers aren’t really interesting in writing Javascript? Now wouldn’t be impressive if a browser provider actually had the guts to introduce a way to implement pure bytecode. That way we could remove “my language is better than your language” scenario. My worry in the future is that the Javascript landscape is going to be fragmented, not by frameworks (which is bad enough), but by what you language you write Javascript in. Which begs the question, is Javascript becoming browser bytecode – I hope not?

[1]

• haXe
• Cappuccino
• Jangaroo
• GWT
• Rhino
• Emscripten
• Coffee-script

One thing that I’ve been toying with a lot is moving the whole code base to haXe. I’ve been a fan of haXe for a long time, I’ve used it for a lot of projects as helpers. I’ve never used it for the main development work though. If I was the main developer and I could control this 100% of the time, without question I would ship the lot to it.

The reason I want to do this is because Adobe are slow are optimising the bytecode it outputs. To give you a basic example, the Logic Operators (&& and ||) are completely useless when compiled with MXMLC. I read Jackson Dunstan’s blog a lot and what he found today shocks me! How can an enterprise compiler, which is what this is fail on some many levels? The compiler is the most stupidest compiler I’ve ever seen, it does nothing, nothing at all! In fact it’s so dumb, we have to get one of the smartest guy’s to implement a post compiler to patch the compiler. Joa shouldn’t have to do the basic parts, in fact he should be doing things that are edge cases, instead he’s doing Adobe’s job.

So with this in mind, I’m constantly toying with moving across to haXe as my main dev library, so what’s stopping me.

1. Once everything is compiled it becomes public, no matter how you write it.
2. There is no internal or protected, I really like these in AS3.
3. There is no const keyword. I like the const keyword as it makes me aware of what is mutable and what isn’t.
4. Last but not least, you can’t load swf’s in to the same applicationDomain because of the Boot class. (see bug here)

I hope the bug get’s fixed soon as I think I could easily start using it a help of a lot sooner.

The IDE support is a lot more useful as well, with FlashDevelop and FDT also giving a big surge, just a pity flash compiler developers aren’t listening.

One thing has struck me of late and that is; we do have really fast operational codes in the language, but other than haXe and Adobe Alchemy not much is taking advantage of it. You can of course try and use TDSI from Joa Ebert, but why should we have to optimise something after we’ve written it? This should be either standard from the language or the compiler.

So what is this really about?
This is about wanting to code without thinking about optimising the basics, you don’t hear of C/C++/C#/Java developers talking about trying to squeeze every ounce of power from the language every time they code something. I’m not saying you shouldn’t optimise, what I am saying is that as a platform it always seems like we’re starting with a handicap.
I want the fasting language for the platform and have all the features for the language. I really like method overloading from Java. I know the AVM2 doesn’t support it by default, but that doesn’t stop you from implementing in some way. A perfect example of this is type parameters (generics) of the Vector class, which I really like from Java and HaXe, but why is it not default on all objects. The compiler checks what your implementing and the aligns it to correct compound types.

Now why can’t a language do this for method overloading, by simply changing the method signature to something else at compile time.

1
2
3
4
5
6
7
8

function method(name:String) : void
{
}
function method(name:String, age:int):void
{
}
method('fred');
method('jim', 24);

This would be translated to the following:

1
2
3
4
5
6
7
8

function method_StringVoid(name:String) : void
{
}
function method_StringIntVoid(name:String, age:int):void
{
}
method_StringVoid('fred');
method_StringIntVoid('jim', 24);

The reason for the curious method signature is to enable something to call the method if it’s not directly know i.e. external swf file etc.

Also why is the fastest int, not used automatically? To use the fastest int, you have to delve into opcodes, which seems extraordinary as you’re actually saying to your developers “we do have this really fast player, but you’re not allowed to use it”. It would be great if a language just used the fastest int and not require the developer to jump into another language (C/C++/haXe).