In the Mayan calendar, 2012 is suppose to be a year of deep cleansing and rebirth for the world. In this spirit, I’ve been branching out into new fields and broadening my conceptual view of software development. The more I learn about programming fundamentals, the closer I get to a notion of which is considered “programming nirvana”. When I first started listening to people about this concept, I was very skeptical. All I was hearing was “blah blah no-variables blah higher-order-functions blah”. Like any programmer, my brain starts crashing as soon as I hear the statement that a language can be productive without variables. How is it possible to make anything meaningful without some internal state within methods and classes? Well, the answer to this is rather complex and outside the scope of this posting. The vehicle driving these concepts is called functional programming (FP), and it’s intrinsic highly abstract nature is usually very difficult for programmers to swallow. Going into the future though, I hope to post more about functional programming here. However, the real purpose of this article is to acknowledge some of the most astoundingly brilliant scientific minds that are changing my industry. I tip my hat to these gentlemen and scholars:

Haskell

Haskell B. Curry Father of Haskell foundations	Simon Peyton-Jones Implemented Haskell GHC compiler	Erik Meijer Major Supporter and an amazing teacher

FP Geniuses

Rich Hickey Creator of Clojure and FP pioneer	Joe Armstrong Erlang founder	Martin Odersky The brain behind Scala

Don Syme Inventor of F#	John McCarthy Lisp and FP pioneer	Conal Elliott Conceptualized Functional Reactive Programming

Honestly, I cannot state my respect for the above individuals enough! They have invested an enormous amount of personal time into an ideal that they are crazily passionate about. Each one of them want to make software development better from both the coder’s standpoint and platform perspective. As a teaser to these principles, below is a video of Simon Peyton-Jones and Erik Meijer talking about their view of coding nirvana:

With the advent of HTML5/WEBGL gaining popularity, Adobe knew it had to move fast. Within a matter of two years, they designed and implemented one of the largest platform updates I’ve seen in the industry- Flash Player 11. It sports direct GPU integration allowing for console quality games to be possible through the browser. If this wasn’t big enough news, they have been working with Unity and UDK to enable an export format from those [now] game tooling platforms. Below is a video of the Unreal Engine 3 running within the browser:

I’ll be spending the next couple weeks writing my own engine for Flash 11 and will update here when I have something working. The new API is not as easy compared to the standard display list or even Papervision for that matter, however it allows you almost total control over the GPU shader pipeline. While ActionScript 3 (AS3) can get the job done, I wonder how long before the haXe community starts implementing the new version. I’m super excited to experience such a radical new set of tools for game development!

Related external articles: 
http://www.epicgames.com/news/unreal-engine-3-supports-adobe-flash/
http://blogs.unity3d.com/2011/02/27/unity-flash-3d-on-the-web/ 

I’ve decided that I’ve neglected my blog long enough and decided it was time for an update. Here we go *long breath*…. Within just the past couple years, I’ve moved from Michigan to San Francisco and have been working primary in building mobile and Facebook social games that have given rise in the gaming industry. I did a number of projects at Crowdstar including Hello City and Mighty Pirates, and now I’m working on the largest project yet in my career at a newer startup called Metamoki (created by Dave Maestri, founder of Mafia Wars). The game development industry in Silicon Valley is rather interesting on a couple of facets. In some ways, it’s repeating the game design that originated back in the DOS and Commodore days. On the other hand, there are mechanics that are new and ‘alien’ in nature. Of course I am referring to the “social” aspect of Facebook games. In some FB games, the meaning of social is almost laughable as it doesn’t really exist. Even the best games in the industry still do not compare to the social aspect of co-op gaming that is rather prevent now in modern commercial games. Recently, big names in the traditional gaming industry are starting their own studios in hopes of breaking into the market. It will be very interesting to see what happens within the next two years.

