So, even though I’m not a Linux ambassador, I’m disapointed over the tratement Adobe gave to the Linux users. In particular, I’m referring to the decision of discontinuing the support for the Adobe Runtime (AIR) on that platform. The latest version is 2.6, and during a time when big changes are being introduced (stage3d, native code, etc) the gap is getting wider day after day.

As a professional developer, even though I don’t work in Linux, the products I develop regularly end up on Linux platform across the globe. Removing Linux as one of the target platforms reduces number of potential customers, and in the end hurting income.

My support for AIR on Linux is not because I want to take sides in an ideological war, it’s a pragmatic choice. I need AIR on Linux for keep my business running.

I think there is a reasonable share of the market behind Linux still waiting to be explored. This is my way of publicly requesting Adobe reconsider their decision, and to reinstate the AIR Runtime on Linux.

This letter is written under no copyright restrictions, and available in the Public Domain. If there are developers out there that agree with me, rather than only linking to it, show your support by copying it to your own website or blog, or write your own version of the letter.

1 - Lovebirds feat. Stee Downes – Want You In My Soul – Original Mix – Winding Road Records
2 – Fritz Kalkbrenner  - Layer Cake – Original Mix – Soul
3 – Maceo Plex – Under The Sheets – Original Mix – No.19 Music
4 – Nicone, Sascha Breamer – Dreamer – Edu Imbernon Remix - Stil Vor Talent
5 – Romano Alfieri & Luca Bear – Leave the Valley – Original Mix – Break New Soil
6 – David August – Hamburg Is For Lovers – Original Mix – Dynamic
7 – Siwell – Watching Above the Horizon – Original Mix – Sphera Records

When plagiarizing an existing game, there are a few tasks which are already done for you; you don’t need to rethink the wheel, it’s almost finished.

In our case, I know there will be “Goodies” and “Baddies”. There will be resources produced by the Goodies (in the case of PvZ, the sun produced by sunflowers) that are used to place new allies (plants). The playing field is laid out in a grid, which the Baddies march into.
Although the mechanics are quite simple, humans are programmed complicate things (overengineerng is the most common example of this plague).

The time I didn’t spend on game design was thrown away on finding a purist way to make the game multiplatform. Experience has taught me that multiplatform by technology is not a big deal, you are always constrained by the technology promoters. Personally, I was (and still am still) a Flash Architect.
Adobe has claimed many times that Flash is a multiplatform technology. Unfortunately, this definition is not accurate, and it’s becoming less accurate day by day. Flash is a famous example of how hard it really is to develop technology that is truly multiplatform.
When I say ‘Flash’, I’m usually referring to the Flash platform in general, comprised of the language (ActionScript 3), the virtual machine (Flash Player, AIR), and the tools provided. The last option, tools (which includes ide, authoring, etc.), should also be considered when evaluating a technology as multiplatform; not only the consumer, but also the developers need to be taken into account.
The Flash decline (if we can call it that) as a multiplatform solution started with the buzzing war if HTML5 paladins lead by Steve Jobs as Apple decided not to include Flash Player on their iOS devices. I’m not going to discuss this matter further, as many battles have already been fought upon this topic, of which I’m sure you are already aware.

