As the new decade begins, millions of people reflect on their situation and ponder how to proceed into the future. In many ways, 2009 was a game changer for the multimedia industry. We have seen Unity and the Unreal engine open to their doors to free indie developer licensing. This illustrates that corporations are realizing that even a great multimedia software infrastructure can be shoved aside for lesser alternatives that however have the strong community around its platform.
We have seen also a greater focus on one language compiling to multiple platforms. Adobe is pushing for Flash to compile natively to the iPhone and pushing the Flash player to all other mobile devices. Unity also aims for compiling to PC, Mac, and iPhone with little changes needed to the source. Microsoft continues to push XNA that has the boon of both PC and XBOX360 support. Of course, haXe continues to gain in popularity as it is a single language that translates into other platforms (Flash,  PHP, Neko, and C++ SDL).

Over at Bill Sander’s blog AS3 Design Patterns, he talks about his journey into design patterns and that his New Year resolution is “Improve nailing down relationships between classes in design patterns.” This year I have expanded my knowledge of design patterns in areas that I do not normally require in my everyday work, but just learning their existence has given me the enlightenment of not just how the design pattern works but ‘why’ it exists and what would happen to a system built without it.

My personal development New Year’s resolution is: “Learning to prototype quickly while keeping modular using loose coupling.” Being able to produce a skeleton of a system quickly helps to a keep the momentum of a project going and to isolate design flaws. However, rapid development can cause a system to be become stagnate and locked into a certain implementation. However, wise programming decisions like using the acquaintance relationship between classes and employing design patterns like strategy or template will make my prototypes open enough to evolve into the final product without infrastructure rewrites.

Update: While technically the new decade starts in 2011, I find the debate mute as people will refer to this era as the “2010’s“.

(more…)

This month has been a very interesting/exciting for programmers of all backgrounds and may be the cornerstone of an industry wide conceptual change.

Unity3D, a primarily web based 3D accelerated language, has announced their “indie” version of their engine as a free no-strings-attached package. This was a wise choice for the company as Google’s free O3D alternative has been gaining support and Adobe’s Flash is rumored to get 3D acceleration soon.

In just a week later, Epic Games released the Unreal Development Kit (UDK), a desktop commercial gaming engine, free of change for non-profit usage. UDK, however, does not compete with Unity3D. UDK has an incredible desktop graphics engine that Unity3D would not be able to compare to. However, Unity3D can run over the browser, has a super small file size for compiled games, and is much easier to learn than UDK. It is also worth mentioning that Unity3D is not a direct competitor to Flash either as its tools for 2D development are poor at best and Flash is installed on almost 97% of all computers (while Unity3D is around 6% I think). There has been little news on the haXe side of things in the past month which is a little disappointing considering the potential of the language.

Finally, Google unveiled Go programming language which is tailored towards system and server development and takes advantage of concepts like multi-threading and server clustering of tasks. While this is not terribly exciting for some, this language may reduce much of the massive complexity employed for enterprise systems and servers today.

One of the underlying themes we are seeing here today is that the user community around a platform is king. A developed language may be perfect and boast all kinds of features, but without users, it inevitably fails. As a developer, this is a fantastic change in the industry as it means cheaper or free entry into powerful languages and more help and support being offered to the community from the creators.

Overall, what we learned at Adobe Max this year was really nothing different than what we already knew months ago almost. Granted, finding out that Flash CS5 can export iPhone apps (perhaps they bundle the player and the flash file together?) was pretty neat- it was not really unexpected. Every cell phone will be getting Flash player soon (including the iPhone with the special export) which will really help increase the hold that Flash Player has on the market. However, there really wasn’t anything other than this announced that was worth getting excited over in my humble opinion. AIR 2.0 is coming out soon, but it’s roster of new features is rather lackluster for a new revision number- it should have been a patch number I believe.

On the flip side, the speakers and show setup were truly aweful. Speakers droned on as if they never bothered writing an outline for themselves, and I felt many ‘novelties’ of the show were tacky (like the canned video of the iPhone app doing the wheel-of-fortune company picker). Even the jokes the speakers used to lighten the content fell so flat that it was as if they were in lue of another joke. Don’t get me wrong, I am definately an Adobe fan boy- I just felt that they put almost no effort into their presentation. Anyone else feel the same way?

Adobe announced that this years MAX event will be one of the most significant ones in the history of the event. There are lots of rumors floating around on what might be unveiled during the event. We know from enough sources that Adobe plans to showcase Flash Player 10 running on almost all major mobile devices (excluding Apple since they hate the idea of application framework competition). In addition, there has been some rumors from Adobe twitter accounts that a new improved desktop Flash Player 10 version will be released (perhaps faster??). Lastly, here is a guess of my own, Nintendo Wii may also get FP10 because they have shown that they are working with Opera and Adobe to port over the player- as last month Flash Lite 3.1 was released in an update. So remember to set your calendars for October 4th to the 7th as it might a historic day for the Flash platform as a whole. It’s very exciting to imagine having full Flash Player 10 Flex applications running on my Android G1!