Aside from the industry as a whole, I’ve been busy writing my own isometric engine, data structures, tooling, and learning other languages to support my day-to-day work. As soon as I think I’ve built the fastest possible system, I always find one more way to make the performance that much faster. I’ve also come to understand computer science more on a fundamental level beyond languages. It really helps to know what is happening behind the scenes when using language core libraries… just because a language provides a core function doesn’t mean you should use it! I have written a great deal of code that basically does what Flash already provides, but the level of performance can reach an average of 2-10x improvement (which helps significantly). I’ve also been following the methodologies of SOLID <http://en.wikipedia.org/wiki/Solid_(object-oriented_design)> and being mindful of these principles really improves the rate in which I can iterate game concepts and cuts down time to complete maintenance tasks.

I’ll finally wrap-up and show off the last two games I’ve developed at my previous work with Crowdstar:

Visit the games below:

http://apps.facebook.com/hello-city

http://apps.facebook.com/mighty-pirates

In this article, the author is a bit half-crazed… bantering that OOP is dead in light of entity/component systems. However, if you can get past that, it’s a good read on the benefits of composing game objects using only composition (instead of complex inheritance):
http://t-machine.org/index.php/2007/09/03/entity-systems-are-the-future-of-mmog-development-part-1/

An example approach to implement an entity system might be as follows:

What are your thoughts? Can a pure entity system be implemented in AS3? Are entity systems worth pursuing in AS3 game development?

Grab it over at: http://unity3d.com/

Changes:

Android Support:

• Support for Android OS is added in this version.
• Please note that this an early build and does not represent the final Unity Android quality.

Standard Assets:

• Standard packages split into more specialized and smaller packages.
• New Image Effects: Sun Shafts (aka God Rays); Bloom & Lens Flares; Vignetting & Chromatic Aberration; Curve based Color Correction; Depth of Field; Contrast Enhance (aka Unsharp Mask); Geometry Outline; Fisheye; Create Shading.
• Improved particle effects.
• New Skyboxes with alpha channels to be compatible with Image Effects.
• New Editor Scripts for useful shortcuts that are not built-in.
• Improved First Person Controller that uses Character Motor script.
• New CharacterMotor script for use with CharacterControllers.
  • Proper movement on slopes and steps without loosing grounding.
  • Support for standing on moving platforms with multiple movement transfer modes when jumping off.
  • Variable height jumping and other jump improvements.
  • Improved speed and acceleration control.
  • Customizable sliding and perpendicular jumping can prevent climbing up too steep surfaces.
  • Detached from input so it can be used for first person, third person, AI, etc.

New Editor Features:

• Black is the new 50% gray. Unity Pro got a new look – you can toggle it in the preferences.
• Procedural Tree Creator. Documentation.
• Integrated Lightmapping via Illuminate Labs’ Beast. Documentation.
  • Automatic generation of lightmap UVs (mesh import setting).
  • Terrains use the same solution and gain a whole new look when used with skylight.
  • You no longer use special “Lightmapped” shaders; all shaders that interact with lighting can handle lightmaps. Dynamic shadows from characters mix with lightmaps properly.
• Object Selector. We no long show a simple dropdown menu; instead a swanky new window opens up, with previews and everything.
• Scene View improvements (documentation):
  • Search field with interactive highlighting of objects.
  • Rectangle selection.
  • Vertex Snapping for precise object placement.
  • Live previews of material, prefab and texture drags into the scene view.
  • Improved camera handles, and a camera preview window.
  • Improved light handles.
  • More consistent scene navigation controls.
• New texture Import Settings dialog with simpler interface & per-platform import settings.
• New Build Settings window to better support multiple platforms.
• New and more organized platform-aware Player Settings Inspector.
• Curve Popup Window:
  • Any public script variable of type AnimationCurve is now exposed in the Inspector as a curve field.
  • Clicking a curve field opens a popup window with a curve editor, similar to the curve editor in the Animation Window.
  • Customizable curve fields can also be used in custom editor windows.
• Editor checks when new versions are available< and notifies the user.
• Texture compression is now multi-threaded for faster texture imports on multi-core computers.
• Asset Server Window:
  • History window shows multiline commit descriptions directly in the list instead of tooltips.
  • Selected history window items are revealed better.
  • Framing (F key) works for history window file list.
  • Remember user/password per host name.
  • Disable merge button in conflict resolution window for non-merge-able items.