Over time, Adobe started cutting platform resources, and a few AIR branches (first AIR on Linux, and later Flash on mobile devices), while other branches were potentiated, such as the iOS Packager (an LLVM translator for targeting iOS devices)
My point is, embracing a technology has it’s risks. Putting all your faith in a technology controlled and developed by others (especially by corporations that put profitability above all else) is foolish. You must face this fact: a technology will rarely (if ever) answer to all your needs. If you think all your problems can be solved by one single technology, there is something wrong.
I’d like to quote my university teacher of Concurrent and Distributed Systems. He believes that languages and technology in general are just elaborate ways to represent simple things that modern developers don’t want to deal with. Rephrasing that, it all ends up as a series of bits, what differs is how you choose to generate them. Keeping this final purpose of all technology in mind can help avoid extremism and unhealthy attachments and to specific technologies, and keep you from getting overwhelmed when those technologies change.
What I came up with was a typical architectural approach (although, I must admit that my decision was biased).
One of my virtual mentors is Cliff Hall, the creator of the PureMVC framewok (promo time, his book  was released a couple of weeks ago, and I highly recommend it). PureMVC has been ported to over 15 different languages,
and it can virtual target in one of his incarnation any device out there.
PureMVC offers a middleware architectural layer: as long as you write code with the framework’s philosophy in mind, you are not bounded to the underlying technology. This allows for framework abstraction and a language agnostic approach.
The MVC pattern allows you to isolate dependencies of the language’s API to only the visual parts (mediators handling the View) and few lines in the Model proxies (the ones that deal with the OS or i/o operations).
Back to the game, using such a framework over-complicates things at the bootstrap phase, but as long as you know the way, you get faster day by day, and the feeling of being safely bounded within the framework encourages you to reduce iteration circles.
True game developers will tell you not to complicate things by introducing architectural frameworks, but as long as you want to target a wider marketplace, an abstraction layer must be introduced to speed things up; PureMVC was my choice.
Back on the game side, I strongly prefer using a runtime scripting language. It happens quite often that large projects lead to high compilation times. Last Monday morning, I decided to track how much time I spent waiting for the compiler. The result? About 30 minutes for one standard work day.
I was looking for an in-game tool to quickly arrange things without recompiling every time.
I’m a fan of Unity3d, and one of the best first impressions that a flash developer notices in the IDE is the play button. You just push it, and your game starts running.
One more time i spend hours in deciding how to reach this result. I was tempted to write my own virtual machine within the technology I pick, or just go for an existing one (note: up to now, I have still not revealed which one, or more, technologies I have chosen).
My final choice was LUA. I don’t want to spend too much time talking about LUA itself, let me just say that I was rude towards LUA in the beginning. I’m not a fun of the language itself, but I’m immensely fascinated by the community around it that keeps pushing it day by day to the Olympus of scripting languages!
But this was another digression. The post title was about fast delivering, and up until now I have been showing off how I introduce delays to the project.
So the remaining three days of the week I decided to speed things up and start working on the game.
As a first action, I forced myself to write out the goals of the week. Always write explicit aims, even if it is a solo project. This is a inner exercise to force yourself to keep the project rolling along. Always set deadlines on short-term goals. There’s no need to decide now that I want this game out 12/12/2012, but there’s a great reason to set the spritesheet stress test for next Friday at 12:00.

My goals were:

• test the basic rendering engine on an iOS/Android/Playbook OS/Windows Phone 7, and stress-test the rendering engine with 100 plants + 100 zombies + 400 bullets
• implement a collision detection system

And the results:

I tested it on an iPad2, and an iPhone 3g. I think I got the chance to work with the top and the lower tier devices running iOS at the moment. It works on both, but unfortunately, the lack of support for Open GS 2.0 on the iPhone 3g slowed things down a lot, and I was not able to reach higher frame-rate during the stress test (stack @10fps).

Now i have two choices, cut out the 3g support and go for the 3gs as a baseline, or just reduce (tweak) the loads in case the games run on a 3g device.

On the android side it was madness. Performance was higher than expected testing on phones with 2.2,3.0 and 4.0. But the fragmentation of colorspace and resolutions scared me a lot. I didn’t think about it at first, but responsive layout design wasn’t enough in such a case. Here is a deeper analysis of my frustration
On the Playbook side I was satisfied enough; great performance even if a weird aspect ratio.
No chance to put my hands on a WP7 device, nor to the Sony S1 & S2.
On the implementation side, the collision system was pretty nice to introduce. I first got into rough box collision with a O(n*m) algorithm complexity (where n are number of shots to test each ticket time, and m the number of zombies). It works but with unacceptable performance.
I later went for a radial collision detection. Faster, since the case were there is no collision is higher than the case were there is. But still not efficient enough.
I decided to exploit the grid structure of the game and implement an R-tree collision system, first using both of the two dimensions, and later using only one dimension (the X axis, since shots fired on one row can hit only zombies in the same row).
The result was quite fast, so I decided to stop my refining process for the moment (even though I’m sure that with a linked list data structure I can increase the performance further)
In the following screenhot, the plants (mushrooms) come from Tado’s Funghi collection, while the zombies (scarecrows) are a CreativeCommons spritesheet, both are used here as placeholders.

In the upcoming days I want to research the marketplace opportunity. I’m particularly interested in the Rim one since it seams Plants vs Zombies was not ported there. I’m also looking forward to digging into these steam statistics >>in order to decide early on how to distribute time resource over single desktop version development.<<

It all starts with my girlfriend – which is an important note to make, in case someone some day decides to take legal action against me, I want to record to show it was all her fault!

It happens quite often that in order to stop her bothering me while working, I throw the iPad on the table and let her enjoy some “random game” time.

Unfortunately, there is one random game which does not always get picked randomly: Plants vs Zombies. She easily gets addicted to it, despite having finished it several times. Now she asks me to provide her with new games, but seems that the hole left by PvZ is cannot be filled; not by red flying birds, nor by chandeliers that fall on a malformed frog (isn’t it?).

In 4 words: I am f**ed up!

Chaining myself in front of the Popcom/EA head quarters begging for a sequel led to nothing but a waste of time. It’s at this point I get the idea: Do it yourself.

I’ll also spice up the project by throwing in some constraints and presenting it as a social psychology experiment. Let’s call this Socially Driven Game Development (dev note – TDD is old fashioned, right?!)