Labels are dangerous when used improperly regardless if they were created in good intentions. The present day world is filled with named factions that rage verbal or physical war on each other for nothing more than self affirming the dominance of their party. This is somehow deeply ingrained in our human nature… to provide loyalty to our clan and subvert others to establish dominance. If you’re not quite sure where I’m going with this, I am hinting at the fruitless debate between the American political parties.

Democrats and republicans have evolved to hated enemies of each other… no longer remembering that they were formed to work in harmony over national issues. In my opinion, there is one major entity to blame for this downfall and social dysfunction of the parties. That would be the American media. Regardless of the national media network you watch, you are being spoon-fed DAILY about the ‘evils’ of the other party that that media network is associated with. I can’t watch any of the big three news networks for more than an hour without being told why one party is better than the other. This is a shame that they choose to demonize and point fingers rather than focusing on the core of the issues at hand.

Should matters like health care regulation be shunned because it ’sounds’ like a certain party’s agenda? On another separate issue, I heard from one news network that a certain bill wasn’t worth looking into because the originator happened to be from the other party so the bill could be linked to promoting that party’s cause “somehow”. This is the kind of blind hatred that has caused our political degradation. So what do I propose? I would merge all political divisions… democrats, republicans, and the other 3^rd parties. Why can’t a person have a mixture of beliefs instead of being forced to conform to only the stances their party supports? The fact that someone who tends to be liberal is only going to feel at home in a democrat party versus someone who is more conservative in their views will have few options but go republican is a sad commentary on how the parties have outlived their usefulness.

The only person who benefits from this segregation is not the voter but the news networks. Controversy sells and the media has turned our political system into a kind of dark entertainment art form. Let’s spend less time worrying about if new policies fit the agenda of our party… and instead focus on what is “right” and benefits people the most. I normally don’t blog about political matters, but I find this dilemma in need of more attention than what it currently gets. Anyone else feel the same way?

The bell rings, and it’s another showdown between modern drawing APIs. Over the past couple weeks, I have weeded out many of my choices of libraries to now these four. What happened to some of the others? XNA, I determined, was way too XBOX360 centric with its multitasking, shaders, and DRM all tailored to the platform. Again, my primary aim was to develop on a Windows platform with possibly Mac compatibility. In addition, XNA requires end PC users to install the XNA framework package which only causes additional hassle for the user to install the game. Blade3D is also removed from the list as they recently went under last week, leaving many of their subscribers scratching their heads. Below is my up-to-date list for viable platforms to use for developing my prototypes and AI research:

• PROs
  • Faster than AS3 10% to 200% depending on use
  • Single language to also write the server platform
  • Flash Player 10 has a huge penetration rate (87% roughly)
• CONs
  • Still rather slow

• PROs
  • Faster than Flash by at least 400% in math and drawing APIs
  • Growing community (10,000+ users)
• CONs
  • Costly
  • Focused around primarily 3D development
  • Small penetration rate for its player (maybe 5% or less)

O3D by Google Labs

• PROs
  • Comparable to Unity3D
  • Bleeding edge technology
  • Google’s supported platform
• CONs
  • Buggy and very new
  • Lacks industrial strength demos
  • Extremely small player install base (< 1%)

Super Fast Media Library

• PROs
  • Super fast 2D library (several times faster than the above APIs)
  • Uses C++ and would allow higher customization and flexibility
• CONs
  • Desktop installation / is not loaded by the browser (user barrier)
  • Only meant for 2D

Over the weekend, we finally had a new release of haXe made available, bringing the current version up to 2.04. The new version mostly is for resolving a slew of obscure bugs; however it also introduces early C++ translation support which is definitely something to keep an eye on. Now we just have to wait till Flash Develop supports the C++ language additions. For the people who have not looked into this language, it worth your time to at least check out as it’s one of the few mature mutliplatform languages available today.

Haxe information and download

Update: Nicolas Cannasse has a simple example of a C++ compile on his blog.

Changes 2009-07-26: 2.04