• Improved error reporting for shaders. Shader Inspector also displays the list of errors & warnings for selected shader.
• Implemented snap to grid in Curve Popup Window and Animation View when holding down Control (Command on OS X). Control/Command no longer adds to selection, but Shift can still be used for that.
• Editor Console displays total number of errors & warnings in lower right corner.
• Improved inspector for movie audio.
• Windows: Double-clicking *.unitypackage will open and import it.
• Editor API has been expanded: documentation.
• Added option to search for object types instead of names in the project search field.
• Can now drag objects onto an array field in the inspector to add them to the array.
• Can now drag project folders onto the Project Wizard on Mac OS X to select them.
• Nicer display of thumbnails when dragging tabbed editor windows.
• Long operations show progress badge on the Unity Dock icon in Mac OS X and on the taskbar button in Windows 7.
• Added support for touchpad gestures in OS X editor, for maximizing windows (pinch gesture), and switching camera in scene view (swipe gesture).
• Overdraw visualization mode does not do alpha testing now. Alpha tested pixels still cost on the GPU, so better to visualize the real cost.
• Animation window can display animation clips from prefab, just click the prefab’s root game object.
• Protect Transform position, rotation, scale against invalid values.
• Build Pipeline: Typetrees are removed from serialized files (assets) when possible, this make resource files smaller and loading time faster.
• Double-clicking a Game Object in Hierarchy View will frame select it in Scene View.
• When going out of Play mode and the Game View is docked together with other tabs, go to last active tab instead of always focusing or creating a Scene View tab.
• Now the Hierarchy View has a toolbar too.
• API Compatibility setting in player settings lets you choose your mono profile. Use 2.0 if you’re having trouble with 3rd party assemblies (2.0 not available for web player).
• High resolution icon support for players (Windows: 256×256 and 128×128; iOS: 114×114).
• Search results in project and scene search are now sorted alphabetically.
• Inspector Lock got a real button instead of being hidden in a menu.
• Rotate Tool now includes ‘Look At Point’ option when Shift + Control/Command keys are held.
• Audition audio in SceneView. Scene view search now filters audio sources as well.
• Added Web Player build templates.
• It is now possible to update Asset Server project to specific revision through command line.

New Graphics Features:

• Static Occlusion Culling using Umbra sPVS.
• Geometry Batching: static and dynamic batching from Unity iPhone 1.7 comes to all platforms.
• Rendering paths: (choose in Player Settings or per-Camera; documentation)
  • Deferred Lighting. A deferred rendering scheme, where realtime lights are not horribly expensive anymore. Lighting cost is only dependent on the number of pixels it touches, so you can have lots of small lights for cheap.
  • Vertex Lit. This makes all shaders & lights use fixed function per-vertex lighting. In exchange, this is fast; primarily targeted at mobile platforms and low-end web.
  • Forward rendering path had lots of changes compared to Unity 2.x, see below.
• Surface Shaders – a much easier way to write shaders that interact with lighting. We don’t have the docs for it yet; you’ll have to trust us that it’s awesome!
• Speed! We have optimized the rendering code; it’s often 20-50% faster than 2.6 in the same scene setups.
• OpenGL ES 2.0 for iOS and Android. You can use shaders for objects, post-processing effects etc.
  • Regular Cg/HLSL shaders and Unity 3 Surface Shaders will be cross-compiled into GLSL behind the scenes. Resulting GLSL will be optimized as well, because mobile platforms are not very good at optimizing the shaders.
  • Of course, since mobile platforms are not very powerful, you should use OpenGL ES 1.1 if possible.