There are two lessons to be drawn from Notch’s Minecraft hype; First, you must keep feeding and getting feedback from the community around your game, and in case you don’t have one, you must do your best to get people involved and feel they are part of the project. The second lesson is that mining seems to be the only thing people want to do from dawn ’till dusk, but for this project, that lesson can be ignored.

So I decided to clone Plans vs Zombies, and share the progress in a daily, on-line diary, letting people inspire design decisions; from gameplay to graphics, from music to additional content.

In addition I’ll add one or more constraints, such as:
- Limit the time I work on project – No more than two hours per day or ten hours per week (this forces me consider this as a side project)
- Recap the day’s work every week – sharing any progress and development, as well taking in feedback regularly
- End every post with a question – sometimes a Yes/No question, sometimes a poll, and sometimes a so-called “open-question”
In the spirit of the last rule, I give you the project’s first question:
What is lacking from Plants vs Zombies?

Scroll straight down to the comments section and write your ideas. After that, scroll back up here and keep reading my thoughts on the matter (mostly superficial views)
- Not homogeneous across platforms (I found out that iPad version has features that iPhone doesn’t, and vice versa, like Zen Garden)
- Not available on a few platforms – Not a big issue, but I bet the Blackberry and Nokia markets are potentially fertile markets that aren’t explored enough.
- Not a real growing path – Except gaining all the plant types, there’s really no other motivator to keep playing. Suns are not permanent through matches, money is not useful after you bought all the items from the shops.
- Longevity is miserable in less than 5 hours.
- It lacks an “entrepreneurial view” – Come on, I don’t want to be stuck in my backyard all my life. I want to conquer the world with my plant army!

Your turn now, see ya tomorrow

I have always considered the summer brake as a good period for self-evaluations more than year-end when too many external factors blind your analytic skill.
Doing this i found very useful writing down the list of what i consider motivating for a developer trying to extract some boolean questions for auto test your motivation level.

As a project manager, or architect you don’t have the privileges to handle all the following factors that usually refer to managers and ceo, but it’s always interesting try to put on others’ shoes to better understand feeling and reasons.

Get rich or die trying

This is one of the most controversial point: money. According to the

Maslow’s Hierarchy of needs this is really a basic factor of everyone happiness. Point is that developers don’t want to be reach, they just want to be rewarded proportional with their efforts. Money is a good trading indicator. It is also the only attribute that let you objective compare your job with others’. Don’t think to your developers as people that just want to be rich exploiting your company, but don’t do the error to think them as volunteers. You must be sure to remove money as a developer problem. So CEO, consider the idea to compensate well your employers. This also let you decide to do benefits according to the singular developer effort inside the team.  Also don’t try to standardize the salary with role categories against each one developer capabilities. Developers are different, with different backgrounds and different motivation, mimic false fair because you are just not able to say “A is better than B so A deserve more money” marks the fact you are not the right person for the CEO role (decision maker first). Also bonuses must always be motivated in front of the entire team, for at least two reasons:

1. You can be wrong, discussing with team on reason why A gain a +10% this month can lead to better knowing if A really deserve the bonus due to the reason you have in mind or not. (Again this request a NOT-FALSE-FAIR team, that is, in this blog post, assumed as pre requirement)
2. In case you are right, this let other see the Cause-Effects of bonus strategy. Sound like dog training, i know, but it works in the same way. The dog catch the ball and bring it back, the dog got the biscuit

Otherwise you know what will happen, even the most motivated developer in the world just take apart quitting your company and move to a greener garden. It’s simply, it’s not about work itself, or something against you, it’s just the inner happiness mechanism described by Maslow that subconsciously demotivate your employer

Stillness or excessive dynamism

A not so easy balance to reach inside your team is finding the middle between stillness and dynamism.

Stillness is the feeling that time is passing and the decision are not taken, the event just flow away, and you are somehow try to chasing that without success. Developers in general are not meant to takes decisions, project managers do, but they easily feels if the project manager is doing his work properly or not. A developers should not takes care of what happens with the customers except for technical reason, so in the case you are a project manager, be transparent and try to handle your dev team with a constant flow. Variations from outside are always dangerous and lead to uncontrolled changes.

On the other hands we have the excessive dynamism that is the opposite way to react to the main project management problems (lacks of requirements, unrealistic deadlines, etc). The behavior of an over excited project manager usually starts with an excessive number of meeting, a progressive relaxation of the team norms and a degenerative flood of useless questions like “What is needed? How long does it take? How big is this problem?”. You got where’s the problem: you can shift responsibility over the developer. Developer can take your work, once, twice, but really, no more than three times in an year. If you are unable to manage a project ask your developer to do for you is not the solution, especially if the additional effort required is not payback (see previous paragraph)

A poor work environment