• flash9 : fixed get_full_path error with -D fdb
• js : fixed Array.remove on IE
• flash8 : removed extra empty AS3 tag (causing some issue with F8 loadMovie)
• improved speed of Bytes unserializing (no need for BytesBuffer)
• flash9 : bugfix, Null<Typedef> was generating dynamic code
• flash9 : added error message in flash.Vector if used without flash 10
• flash9 : fixed some “never” property access issues
• all : added “never” property access support for all platforms
• js : small syntax fix with value-blocks
• js : fixed Type.enumEq with null values
• js/flash8 : use &0xFF in haxe.io.Bytes.set
• flash9 : fixed switch on Null<Int> verify error
• flash9 : fixes related to UInt type + error when using Int/UInt comparison
• as3 : improved Vector support, inline flash.Lib.as
• as3 : bugfix with skip_constructor
• as3 : added Enum.__constructs__ (allow Type.getEnumConstructs)
• as3 : make all constructor parameters optional (allow Type.createEmptyInstance)
• as3 : bugfix with property access inside setter (stack overflow)
• all : Enum is now Enum<T>
• all : added Type.createEnumIndex
• all : forbid same name for static+instance field (not supported on several platforms)
• all : renamed haxe.Http.request to “requestUrl”
• all : renamed neko.zip.Compress/Uncompress.run to “execute”
• spod : fix very rare issue with relations and transactions
• compiler : added TClosure – optimize closure creation and ease code generation
• cpp : added CPP platform
• all : added ‘using’ syntax
• neko : added ‘domains’ optional param to ThreadRemotingServer to answer policy-file-request
• php : fixed php.db.Mysql so that getResult is consistent with Neko behavior
• php : fixed __toString for anonymouse objects
• php : fixed bug in overridden dynamic functions
• php : fixed round to be consistent with other platforms
• php : fixed bug concatenating two dynamic variables
• php : php.Lib.rethrow now works as expected
• flash9 : fixed bug with SWC output and recursive types
• flash8 : fixed inversed arguments in __new__
• neko : added neko.net.Socket.setFastSend
• php: fixed String.charCodeAt
• php: minor optimization (removed foreach from std code)
• php: implemented haxe.Stack
• php: changed exception handler to use haXe call stack
• php: changed special vars to use the » prefix instead of __
• php: fixed use of reserved keywords for var names
• php: List iterator is now class based (faster)
• php: fixed behavior of class variables having assigned functions
• php: fixed php.db.Manager (was uncorrectly removing superclass fields)
• php: added support for native Iterator and IteratorAggregate interfaces
• all : added –display classes and –display keywords
• all : fixed issue with optional parameters in inline functions
• all : allow implementing interfaces with inline methods
• all : enable inlining for getter/setter/iterator/resolve/using

One of major benefits of working with computers and internet-based technologies are the massive communities behind them. Such communities offer feedback on ideas, technical help, and tutoring. In addition, standards begin to arise on their own because developers want to be able to integrate with other existing services to ease transition to and from their software. To allow other developers to embrace a new standard, an author of the standard usually releases it free-to-use, creates simple documentation, and provides support usually in the form of a open forum.

However, from my observations, the physical engineering world seems to completely lack such concepts as a whole. Almost every device you can buy has parts that are completely non-interchangeable with one-another. About the only thing that is standard is the screw type that the product gets put together with. Why can’t products be made with interchangeable plug-n-play modules? If the radio brakes in one stereo, why can’t I just pull out the ‘radio receiver module’ and replace it with another?

You can sorta do that by un-soldering several circuit board parts, look at the model numbers (if they have one), and hope that some foreign warehouse has them for sale for consumers. It makes it even more difficult because there are hundreds of thousands variations on parts and warehouses can’t inventory that many effectively… as opposed to carrying components that encapsulate functionality that devices share in common. This is just one example of engineering evolving.

What would Engineering 2.0 look like? Perhaps, if someone had an idea to build their own radio, they could:

• Create a blueprint of the radio case using a web application
• Upload the blueprint to a company that can cost-effectively make custom cases
• Order a radio and power ‘module’
• Order device buttons that are easily mountable to custom cases
• Radio module has a ‘USB’-esk port for the button interface to plug into

In a weekend, someone who knows little about the engineering world could literally build their own home device that fits their exact needs. Maybe this is all far-fetched, but I am convinced that traditional everyday engineering as we know it will change based on the need for a new level of global standardization and maintenance tasks that are client friendly.

Newsweek offers an interesting article that touches on the issue as well:
http://www.newsweek.com/id/55776

Here are just a couple more enhancements to FlashMVC I was able to add over the weekend. These will not only automate a few things, but it makes room for additional addons in the future. There are two new features that have been added to SuperAction:

bindVars(… REST):void
This method looks at the SuperEvent fired from a completed action class, and copies properties to the SuperModel from the SuperEvent.

lastSuperEvent : SuperEvent
[read-only] Returns the last SuperEvent fired after completing an action. (This is useful for reading a property from a SuperEvent after the event has fired and you didn’t have a listner for it yet in your view)

Check out the documentation for more info:
http://www.flashmvc.com/documentation/

FlashMVC overview: www.FlashMVC.com