• Particle Rotation: Particle.rotation, Particle.angularVelocity and respective properties in ParticleEmitter.
• Soft Particles! When you use Deferred Lighting and have Soft Particles on in Quality Settings, particles will fade out close to intersections with the scene. All built-in Particle shaders (except VertexLit) support this.
• Shadowing improvements: use native shadow maps on Direct3D (faster, less memory, native filtering); much reduced self-shadowing artifacts; Soft shadows support for Point lights; much less “shadow halos” around objects for directional light soft shadows; optimized shadows for Forward rendering path (shares depth buffer with main rendering); optimized shaders for directional light shadows.
• Terrain: Added slider (under Terrain Settings) to control detail object density.
• Vertex shaders for Shader Model 3.0 on Direct3D9 and GLSL on OpenGL can read from textures.
• Skybox is rendered after opaque geometry. Improves performance if your application is fillrate bound.
• Separate Alpha Blending: use Blend ColorSrc ColorDest, AlphaSrc AlphaDest in ShaderLab.
• In-editor visualization on which objects would use which rendering paths (green/yellow/red for deferred/forward/vertexlit).
• #pragma glsl for compiling Cg/HLSL shaders into GLSL instead of ARB assembly programs on OpenGL.
• Compiling shaders to #pragma target 3.0 allows 512 texture indirections on OpenGL (up from 4).
• Development standalone players on Windows have Direct3D PIX events; useful if you use PIX, Intel GPA or other graphics performance tools.
• Fog just works on Direct3D with Shader Model 3.0 shaders, on OpenGL with GLSL and on OpenGL ES 2.0. Additionally, there’s no need to write #pragma fragmentoption ARB_fog_exp2 in your shaders anymore; just remove that line.
• CameraDepthTexture modes can be combined if you want to get both depth & depth+normals textures.
• It is possible to forcibly disable Anisotropic filtering on a texture, even when Quality Settings have anisotropic on all textures. Just set anisotropic slider on the texture to zero.
• Uniformly scaled objects will no longer be pre-scaled before rendering – instead uniform scale is now natively supported by the renderer.
• Cg/HLSL VPOS (pixel position) pixel shader input semantic is supported now.
• Terrain: Expose detail resolution per patch; previously was hardcoded to 8.
• Terrain: Improved performance of painting textures & detail objects.

Asset Pipeline Improvements:

• Upgraded to FBX SDK 2011.2.
• Import support for stepped and linear keys for position curves; improved compression and curve fitting for position curves.
• Settings for allowed animation compression error in mesh importer.
• Implemented support for importing 1 unit in 3dsmax as 1 unit in Unity (the default is 1 cm in 3dsmax as 1 unit in Unity).
• Implemented import of tangent space from FBX, .max, .mb and .ma files.
• Switched Cinema4D import process to work in background mode.
• Support for Cinema4D R11 on Mac OS X.
• Support for FBX2010 format when exporting from Cinema4D.

Audio Improvements:

• Filter components: Reverb, Echo, Distortion, Chorus, High- and Low-pass. Can be applied to each audio source or globally to the listener.
• Reverb Zones: Apply reverb to main audio output, when the listener is within zone(s) defined by a position and min/max radii.
• Live output and spectrum data access from each audio source or globally from the listener.
• Tracker/Mod file support.
• Sample-accurate synching. Sources played in the same frame are always started at the exact same point in time. Sources can be delayed and played in the future on an exact sample accurate boundary with .Play(int64 delay).
• Surround sound (7.1, 5.1, 4.0, ProLogic DTS) support.
• Attenuation curves for volume, spread, panning and lowpass filter factors.
• Doppler factor per audio source.
• AudioSource prioritization.
• iOS latency settings. Choose between Default, Best Performance, Good Latency and Best Latency.
• Asset memory is freed after loading audio data.

Physics Improvements:

• Upgraded PhysX to 2.8.3.
• Cloth and clothing simulation: use the new InteractiveCloth, SkinnedCloth and ClothRenderer components.
• Layer based ignore collisions: use the Physics inspector or Physics.IgnoreCollision().
• Continuous collision detection, to make sure that fast moving colliders will not pass through other colliders. SeeCollider.collisionDetectionMode.
• Added Physics.SphereCast() and Physics.CapsuleCast() to implement volume raycasts.
• Added Rigidbody.SweepTest() to check if a Rigidbody would collide with anything if moved into a certain direction.

New Scripting Features (documentation):