This is not a physical matter, e.g. place where it’s too loud, there’s no privacy, you get lots of interruptions etc.. This is also about your digital environment: slow builds, slow unit tests, slow desktops etc. They suck productivity and reduce enthusiasm. A bad environment can destroy motivation or at the very least be a distraction.

If there’s something that stop your developer flow for more than 10 minutes you must find out where’s the problem and fix it or ask someone to fix. Tools are made for speedup process not for slow it down, so if you are using SVN please be sure that all know how to use it, if you are super proud of your new compilers suite be sure that all developers know the new tools and how to use it, etc etc etc.

The best way to do that is to keep an internal document where all this information is stored (yeah, consider doing this even if you are a solo) and start delegate to someone the role of administrator. Delegate means explicit the new role request, don’t just ask him to “fix this please” or “look into this issue, there’s something that doesn’t work”. Be clear and explain always the issue and why it must be fix. If you are a developer you must point it out sooner all the situations that stop your workflow. A good work environment is a necessary requirement. Developer are by nature “programmed” for not wasting time so why force them doing…

Passive and Active Learn

Unless your work can be done by a robot, i’m sure you are learning something from your daily work. There are two way in doing this, the passive way, while you iterate over the project problems solving, and the active way that include the awareness of the learning process.

Active learning must be sponsored somehow from the company you work for. As Team Manager you must include in the weekly timing few times for active learning. Developers love to learn – new languages, new tools, new frameworks even if not required by upcoming project. Soon or later you’ll need this knowledge. Don’t be so fool, developers can just survive with passive learning, it’s like put a newbie on a plane and ask him to pilot it. It success only in films, in real time you crash at the ground. It’s the same with developers. You can put them on a project if they have not the knowledge to effort it, there a small effort you can ask to them on the learning curve, and in any case someone must know where’s the parachute before the project crashes.

Make it fan

Developers in general love to solve problems in a controlled environment – whether it’s how to integrate a new features, which algorithm is better for a given situation, etc ..
Know your developers and align the challenge to their attitudes, team will learn from others’ skills. Set a monthly challenge and reward the winner. This will force developers take part while they are working on main project, enhancing their multitasking skill, it is also a good chance to learn from different solutions. Review results leads to a wider consciousness of team members.

Let them be proud

Have you ever listen how your developer describe their work to third person (not skilled in IT)? Are they going to say something like “I’m working on the new revolutionary application for …. ” or are they say something like ” Uhh, to boring to explain … ”

Developer must be proud of what they are working on, only in this way they’ll fell the work they are doing as a personal grow, not only as the boss bank account work.

Choose your project wisely, mix developers attitude with needs, try to underline the thing to be proud within any project ,and ask developers to find it out and abstract from the single project. Shift and focus the attention to the important thing

As a conclusion i’d like to add an additional point: listen to your developers.

“When a developer speaks, someone should listen. When several developers are saying the same thing, someone should listen and act . . .quickly”

Test your motivation

Ok now you know my personal view on the topic, following now some boolean question (this give a turin taste to the test). Note down the number of positive answer, and check your motivation range.

A) Financial (5pt)

A1. Is your monthly salary equal to the global salary?

A2. Are your salary including benefits in percentage of company year revenues?

A3. Are lunch and/or dinner included in your contract?

A4. Is there any perks including local activities (Gym,Swimming Pool,Parties)?

A5. Are additional hard time tasks payed back?

B) Project Management (5pt)

B1. Did you rarely face lack of requirements ?

B2. Did you rarely face unrealistic deadlines?

B3. Did you rarely face shifts in deadlines ?

B4. You never take decision that someone else should takes.

B5. Nobody takes decision you must takes.

C) Work Enviroment (5pt)

C1. Company provides you hardware and software needed for daily development tasks.

C2. Do you have your private working space ?

C3. You are not interrupted during your dev phases.

C4. Surrounding environment is quiet enough for your needs.

C5. There’s enough coffee for developers need (believe me, this point value is really high).

D) Personal Motivation (5pt)

D1. I take part of something i’m pride of.

D2. I’m part of a team, and my ideas are taken seriously

D3. I learn in the last year at least two fundamental skills i’ll include in my resume

D4. I was encourage participating in community developer events (user groups, code camps), blogs (share links across the team), books (monthly bookshelf anyone?) and conferences.

D5. Chance to develop personal project within working hours.

Finally Adobe Air 3.0 was committed to the labs.
There are some really cool features in this new milestone release. The one i’d like to talk today is Captive.
How many times did you face issue on installing and executing air apps in non administrator system? Isn’t this one of the main reason why Zinc found his way on our heart?
Well, adobe seems to grant the developers wishes let us wrapping together Air file and the runtime. The final result is a deployed compiled executable file (.exe for Windows or .dmg for OSX).
No room for linux though!

Following a detailed list of the captivity feature/characteristics:

• you can compile only for the OS family you are running the adt compiler, so if you want to create both .exe and .dmg version of your software you need to run both the operative system, and do the compile operation twice
• process is very close to the Native Process compilation we saw in 2.6, so there might be chance to see this feature included in Flash professional in short time
• captive compiled executable apps can target native processes part of the api
• captive compiled executable apps can run without administrator privileges (somehow not far from how zinc does)
• captive compiled apps can be execute from externals support, but not from remote resources like network storage (at least at this stage, i’m sure there will be changes on this side)
• captive doesn’t improve performance of your app. This comes from an oddish simplifications Adobe did while presenting captive. Captive doesn’t works as the iPhone packager did. There’s no cross compilation or byte code translation into native code. It just wrap all the AIR frameworks libraries with your (still exists) swf file. Open, at your risk, the compiled file to dig into.
• captive feature also works for android application. This side isn’t under my radar of interest. I’m just curious if this let you “deploy” newer framework version on older device. I’m imaging wrapping with Captive the 3.0 framework and deploy the resulting APK to the oldest android devices .. kaboom!

How it works? Gimme the code!

At this point there’s nothing too much esoteric to do.. just run the adt command line tool. In order to do that you must:

1. Download the AIR SDK and extract as explained here
2. Target the right swf version. 13 is the SWF version that corresponds to AIR 3, so you need to tell the runtime what version of the APIs you want to use. While compiling with mxmlc just add the compiler argument “swf-version=13″ or on your favorite ide just dig for something like  ”Project Properties,” then “Flex Compiler.” In the “Additional compiler arguments” box, add “-swf-version=13“.
3. (Optional) open terminal and navigate to your sdk folder. Navigate now to bin/  change privileges of the ADT file using command  
   chmod 775 adt
4. now from the same folder you can run adt using the command, please note the bundle string that identify the desktop target (against the Android option apk-captive-runtime ). The other ADT options are the common parameters.
   

   adt -package SIGNING_OPTIONS -target bundle SIGNING_OPTIONS <output-package> ( <app-desc> FILE-OPTIONS | <input-package> )

The base concept, as “Bitwise” may suggest, is to use the bit representation of the number.
A number can be represented in an infinite number of ways. The representation we are used to is called decimal, or base 10.
The binary, or base 2, number system is the one that computers use to represent numbers in memory. Since we’re dealing with base 2, there are only two digits available, namely 0 and 1. Each digit is multiplied by successive powers of two to obtain the number’s overall value.

Following some of the useful/interesting implementation of the art of handle bit.

Multiplication and Division by 2 (or multiple of 2)

bitwise left and right shift

// this is the normal way to divide or moltiply y for a multiple of
// 2 (0,1,2,4,8...)

y *= Math.pow(2,x);
y /= Math.pow(2,x);

// this is the bitwise way to divide or moltiply,
// note that the X is the number of positions to shift the number

y <<= x // Multiplication by 2^x
y >>= x // Division by 2^x

Even if is possible only to moltiply/divide number by 0,1,2,4,8,16 and so on, consider that the bitwise function is faster up to 3.5 times of the usual one.

Cast using bitshift

Since the bitwise operation results in an integer value (int or uint) we can use the bitshifter also for casting Number to int (uint)
This is 10% fastwer of the normal casting. This also can be used to emulate the math.floor on a double ;)

// Normal casting
x = int(1.232)

// casting with bitshifting
x = 1.232 >> 0;

Swapping int with the Xor Operator ( ^ )

The Exclusive disjunction, also called exclusive or (symbolized XOR or EOR), is a type of logical disjunction on two operands that results in a value of true if exactly one of the operands has a value of true. A simple way to state this is “one or the other but not both, but i’m sure you still know this. What probably you don’t is this advance and smart use of the XOR.

Assume that x and y are two int (uint) already sets.

x = x ^ y;
//  x is equal to x^y       y is equal to y
y = x ^ y;
 //  x is equal to x^y       y is equal to (x ^ y )^ y == x
x = x ^ y;
// x is equal to (x ^ x) ^ y  == y     y is equal to x

like explained in the comment you actually swap two variables without using an auxiliar one and this is also 1.4x times faster!

Other interesting operations

The modulo operator (%) can be easily replaced by an additive mask (with the AND “&” operator).
In other words, the number we need to use as our mask in order to perform a modulus operation on 2n is simply 2n – 1. To illustrate this, the following pairs of statements are all equivalent to one another:

x = y % 8;
x = y & 7;

x = y % 32;
x = y & 31;

x = y % 256;
x = y & 255;

The only difference is that using the mask is 6x faster than the normal modulo.
For the same reason, using this way do determinate if a number is Even or Pair is much faster!

isEven = (i & 1) == 0;  // if i is even return true, elsewhere false.

the following one is probably the best one on encreasing performance side, it is 25x faster than the original Math.abs()

//version 1
i = ( x >> 31) ? -x :x;
//version 2
i = (x ^ (x >> 31)) - (x >> 31);

Comparing two integers for equal sign

eqSign = a ^ b >= 0;

Sign flipping using NOT or XOR

i = ~i + 1;
//or
i = (i ^ -1) + 1

Bitmasks Theory

So what masks are? they are exactly what you think they are, a way for masking something and show the rest. There are mainly 3 functions on using bitmask:

Masking bits to 1
To turn certain bits on, the bitwise OR operation can be used.Knowing that Y OR 1 = 1 and Y OR 0 = Y. Therefore, to make sure a bit is on, OR can be used with a 1. To leave a bit unchanged, OR is used with a 0.

Masking bits to 0
To change a bit from on to off using the OR operation bitwise AND is used. When a value is ANDed with a 1, the result is simply the original value, as in: Y AND 1 = Y. However, ANDing a value with 0 is guaranteed to return a 0, so it is possible to turn a bit off by ANDing it with 0: Y AND 0 = 0. To leave the other bits alone, ANDing them with a 1 can be done.

Querying the status of a bit
It is possible to use bitmasks to easily check the state of individual bits regardless of the other bits. To do this, turning off all the other bits using the bitwise AND is done as discussed above and the value is compared with 0. If it is equal to 0, then the bit was off, but if the value is any other value, then the bit was on. What makes this convenient is that it is not necessary to figure out what the value actually is, just that it is not 0.

So for exemple if you want to know the value for the 5th bit of a 8-bit number just AND it with a 00010000 mask.

Bitmasks Implementations in as3

The main havy use of bitwise operation in as3 is refeared on handling color data.
As you probably know there are mainly two type of colour on flash the 24 bit (with 3 channel, and 8bit (255 value) for each color channel) and the 32 bit (that add the Alpha channel with its 8 bit value). Working with colors can be really painfull if you don’t keep in mind that they are only bits! So forget substring doublets, forget the 10-base arithmetic and start using what you learn on the lines above.

// EXTRACTING COMPONENTS
//24bit
var color:uint = 0x336699;
var r:uint = color >> 16;
var g:uint = color >> 8 & 0xFF;
var b:uint = color & 0xFF;

//32bit
var color:uint = 0xff336699;
var a:uint = color >> 24;
var r:uint = color >> 16 & 0xFF;
var g:uint = color >>  8 & 0xFF;
var b:uint = color & 0xFF;

// COMBINING  COMPONENTS
//24bit
var r:uint = 0x33;
var g:uint = 0x66;
var b:uint = 0x99;
var color:uint = r << 16 | g << 8 | b;

//32bit
var a:uint = 0xff;
var r:uint = 0x33;
var g:uint = 0x66;
var b:uint = 0x99;
var color:uint = a << 24 | r << 16 | g << 8 | b;

In this blog post i’ll try to cover the basic aspects of Trees, proposing a new implementation of the Red-Black Tree.

If you arrived here, you probably know what a Red Black tree is, and why is an interesting data structure, just to refresh a little bit here following a quick overview:

Requirements (invariants)

1) A node is either red or black.
2) The root is black.
3) All leaves are black.
4) Both children of every red node are black.
5) Every simple path from a given node to any of its descendant leaves contains the same number of black nodes.

These introduced constraints against the less bounded binary search trees, let the Red-Black tree longest path from the root to any leaf beeing no more than twice as long as the shortest path from the root to any other leaf in that tree (balanced). This result in algorithm cost of search tend to O(log(n)). The downside is the insertion and delete cost of O(log(n)) too. I must say that is still a fair trade.
The real downside of RB tree is the complexity of the algorithm behind it, that is hard to implement. Usually languages have they own basic implementation of data structures (major languages at least), if not already implemented there are some problems:

- books usually hide part of the implementation (sometimes they just skip and leave the hard work to the reader, since it’s an high risk task this is not a good idea)

- remove and insertion must provide the Recostruction and Coloration,that are the fixup process, to keep the Tree in the right form. In the original structure draft by Rudolf Bayer in 1972 wasn’t specified the effective implementation of the delete operation, so through years there was many implementation, usually with many lines of code, and different approaches.

Before getting into the new RB implementation i must add some explanation about language related issues.

AS3 hasn’t any generics way to handle data.

Generics is the ability to specify a type that will be used within a class without explicitly defining the type. Generics is the way this practice is know in Java world, for oldschool C++ the keyword is Template. In general writing code using generics let you manage one data structure for different type of objects without knowing exactly with object type will be later used.

(there is an interesting article on why as3 needs generics here)