• Mono Develop for script editing and debugging! Documentation.
• Upgrade Mono and C# compiler to Mono 2.6.3. This brings C# 3.5, variable type inference, lambda expressions, LINQ and more.
• New UnityScript compiler: generics, interfaces, structs, type cast operator, anonymous functions/closures, lambda expressions, function types, type inferred array comprehensions and more.
• New Boo compiler.
• Mono class libraries derived from Silverlight profile for the web player.
• Socket security sandbox implementation. Just like Flash (think crossdomain.xml).
• WWW class security sandbox implementation. Just like Flash (think crossdomain.xml).
• Per-platform script defines. Use UNITY_EDITOR, UNITY_WEBPLAYER, UNITY_IPHONE etc. Documentation.
• Improved UnityScript compilation speed.
• New scripting API functions (documentation). Some highlights:
  • WWW.responseHeaders will contain the response headers received from the HTTP server.
  • Application.isWebPlayer.
  • SystemInfo.graphicsPixelFillrate to query GPU pixel fillrate. Returns fillrate for about a thousand GPUs out there.
  • GL.ClearWithSkybox.
  • Math functions: MoveTowards to Mathf, Vector2, Vector3, and Vector4; Quaternion.RotateTowards.
• Changed Mathf.Approximately to not only be useful for comparing very small numbers.
• Stacktraces have been prettified, useless information is better stripped from stack traces.

Other Improvements:

• Web Player: Java and ClickOnce based installer on Windows for true one-click installation process.
• IME input support (for languages like Japanese, which require multiple keypresses to enter a character) on Windows, and in the editor and standalone on the Mac.
• Support for OS font rendering (new “dynamic” font rendering mode), to save space in distribution and texture sizes. Textures are generated dynamically to contain the characters which are needed.
• Documentation: scripting examples in UnityScript; C# and Boo. Docs for all platforms merged and platform specific parts toggle-able.
• Web Player: UnityObject.js script makes Web Player embedding easier.
• iOS: Added cpu-waits-gpu metric in internal profiler; useful for tracking down GPU bound applications.
• iOS: Native resolution support for iPhone 4.
• iOS: Improved game build sizes.
• iOS: Unity Remote 2: It is possible to turn off image syncing between editor and device. Useful for input-critical games.
• OS X Web Player: Now supports NPDrawingModelInvalidatingCoreAnimation, as will be required by future versions of Chrome.
• Networking: RakNet upgraded to version 3.732
• Networking: Connection tester, Network.TestConnection(), now reports your NAT implementation type more accurately.
• Networking: Exposed Network.logLevel so you can change the amount of log output at runtime.
• Networking: Added network GUID, used for NAT punchthrough.
• Bug Reporter: Supports multiple file attachments; trims attached log files if they are too large.

Tags: unity3d

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.

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

For the past couple months, I have been trying to determine the best platform to become my primary language for game AI unit development, shaders, and working on theories of improving the Fridge-A* algorithm. However, choosing the right language has become an arduous task. Hardcore programmers will scream “C++ is the only way to go!” while the elites say “C is so much better than C++” and of course there is that one guy who comments “Why would you use anything other than Assembly language?” The problem lies in the fact that I am doing this work on my own and do not have XX hours to write an elaborate garbage collector, manage raw threads, or constantly keep track of hundreds of pointers. On the other hand, I must have enough speed and processing power to do the research and development I want.

Some suggest Java as a game platform as the language is respectable. However, graphics rendering speed and the Java gaming community is poor at best in my humble opinion. I did enjoy using BlitzMax back in the day, but the engine is simply not powerful enough to create something near commercial quality. Also, the popularity of the language is low, and I would have little professional use for learning more of the language. Flash AS3 is my primary profession; however, its performance leaves much to be desired at times. On the other side, Silverlight 3 is looking rather nifty, but the API still looks funky and doesn’t seem like the engine is really mature enough to do any major development in. Perhaps, if Silverlight 4 has near XNA speeds, better shaders and bitmap drawing, and the XAML to C# connection has less oddities in the API… it would be a contender for my list. Aside from the web platform, I could also go for a super high-end engine like Unreal Engine 3 or Source, but I couldn’t ever hope to produce something commercial with it because of the insanely expensive licensing (hundreds of thousands we are talking about!). Of course this is also Torque, but I have not been impressed with any of the games made on the platform, and there is a moderate cost to get started with it.

So I eventually evaluated my choices to XNA, haXe, and Unity3D:

Pros:

• Very fast (Fastest of the choices)
• Great shader support
• C# is a nice language with advanced OOP support
• Xbox and Windows deployment
• Free for indie users

Cons:

• Meant really for just the xbox… there is little support for Windows only deployment and DRM concerns. Also, no luck for Macs.
• Unlike the other two, XNA cannot steam which means a smaller audience because of the hassle of downloading
• Super new so the community is not that large in general

Pros:

• Compiles out to Flash which 98% of users have already installed
• Real-world benchmarks show 2x the speed of Flash 9 using code performance optimizations unique to haXe
• From working with haXe, I will use that same knowledge to build javascript and neko scripts in the future if I wanted
• I can use my existing knowledge of Flash to accelerate my development
• Totally free

Cons:

• No Flash IDE
• Also super new with a small community and little to speak of tutorials
• Still slower than unity3D and XNA
• Currently does not support importing Flash libraries which reduces the amount of existing libraries I can bring over versus just using Flash AS3.

Pros:

• Fastest of the web 3D engine… also nice looking
• Supports developed on Macs and now Windows
• Uses Python for scripting
• Supports large number of users for networking and shaders

Cons:

• No free version to try things out (only 30 day trial)
• Costly software (the indie license has a terrible roster of features making the Pro version the ideal choice)
• Little resources and support for making 2D games… everything is geared for 3D development. This can be a negative thing for me as I like to develop quick 2D testing scenarios for AI scripts. From what I can see, there are few tools for doing advanced bitmap drawing.

Final thoughts:

In truth, I have not made up my mind yet. The pros and cons of all the solutions seem to make every choice the same weight in how it appeals to me. I could forsake all the above options and just go with C++ with Allegro or SDL, but they too have their ups and downs. Allergro is really slow without full DirectX/OpenGL support and SDL seems to have an aged API with little in the future for it. Also, neither of those libraries natively support shaders. XNA would give me all the speed I would need for what I am trying to accomplish, but using a language that streams over the internet would give me a much wider audience.

Well, what do you say readers? Are there other languages I should be looking at? For my next post on the subject, I will try to make some benchmarks in all of the three languages to test their true strengths.

As a followup on my Wednesday lecture on design patterns, I wanted to post some informative resources for learning more about design patterns outside the next lecture on the topic. Also, I wanted to say thanks for everyone who showed up to hear me rant about code structure (not the most exciting topic in the world mind you)!

Design Pattern Definition
In software engineering, a design pattern is a general reusable solution to a commonly occurring problem in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved.
- read more at WikiPedia

MVC Definition (the most common principle of Design Patterns)

“Model–View–Controller (MVC) is an architectural pattern used in software engineering. Successful use of the pattern isolates business logic from user interface considerations, resulting in an application where it is easier to modify either the visual appearance of the application or the underlying business rules without affecting the other. In MVC, the model represents the information (the data) of the application; the view corresponds to elements of the user interface such as text, checkbox items, and so forth; and the controller manages the communication of data and the business rules used to manipulate the data to and from the model.”
- read more at WikiPedia

Books:

• Gang of Four’s original Design Patterns
• Advanced ActionScript 3 with Design Patterns (highly recommended)
• ActionScript 3.0 Design Patterns: Object Oriented Programming Techniques

AS3 Design Pattern Informational Websites:

• www.as3dp.com – ActionScript 3 Design Pattern Blog (Principles Category)
• ntt.cc posts on of porting GoF design patterns to AS3

Flash Design Pattern Frameworks:
(for now, it’s best to avoid these until you understand the fundamentals of MVC)

• FlashMVC
• PureMVC
• Cairngorm

Good Design Priniciples:

• ALWAYS type your variables (not really design principle but I too often see people doing this still)
• An object/MovieClip should contain the actions that it performs (as oppose to objects outside the class forcing it to perform actions)
• A class should never be able to “break” if the user sets a property or calls a function on it when they are not suppose to. Keep preventive logic in the class that’s doing the work.
• A good chosen design pattern for a problem will not take any longer to implement than not using it with spaghetti code.

Feel free to leave comments or email me about any further questions you have about Design Patterns or where to find additional materials on it. Have a great weekend everyone!