This means that we are unable to implement a general solution (read data structure), but we should typed and force typing just to get better performance (if you are thinking to handler generics object, believe me it’s a bad idea – dynamic type checking is always a bad idea on semi-compiled languages).
So main point is to custom the generic code i wrote (and attach at the end of the blog entry) customizing to your specific purpose. (just search for the “object” and replace with your “type”.

AS3 hasn’t any ready to use implementation of the comparable concept.

This is not only a language lack, it’s about also the way developer think to the question.
Main problem is that data structures usually deals with object, in doing this algorithms (search, order, insertion) take advance of the fact that object are comparable between each other.
In java this concept is well implemented/exposed by the overridable method compares and the comparables interface.
Unfortunatly again this is not a best practice used in the AS3 words.
Let say, that dealing with data structure will force you to find a way to represent the concept that object are comparable and how to take a decision about the fact that A comes from B and not viceversa.

AS3 hasn’t the concept of overloading method.

This is slightly different from set default value to function formal values.
The lack of overloading usually leads to an higher branches complexity (if-then-else levels).
In my implementation i prefered to split overloaded methods into different methods instead of collapsing into one method with higher branches complexity.

So when you’ll download the implementation at the end of this blog post remember to:

1) strictly defined the type of values that LLRB tree handles (now is set to object, just search and replace it)
2) choose a way to compare objects (actually i’m use int as keys, so you can easily define that keys A < B < C, at this point Collision is not handled, if you try to insert object with key B again into the tree, this simply override the B-object already in)
3) be good with my implementation, in java would look much elegant, but as3 as some limits i must workarounded.

What is a LLRB Tree

Finally straight to the point.
In September 2008 (surprised for the recent date ?! ) Robert Sedgewick (a pillar in Computer Science panorama) proposed for the first time the Left leaning tecnique to color the Red Black Tree, introducing additional invariant that all red links must lean left except during inserts and deletes.

What may look like a “simply” modification leads to great results:
- A random successful search examines lg(N) – 0.5 nodes. While the normal RB has a worst case where the search takes C * lg(N) where C is a constant > 1.
- The average size of left subtree exhibits log-oscillating behavior in growing tree
- Experimental studies have not been able to distinguish these algorithms from optimal.
- Simplify the isomorphism from 2-3 and 2-3-4 tree: the left- leaning versions of 2-3 trees and top-down 2-3-4 trees differ in the position of one line of code.
- Simple implementation (that’s true for me at least. Just 250 loc for the entire data structure and 120 for the core only, while a normal RB tree request around 400 for the core only.

Here the classes:

LLRB DataStruct (2.9kb)

Here a firestarter piece of code:

// CREATE A TREE
var tree:LLRBTree = new LLRBTree();
// ADD AN OBJECT
tree.put(key,object);
// SEARCH FOR AN OBJECT
tree.find(key);

// REMOVE AN OJBECT, returns the object removed
tree.remove(key);

// OTHER INTERESTING METHOD
tree.deleteMax(); // find and remove the higher element
tree.deleteMin(); // find and remove the lower element
tree.max(); // find the higher element
tree.min(); // find the lower element
tree.height() // the height of the tree.

Here a not so much interesting benchmark about time elapse in serching ordered data structures with a binary search (for array and vector) and llrb tree search. (Not a fan of this kind of benchmark, but ppl enjoy it, so here you are.)

Even if ActionScript 3 offers us only 3 basic data Types (int, uint and Number) that is , compared with other Languages really a small number, we still suffer the same problem, since is not a language problem, but simply how computers rappresents numbers.

The Floating Point rappresentation.

In Math we usually work with Real numbers (the R set) that are an infinite set of number, where number can have an infinite number of digits (basicly periodical and irrational). Let’s think to PI or the result of fraction like 1/3 to image fews.
Good exemple to get this idea is to think to a number, than divide by 2, and iterate this: I challange you finding an end to this.
A calculator has a limited number of significant digit, that let us figuring out that we can’t rappresent every number in R.
There are also some “minor” problem on how a number is rappresentend inside a calculator, that is the base: we count in base 10 (we have 10 fingers we can count on, in past other base was picked like 60 and 12, both smarter than base 10, due to the bigger number of natural divisor of the base), calculators work in base 2 (since the electronic behind easily works with 2-state voltage condition).
Both the above reason lead to the floating point rappresentation, that even if is not the only existing rappresentation is the most used. (Other two major rappresentions are Fixed point and integer).
The advantage of floating point rappresentation over others, are the wider range of values it can rappresent.
Since the concept of Floating point was formulated first time, many standards was proposed, IEEE decided to make their own standard set of rules for what was recorded in 2008 as IEEE 754 FP rappresentation scheme.

The idea is to use 4 main format, based on the avaiable bit (note: i’m not used to make plural of words like “bit” ), that are 16 (Half), 32 (Single), 64 (Double), 128 (Quadruple).
The avaiable bit are divided into 3 groups: Sign, Exponent, Significant. First group “Sign” is composed by one bit only, 0 if the number is positive, 1 if negative. Exponent group contains 8 bit of the 32 in Single format and 11 bit of the 64 in double format. Exponent (in the 8bit case) can assume 256 different values (2^8): 0 and 255 are reserved number, while the other values rappresent number between -126 and 127 (a tecnical note: this process is called polarization of the number and don’t request a bit as sign, they just move the interval from 0-254 to -126 and 127 in the decoding phase)

The bit left (23 in the single rappresentation and 52 on the 64 bit rappresentation) are used for the Significant group. It rappresents, as name can suggest, the significant digits of the number normalized. This number is also called “mantissa”. The process of normalization is needed for avoiding different rappresentation of the same number.
For exemple the number 30 can be write as 3*10^3, or as 300*10^-1, forcing the normalizationis the only way to know that 30 can be rappresented in Fp only as 0.3 * 10^2.

So now we have all our parts to star moving our “real life” number into floating point rappresentation.
A general number can be rappresented as fl(x) = sgn(x)(0.a1a2…an)b^p

The Problems with FP.

We said that we have a limited number of bits. this automaticly set an upper bount to our desire of mapping real world number into a calculator. Without any standard rappresentation we can easily know that n bit can rappresent up to 2^n-1 number (where any number is +1 from the previous).
Living in the “integer” world is not so cool, and soon we need our point.

This is where floating point world start.

On 64bit double precision, upper bound is 1.79769313486231e+308 that is the result of a all-1 mantissa and the maximum exponent.Lower bound (in the absolute meaning, so the closest number to 0) is 4.9406564584124654e-324.

As you can see in this image, the upperbound is marked both on the Minus and on the Plus side, the next value major than the Upperbound is marked as Infinity (+inf and -inf). This is a marked set of bit that floating point notation use for keep consist some operation (like multiply a number for infinity resulting in infinity)

What really metter is the distribution of number rappresented by the curve, and the hole between any floating point number in that.
This is also called FP relative accuracy where “Accuracy” refers to how close a measurement is to the true value.

Just run the following as3 code.

var e = 1;
var k = 0;

while((e+1) > 1){
	e /= 2;
	k++;

}
trace(e *= 2,k);
trace( "The number 1: ", 1);
trace( "The closer smaller number to 1: ", 1+e);
trace( "The useless addition; ", 1+e/2);

We actually found the closest number to 1, and we also proof that any try to add number minor than this number is useless.
This magic number is called EPS, and rappresent the space between two close FP number. Any number between don’t exist in calculator.
We are facing precision loss of the result.
This affect all the basic operation, and some property we normaly use are not longer valid.

Associative property is not valid in FP:

(x+y)+z != x+(y+z)
(x*y)*z != x*(y*z)

(ie x = −2^100, y = 2^100, and z = 1.)

Distributive propery is not valid in FP:

x*(y+z) != (x*y)+(x*z)

(ie x = 0.5, y = largest possible number, and z = 1)

Simmetry is not valid in FP:

x*y != y*x

(ie x = 0.4 , y=0.3)

Conclusion
Working with Floating Point operations can be legal in principle, but the result can be impossible to represent in the specified format, because the exponent is too large or too small to encode in the exponent field. Such an event is called an overflow (exponent too large), underflow (exponent too small) or denormalization (precision loss).

Introduction:

Summer evenings may be so borings, we all know the “lazy dog layed on sofa” habit takes over! So why not gettin involved into an as3 contest?
Contest’s name comes from the well know trash-movie, with a lower time limit (15seconds is the time before flash player goes in timeout).

So, what are you suppose to do? Write code that solve the following problem in less than 15seconds.
Well, the main aim of the contest is to reach the lowest time, the upperbound limit is just to let you know that a brutal force approach will not work this time!

Updates:

Deadline moved to 16th August

Goals of the contest:

1.Share knowledge
2.Recognize math as still a key skill, even on the daily work (i’ll come back on this as much as i can)
3.Get a chance to try a “think-before-code” approach to a complex problem.
4.Spend, I hope happy, hours on Optimizations, Data Structures and Algorithm complexity Topics.

Contest topic:

In math, as in Science in general, there are some still not solved problems.This means that we can’t give an answer to a particular question.
One of this problems comes from Lothar Collatz. His conjecture asks if for every n (with n an integer number) the iteration

always returns to 1. Actually this is formally undecidable even if there was (and still there is) a high number of mathematic minds that keep trying to give the problem an answer.
For your luck, this is not the contest’s task.

Contest task:

Using the Collatz rule, and starting for ie with 11, we generate the following sequence:

11 -> 34 -> 17 -> 52 -> 26 -> 13 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1

we can call this a chain of 15 steps that leads to 1.

Write a function

collatz(upperBound:Number):Number

returned value i need the number N < upperBound that produces the longest chain between all the numbers from 1 to upperBound.

Submissions Testing: