Preface

I needed a break from Flex for mobile, and wanted to see if there were any other good application frameworks that allowed you to deploy to multiple devices beyond Adobe AIR. Tony Lukasavage had written about a few recently, and Matt Guest had written about his quick experience using Corona for games based on the buzz around Robert Nay, the 14 year old who knocked Angry Birds out of the top mobile game slot via Bubble Ball.

While Unity has the best language on the planet, C#, I needed a break from lower level languages.  In the past, Ruby and Python were great reprieves for doing smaller projects.  In doing some mobile apps, I’ve noticed that for the scope of the project, sometimes 3 weeks or less, the verbose language actually gets in the way.  So, I was looking for a higher level language, and Lua in Corona SEEMS to fit the bill, but I’m still learning.  I liked how I could save a file in TextMate and and it would just refresh the iPhone/Android emulator. HOTNESS! Uber fast compared to mxmlc and “Building…” in Flash Builder, even when using pure AS3.  The interpreted nature of Lua helps speed that up (I guess).

Introduction

I’ve only been reading up on Lua for 1 day, but here’s a quick crash course to get traditional ActionScript programmers up to speed with Lua concepts.  If you’ve done any ActionScript 1, or even JavaScript, you’ll find this very familiar to traditional ECMA concepts.  If you’re a Java/C guy coming to Flex and now reading this, it may be a little weird.

I’m still learning the OOP & packages Lua stuff, so will post that in a later article.  In reading the docs, it’s pretty clear OOP and packages aren’t really something the original language designers figured you’d actually do, so it seems like a ton of work, more than it took in AS1, to get inheritance and packages.

WARNING: This guide was written primarely to help me learn Lua and have all the common comparisons on one page.  I’m sure it has errors and misconceptions; if I get railed in the comments, I’ll update this post as soon as possible.  Here there be dragons, bitches!

Getting Started

If you’re on a Mac, the best thing to do is go download & install Corona + TextMate, and then install the Corona Bundle for TextMate.  For Windows users, you can check out more on their blog.

Output

To show output from your code in ActionScript for the Flash IDE’s console, or Flash Builder’s console, you use trace:

trace("Hello World!");

In Lua, you use print:

print("Hello World!")

You’ll notice there is no semi-colon used in Lua. Like ActionScript they are optional, but most code I’ve seen doesn’t use them. I’ve only met 1 ActionScript coder that didn’t use semi-colons.

There are also no brackets {} in Lua, similar to Python, although the whitespace isn’t as strict.

Comments

In ActionScript, a single line comment is //:

// This is a comment ActionScript

In Lua, a single line comment is: —

-- This is a comment in Lua

A multi-line comment in ActionScript starts with /* and ends with */:

/*
This is a
multiline comment
in ActionScript
*/

In Lua, it starts with –[[ and ends up ]]–:

--[[
This is a
multiline comment
in Lua
]]--

Variables

In ActionScript 1, this was a global variable:

_global.foo = "bar";

In Lua, this is a global variable:

foo = "bar"

In ActionScript 3, you usually have to utilize the Singleton design pattern or a default namespace class to get globals:

package
{

	public class MyGlobals
	{

		public var foo:String;

		private static var _inst:MyGlobals;

		public function get instance():MyGlobals
		{
			if(_inst == null)
				_inst = new MyGlobals();

			return _inst;
		}
	}
}

// then to use
MyGlobals.instance.foo = "bar";

…or a public static variable on MyGlobals:

package
{
	public class MyGlobals
	{
		public static var foo:String;
	}
}

// then to use
MyGlobals.foo = "bar";

In ActionScript 3, un-initialized variables on non-dynamic objects such as classes such as Strings or other by reference variables are null:

trace(foo); // null
foo = "bar";
trace(foo); // bar

Lua uses nil:

print(foo) --> nil
foo = "bar"
print(foo) --> bar

To remove a reference on a strongly-typed object in ActionScript 3, you set the variable to null:

myArray = [1, 2, 3];
myArray = null;

In Lua, you set it to nil:

myNumber = 10
myNumber = nil

Notice I used a Number in Lua. In ActionScript 1, you could do that since all were variants, but in AS3, you can’t set a Number to null, only another Number or NaN.

Lua (I think) has it’s own garbage collection like ActionScript 1 and 3 do, thus they both use null and nil to decrement the reference count on objects. Both have similar rules for immutable primitives, like String and Number always creating new variables, and this copying by value when you create new ones:

var a:String = "moo";
var b:String = a;
a = "whoa";
trace(a); // whoa
trace(b); // moo

Lua is the same way.

The reverse is true for Objects that use by ref such as Arrays/Lists and other Objects.

var a:Array = [1, 2, 3];
var b:Array = a;
a.pop();
trace(a); // 1,2
trace(b); // 1,2
trace(a == b); // true

So, while ActionScript 3 has certain rules for primitives such as String, Number, int, and uint, in Lua you can just set it’s String and Number (it only has Float) to nil.

Types

In ActionScript 1, most everything was a variant. In ActionScript 3, we have a true type system. In Lua, everything is basically a variant. In AS1, if you wanted to figure out the type of something, you’d use typeof:

var foo = "bar";
trace(typeof(foo)); // bar
var foo = 10;
trace(typeof(foo)); // number
trace(typeof(typeof)); // function

In Lua, you use type:

foo = "bar"
print(type(foo)) --> string
foo = 10
print(type(foo)) --> number
print(type(type)) --> function

Booleans & if tests

Keep in mind, nil and false always equate to false. Everything else is true. The use of 0 and “” are considered true in Lua, and in ActionScript. Sometimes people will use if in ActionScript to test for true or if a variable is not null:

if(foo)
{
  trace("foo is: " + foo); // bar
}
else
{
   trace("foo is null.");
}

Similar in Lua:

if foo then
	print("foo is: " .. foo)
else
	print("foo is nill")
end

Concatenation

Notice in ActionScript, + is used for concatenating everything in trace, and ActionScript is smart enough to coerce and/or call toString() on certain Objects.

trace("foo " + "bar"); // foo bar

In Lua, you use ..

print("foo " .. "bar") --> foo bar

Numbers/Floats

Numbers in Lua are similar to Numbers in ActionScript 1; they are floats (decimals). There are no ints or uints.

Tables vs Objects

Tables are the what Lua calls Objects. They have nearly the exact same syntax, although their constructors are completely different and have a ton of syntactic sugar in Lua. They’re basically associative arrays. You can use any value as the key in Lua, excluding nil.

var a:Object = {};
var k:String = "x";
a[k] = 10;
trace(a["x"]); // 10
trace(a.x); // 10

a = {}
k = "x"
a[k] = 10
print(a["x"]) --> 10
print(a.x) --> 10

To remove slots in ActionScript, you use delete:

delete a.x;

In Lua, you just set it to nil:

a.x = nil

Math

Math operations are about the same using +, -, *, / and standard math precedence/order of operations including parentheses ()… sort of. You can see the precedence in the docs.

Relational Operators

Lua has about the same operators as ActionScirpt excluding “not equal”.

 <   >   <=  >=  ==  !=

 <   >   <=  >=  ==  ~=

Notice the last one.

Logical Operators

ActionScript has:

&& // and
|| // or
!= // Borat says, "NNNooott!"

Lua has:

and --> and
or --> or
not --> not

So, from the Lua docs, here’s ActionScript:

trace(4 && 5);         // 5
trace(null && 13);         // null
trace(false && 13);         // false
trace(4 || 5);         // 4
trace(false || 5);         // 5

And Lua:

print(4 and 5)         --> 5
print(nil and 13)      --> nil
print(false and 13)    --> false
print(4 or 5)          --> 4
print(false or 5)      --> 5

Assignments and Statements

ActionScript and Lua have a similiar syntax for statements although ActionScript has more helper shortcuts like +=, ++, etc.

var a:Number = 1;
a = a + 1;
trace(a); // 2
a++;
trace(a); // 3

a = 1
a = a + 1
print(a) // 2
a = a + 1
print(a) // 3

You can also do single line with multiple variables; while un-readable to me, it actually comes into play when you have functions returning multiple values and error handling as you’ll see later.

a, b = 10, 2*x

For example, assuming getResults() returns 2 values instead of the standard 1 in ActionScript, you can get the first and second via:

a, b = getResults()

Yes, craziness.

Local Variables

Local variables in ActionScript:

var i:Number = 0;

function foo()
{
   trace(i); // 0
   var i:Number = 23;
   trace(i); // 23
}

And in Lua:

i = 0
local i = 1

Local variables are stricter in scope in Lua than in ActionScript. They are similar to how they are (I think) in C, where it’s “block based”. In ActionScript, the local variable is local to the entire function whereas in Lua, it’s local only to the current block it’s in, such as the then/else part of the if then statement. Finally, in both languages, local variables are faster to access.

An example of local scope in Lua is a while loop:

x = 10
local i = 1 --> local to chunk
while i < 2 do
   local x = i * 2 -- local to the while body   
   print(x) --> 2, 4, 6, 8, ...
   i = i + 1
end

The locals, like in ActionScript, aren’t actually created until you initialize them, so this makes for more efficient code.

Control Structures

Lua has the standard if, while, for, and repeat statements. The difference is the if, while, and for need a corresponding end for the statement. The repeats use an until statement.

Here’s a simple if statement in ActionScript:

if(a < 0)
{
   a = 0;
}

And Lua:

if a < 0 then a = 0 end

... or:

if a < 0 then
   a = 0
end

Here's an if else statement in ActionScript:

if(a < b)
{
   return a;
}
else
{
   return b;
}

And in Lua:

if a < b then
   return a
else
   return b
end

...that too can be written on one line.

Like Python, Lua has elseif:

if value == "north" then
   return y  - 1
elseif value == "south" then
   return y + 1
elseif value == "east" then
   return x + 1
elseif value == "west" then
   return x - 1
else
   error("invalid direction, yo!")
end

Notice we have the standard == to test for equality. The common way to report errors is the error function; we'll get to him in a bit.

Loops

A quick note about loops. In ActionScript, the first index of an Array or Vector is 0. In Lua, it's whatever you want, but the convention is 1. You can use 0 if you really want to, but a lot of the existing libraries may not work since they follow the 1 convention. Also there isn't a concept of "Array.length" in Lua. The first item found that has nil is considered to be "end" of the Array/List/Table.

While Loop (and Arrays)

For you while fans, here's one in ActionScript:

var i:int = 0;
while(list[i])
{
   trace(list[i]);
   i++;
}

And in Lua:

local i = 1
while list[i] do
   print(list[i])
   i = i + 1
end

Notice Lua starts with 1 whereas ActionScript starts with 0. Also notice the while loop in Lua is testing if list[i] is not equal to false or nil. The way Arrays (in this case a simple table acting as an associative array) work for most looping operations is you test for nil in them. If it finds nil, it assumes it is the end of the array/list.

For - 2 Types

There are 2 types of for loops. For loops are similar to ActionScript, but the syntax is quite different. Sometimes smaller loops are written on 1 line. You'll constantly see this in Lua because of it's Functional bent, a lot of people try to write as terse as syntax as possible. If you come from a Java/ActionScript 3 only background, you'll want to spread it out more. I'll do both below.

Lua's numeric version of for loop works in pseudo code like this:

for var=start,end,optionalIncrement do
   something
end

You don't need to include the increment; if you don't, it'll assume 1. Most for loops I've seen in ActionScript always use 1 anyway.

Here's how we loop through 1 to 10 in ActionScript:

for(var i:int=1; i < 11; i++)
{
   trace(i);
}

Here's how we do the same in Lua:

for i=1,10,1 do print(i) end

...or:

for i=1,10 do print(i) end

...or even:

for i=1,10,1 do
   print(i)
end

There are some strange things too. The var, or i in this case, is a local variable to the for loop. After the loop is done in ActionScript, you can reference it, but not in Lua.

Also, functions/expressions in the for loop itself for start/end/increment are only run once where as in ActionScript, the test & increment are done each loop.

Like ActionScript, if you want to abort the mofo, use break. If you want to break it down, use DJ Icey.

The generic for is like a for var n or a for each in ActionScript where you iterate over properties of an Object. This gets pretty deep in Lua, and they have a TON of different ways one can write iterators, using closures, coroutines, etc. I encourage you to briefly read the docs on generic for and hit the advanced stuff (advanced for me, heh) if you're into that kind of thing (*cough* Python developers *cough*).

Break and Return Placement

While break and return are similar to ActionScript, their placement is more strict. Both have to be right before the last part of a block (right above end, else, or until).

Functions

Functions in Lua are just like they are in ActionScript with some subtle rules about usage you can read more on. What I want to focus on is multiple return values which plays into how you do error handling/logging in Lua if you come from a Flash background.

It's called unconventional in the docs, but when all functions that run in protected mode (more on that later), return errors as the 2nd parameter, that's not unconventional, that's conventional.

Anyway, check out how the find string function looks in Lua:

 s, e = string.find("hello Lua users", "Lua")
print(s, e)   -->  7      9

The find gets the first index where it occurs and ends or nil if it can't find it. Notice how the first result is in s, and the second is in e. To do this yourself, you just return 2 values like so:

function fooByTwo()
   return 1, 2
end

uno, dos = fooByTwo()

Variable Number of Arguments

Lua has rest parameters like ActionScript has as well:

function showNames (...)
   for i, name in ipairs(arg) do
      print(i .. ":name=" .. name .. "\t")
   end
end

Notice the arg variable is a predefined variable in functions, much like arguments was in ActionScript 1. In ActionScript 3, we can name it whatever we want:

function showNames(... names)

Finally, you'll notice ipairs is used a lot as a sort of default iterator for loops.

Function Scope

You can read more about lexical scoping, closures, and all the other Functional stuff if you want, but I wanted to focus on Scope because it's bloody AS1's thisThing.owner/mx.utils.Delegate all over again. If you don't remember what I'm talking about, or you have no context, Keith talks about it and how to get around ActionScript 1's scoping challenges via the Activation Object and Mike Chambers elaborates on how closures work in AS3.

Before AS3, classes had their callbacks scoped to what object they were called from, not where they were defined; thus you had to give child objects pointers back to their parent classes.

Lua has the same deal with functions. I'll elaborate more in a future OOP article since I'm still learning, but here's how it works. Functions in Lua by default don't have a this or self. Much like Python, you have to pass in scope in a generalized fashion.

Static

So... here's how you do a static method(sort of) in ActionScript:

package
{
	public class Bar
	{
		public static function foo(a:String):void
		{
			trace("passed in var: " + a);
		}
	}
}

Bar.foo();

...and in Lua:

Bar = {}
function Bar.foo(a)
   print("passed in var: " .. a)
end
Bar.foo("Cow")

In Lua, like AS1, you delete your class objects, however, thus if I made an instance, and tried to call it, it'd cause an error:

b = Bar
Bar = nil
b.foo("Test") --> Error

Instance Methods

So how do we get "this" equivalent? In 2 ways; it depends on how you call the function. Remember, Functional people like carrying scope around like a magic gem... seems like a lot of work to me, but I grew into an OOP world so what do I know.

You'd refine the above to this:

function Bar.foo(self, a)
   print("passed in var: " .. a)
end

Then, you can call it in 2 ways, the first manual way:

b = Bar;
b.foo(b, "test")

Or the built-in way they have to do that for you:

b = Bar;
b:foo("test")

Notice the colon instead of the dot.

If you remember Object.prototype in ActionScript 1 where you had to manually add this inside all functions, it's very similar.

Classes

I'll get into classes and packages later... they are whack compared to what I'm used too. For now, here's 3 syntax variations you can do (this'll look familiar to you AS1 devs):

The object/table way:

Lib = {}
Lib.foo = function (x,y) return x + y end
Lib.goo = function (x,y) return x - y end

Using the Lua table constructor way:

Lib = {
  foo = function (x,y) return x + y end,
  goo = function (x,y) return x - y end
}

And the common way I've seen in Cornoa (I think):

Lib = {}
function Lib.foo (x,y)
   return x + y
end
function Lib.goo (x,y)
   return x - y
end

Errors

Lua's runtime, at least from what I've seen in Corona, runs just like Flash Player 8 on down did. If the original AVM has an error, it aborts the current function and/or related stack items, and tries its best to proceed. You can run Lua where it'll output to the console (Terminal if on Mac), but you won't see the errors in your code unless you specifically trap/log them.

A common error check in ActionScript 3 is checking for null; since this is the one thing our mxmlc compiler (and the Flash IDE) isn't really good at finding since Flash often gets external data in it, and thus "garbage in, garbage out" comes into play.

if(UserFactory.getUser(xml) == null)
{
   throw new Error("Dude, our XML is whack, yo! ...or maybe our parsing code is lame.");
}

Lua can do something similar:

if not UserFactory.getUser(xml) then error("Dude, our XML is whack, yo! ...or maybe our parsing code is lame.") end

However, that's a pretty common operation in Lua, thus they have an assert function. If assert gets a false or nil back from the function, it'll raise an error with the string you pass in the 2nd parameter:

user = assert(UserFactory.getUser(xml), "Failed to parse user."),

If you don't raise your own error in functions, Lua will return nil by default. Otherwise, you can call the built in error function, passing in the reason for the failure as a string, simliar to throw new Error("that blowed up real good") in ActionScript 3. You'll be able to see this in the console/Terminal.

Thus, the common way to play it safe is to use assert. Remember before explaining how Functions can return 2 values, and by default will return the error, if any, as the 2nd parameter? This works naturally with assert (example below from the docs):

file = assert(io.open("no-file", "r"))
      --> stdin:1: no-file: No such file or directory

Notice you didn't have to write a 2nd parameter in the error function, it'll return and print automatically via assert.

Custom Error Handling

Lua has a try/catch equivalent as well. If you call error("Explosions") inside a Lua function, it can be caught via pcall which means "protected call". Using pcall, it'll return true if all is well, and false if an error occurred. In ActionScript, you'd go:

public function foo():void
{
	if(!allGoodInDaHoodDogwood)
	{
		throw new Error("ZOMG, Compton!");
	}
	else
	{
		return;
	}
}

try
{
	foo();
}
catch(err:Error)
{
	trace(err);
}

In Lua:

function foo()
	if not allGoodInDaHoodDogwood then
		error("ZOMG, Compton!")
	else
		return
	end
end

if pcall(foo) then
	-- no errors in foo
	print "They SHOOTIN'!!!... aw made you look, you slave to a page in my rhyme book."
else
	-- foo threw an error
	print "foo blew up"
end

Stacktrace

You can use

print(debug.traceback)

to see the stacktrace up to the point of execution.

Conclusion

As we can see, Lua has a lot in common with ActionScript, specifically ActionScript 1, JavaScript, and ECMA in general. There is much more to Lua than the above, and the above is just from 1 day of reading & playing. If you're not looking to totally rock your world when learning a new language, say ActionScript to Objective C, then I encourage you to check out Lua, specifically using the Corona resources I stated at the top of this article. When I figure this OOP and package stuff out, I'll write a follow up post.

Please feel free to post corrections in the comments; I'm obviously still new at Lua.

The downside is, when you compile, you do not get errors if the Flash IDE didn’t find a class for a particular Symbol that’s set to have one.  Maybe you mis-typed the package path or class name.  Maybe you forgot to set the class path for the FLA.  Maybe the FLA is in the wrong place.  Whatever the reason, your code “won’t work” and you won’t know why.  You may not get code hints in Flash Builder / FDT / IntelliJ, and certain other dependencies may be missing as well and you’ll be left wondering why.

The Flash IDE provides a check mark button next to the linkage class to allow you to confirm or deny Flash can find the class.  In a quick scan of the JavaScript for Flash docs, I could not find a way to use this button’s functionality in JSFL.  So, I wrote a quick script that does.

NOTE: I do not take source paths into account; I assume that the classes are in the same directory as the FLA’s.  You can easily change this by querying fl.getDocumentDOM().sourcePath, or just hardcoding your known path.

fl.outputPanel.clear();
fl.trace("*** Checking for un-found classes... ***");
var totalNotFound = 0;

var doc = fl.getDocumentDOM();
var lib = doc.library;
var items = lib.items;

var itemsLen = items.length;

for(var i = 0; i < itemsLen; i++)
{

	var item = items[i];
	/*
	fl.trace("--------------");
	for(var prop in item)
	{
		fl.trace(prop + "::" + item[prop]);
	}
	*/

	if(item.linkageExportForAS)
	{
		var className = item.linkageClassName;
		var classPath = className.split(".").join("/");
		var exists = doesClassExistOnDisk(classPath);
		if(exists == false)
		{
			totalNotFound++;
			fl.trace("Couldn't find class for '" + item.name + "', class: " + className);
		}
	}

}

if(totalNotFound == 0)
{
	fl.trace("*** DONE. All classes found.");
}
else
{
	fl.trace("*** DONE. " + totalNotFound + " classes not found.");
}

function doesClassExistOnDisk(classPath)
{
	var filename = classPath + ".as";
	var doc = fl.getDocumentDOM();
	var currentFolder = doc.pathURI.split(doc.name).join("");
	var fullURI = currentFolder + filename;
	//fl.trace("fullURI: " + fullURI);
	return FLfile.exists(fullURI);
}

On a side note, Dru Kepple has a lot of wonderful JSFL classes to help working with ActionScript in the Flash IDE, specifically the Document class.

It’s long overdue. Flash Builder 4 is a mess, and hopefully fixing/improving the following items will bring it up to par.  If you are a product engineer, skip the intro.

Problem

Flash Builder 4 is a great leap forward from Flex Builder 3.  It’s not any large features, but rather a bunch of little, consistent things that lead to a pleasant experience.

Years of neglecting other areas, as well as blatant missing features that open source alternatives & competing IDE’s have makes me question if there is any serious money behind Flash Builder.  I know the effort and will are there; even after distancing myself from the Adobe product teams the last 3 years, when I do return via email/Twitter, they still have great attitudes, and want to continually improve their tools/runtimes.

Bottom line, I and many others are more productive using open source alternatives to Flash Builder, and usually only keep Flash Builder around for 3 key features (Library project linking, Design View, and superior MXML handling, specially with states).  There are a lot of common workflows that seem to be ignored, and even after 4 years of the community bringing them up, they still aren’t remedied.

I outline the problems below with potential solutions.  Some solutions are actually easy; you just copy open source implementations.

Call To Action

I cannot promote Flash Builder 4 to my clients, nor will I spend another dime on Flash Builder 4/5 licenses until Adobe takes Flash Builder seriously by making 5 on par with open source alternatives.  While I respect that some of the blame lies on the Eclipse foundation, Adobe clearly thinks there is value there if they base a Designer specific tool’s future, Catalyst, on top of Eclipse’s architecture.

I, and millions of others sent a message to Adobe with CS4.  We were sick and tired of incomplete features, bugs, and crashes.  Adobe then laid of 10% of their staff due to poor CS3 sales… even though 1 month prior their CEO was on stage at the Adobe MAX conference saying sales were doing well.  They did this again the following year.  You can blame it on the recession.  You can blame it on a public company doing what most do in down times; laying off staff to boost their stock value when dividends are nowhere to be seen because there is no forthcoming company revenue.

…or you can take responsibility for your bad software, and fix it.  I was a devoted customer until CS3; we fought with our wallets, and our wallets won.   Which sucks.  My career and life are based on Adobe’s product line.  When you, Adobe, suck, life sucks.  Not just for me, for the world.  You’re doing important work.

The following are problems with potential solutions.

1. Code Hints

Flash Develop, FDT, IntelliJ, and Visual Studio all give code hints for your classes, methods, and variables WHILE YOU TYPE.  No period needs to be post-reached, not keyboard command; it just shows you a drop down WHILE YOU TYPE.

Worse, if you misspell something and back up, most of the time the drop down will go away, forcing you to spend more time to get the code hint to come back up… or just say eff it and code like your in AS1 (or Python).

This should be top priority; I understand if you’re waiting on Eclipse to add this.

2. Automatic Class Importing

Flash Develop and FDT both auto-import for you while you type and hit enter.  IntelliJ gives you the option to hit Alt+Enter to import a class of your choice, or perhaps define it which is even cooler.  Know what Flash Builder does?  Doesn’t compile, and blames it on you.  Gee, thanks $500 IDE.  I paid you $500 bucks to bitch at me and not auto-import my class you know full well where it is.

My code is littered with var a:SomeClass.  If you go on a blank line, and type var a, it’s the quickest way to get the class drop down.  From there, you can hit enter which’ll auto import the class.  You then delete the line.

Half of the problem is that the drop down is just flaky; miss it, and it won’t import your class.  Just start typing in a non-start line place, and Flash Builder won’t even give you a code hint.  Import yourself.

Please do a better job of auto-importing.  Level 1 is to get what Flash Develop/FDT do, Level 2 is to match IntelliJ’s intelligent options.

3. Slow Code Hinting Response & Mispellings

Part of the problem is the code hinting is just slow.  IntelliJ, which is slower than Eclipse, still seems to consistently work.  While Flash Builder 4 has significant improvements for misspellings over Flex Builder 3, ESPECIALLY in the class creation dialogue, for the code hints, 9 times outta 10, if you mispell “Graa” instead of “Grap” for Graphics, good bye dialogue, please start again.

If you can’t increase the responsiveness, then just be more forgiving with spelling, or just fix #1, and you should be good.

4. Stop Being ActionScript Racist: ActionScript vs. Flex

You all have been doing this crap since Flash 8.  Back then, you’d show AS3 code hints for AS2; even help would show AS3 when I specifically set AS2 in the publish settings.  Back then, QA was sincerely concerned, but it still shipped.  “We don’t want you to use AS2 anyway”.

When people like Keith Peters, Steven Sacks, Grant Skinner, and Darron Schall bitch about it, and you do nothing, that’s a serious communication problem… and makes me question if the assholes who used to run Flash Media Server 1 & Flex 1 teams are now running Flash Builder team.  Aka, “Screw you, your ideas make us and our shareholders no money, please DIAF.”

When I create an ActionScript 3 project, and go to import flash.display.Graphics, but you give me a code hint spark.primitives.Graphic, I want to throw a nuke at San Fran.  It’s a waste a time, confusing, and causes compilation problems.  It also leads to subtle, yet horrible problems where Flex dependencies get leaked into potentially awesome AS3 only libraries.  as3corelib is a perfect example.  Was pimp… then someone accidentally imported mx.formatters.DateFormatter… AND YOU’RE FUCKED!

If I create an AS3 project, get your damn Flex outta my code.  I’m Jesse Warden, you know I love Flex, especially 4 now that I’ve drunken the Kool-Aid.  But when I’m coding an AS3 only AIR project for Android to help promote your technology, and your own IDE starts getting all AS3 racist on me, it makes me RAAAGGGEEE!!!

5. Linking Projects: Unit & Visual/Functional Testing

Linking projects is just garbage and does not work.  One of the greatest features you all implemented in Flex 2 was Library Projects.  Using Library projects, you can also make Design View quite useful in Flex 3.  You just build all your GUI in the Lib, and implement with application logic in your main project.  Since it’s a Library project that’s pre-compiled, all your graphics show up nicely in Design View.

…if you want to unit test or do visual tests, however, it’s a nightmare.  In this case, I have 3 options (3rd is make your own command line build script for mxmlc).

I can either integrate all my unit testing code & framework libraries into the project itself, or setup a new Flex/ActionScript project specifically for just testing the code.  If you’ve ever worked with a large team, you know that the 1st doesn’t work.  All someone has to do is get out of sync and/or break the build, and poof, productivity grinds to a halt.  Broken builds, source control/SubClipse can get out of whack, or strange conflicts can result.  Things happen, no big deal.

The big deal is you can lessen the impact by creating new projects so developers can work on their projects and do integration testing with their new code on their own terms when they are ready to lessen the impact on the team.  It’s a very simple thing to do.

The problem is, this sucks.  Linking to Library projects is magic; it’s why people still keep Flash Builder around when they primarily use FDT.  You just click the “Add Project” button for Library paths, and BOOM, you’re linked.  It automatically recompiles your SWC, and copies the fresh mofo over.  No manual refreshing, no Project Clean n’ Pray… it just works.  THIS is where I’m glad some of my $5oo bucks went.

For projects?  No such love.  I have to manually point the source to the other project’s source.  While in the same Workspace, apparently Eclipse doesn’t think that’s useful and makes me manually navigate there via Finder/Explorer.  Worse, you have to do it AGAIN for your libs folder since it’s a source path link and not a real project reference.

…and it gets worse.  Because it’s a source path to an open project, Eclipse gets confused sometimes.   You’ll run into situations where you can have to “MyCustomButton.as” files open.  Which tab is which?  Why is one “out of sync”?  How come sometimes I compile and run and the code hasn’t changed?

This is even more important for components you’re testing in AIR projects.  Most AIR projects have complicated bootstrapping, so it’s not very straightforward to just test a new AIR application (which creates yet another AIR config xml file).  It’s easier just to create a quick ActionScript/Flex project, and test the components in isolation.  Quicker to solve bugs too.

Please fix linking projects (Library projects work just fine).

6. Design View

What the hell did you do!?  This worked fine in 3.  In 4, sometimes my drops are ignored.  My pixel perfect placements take 3 drags to get right.  Sometimes it just gets locked up, and I have to manually hit the refresh button.  Based on Twitter, there are only 3 other people in the world who use Design View; the rest are crayon pushers who use Catalyst, so maybe that’s why.  Still, if you don’t want us to use it, then make it like the Behaviors Panel in Flash, and REMOVE IT.

7. Proactive Error Checking

mxmlc’s incremental compilation is rad.  I know those coming from PowerBuilder, Java, and other large Enterprise systems which have tools that are pretty smart at only re-compiling what is needed are somewhat critical of mxmlc’s speed.  Whatever, if you worked on projects in Flex Builder 2, and then did projects in Flex Builder 3, it was light years better.  If you did work in Flash IDE, then went to MTASC, then went “back” to Flex Builder 2, then 3… it was UBER-light years better.

That said, the background compilation for errors doesn’t really do much.  IntelliJ really wins here in making use of the full IDE to HELP you, vs. just inform you’re screwed, no compilation for you.  Right now, most messages in Flash Builder’s mxmlc errors are good enough, and clicking on the error to go to the line is great.

However, IntelliJ makes the word/area red, puts red tick marks on the right side to indicate where in the class the error is, and even underlines the tab’s class name itself to imply “this class has an error”.  That’s 3 visual indicators each covering a different spacial area all to be proactive to help you FIND problems.  Even cooler, IntelliJ has some helpful options to import a class you forgot, show a possible mispelling, or allow you to create a class that doesn’t exist yet.

These common problems are old.  IntelliJ has found ways to help you solve these common problems.  I fail to see why at version 4 we’re still ways away from this.  All we get a list of red dots plus reasons away from the code itself and everyone I know ignores all of them except for the 1st.  Context is key, and in-code errors plus helpful solutions would be great.

8. Copy Paste

How come I can’t copy paste from Flash Builder to Flash?  Some programs just seem to ignore the clipboard from Flash Builder.  Others on Twitter have reported the clipboard in Eclipse is reclusive for them as well.

9. Pasting Multiple Files

I have flexunit4.swc, hamcrest.swc, mockolate.swc, greensock.swc.  I copy them from my Finder.  I paste them into my libs folder inside of Flash Builder’s project panel.  Only flexunit4.swc makes it. God dammit.

Please fix this.

Conclusions

If you fix the above, you’ll start to become on par with Flash Develop/Intellij/FDT.  Once you do that, I can justify spending $500 again for an IDE.  Right now, beyond MXML handling, states preview, and consistent Library Project linking, I’m not sure why I paid for in my upgrade from 3 to 4.  Whatever I can do to NOT use Flash Builder 4, I’ll do.  Either you all were rushed, you don’t have enough money behind the project, or y’all have never used another IDE beyond Flex Builder to code ActionScript.

If you didn’t listen to anything I said, then for Flash Builder 5, please:

1. copy Flash Develop’s code hinting
2. copy FDT’s code gen
3. copy IntelliJ’s proactive error handling & auto-importing
4. copy FDT’s class re-factoring
5. fix Design View

Please keep in mind the following is full of (accurate) generalities to make things more concise and easier to understand.  The Flash/Flex community is very diverse, and as such there are many exceptions to the below.

Nomenclature

W2: You’re employer takes taxes out of your paycheck.

1099: You are responsible for all taxes owed on your revenue.

W9: Like 1099 for companies working with other companies (as opposed to an individual like 1099). Also know an as Corp to Corp/C2C.

What is a Flex Developer?

A Flex Developer is a programmer who utilizes the Adobe Flex SDK to create either web based applications, often called Rich Internet Applications, that run in Flash Player or desktop applications running in the Adobe AIR runtime.  They code in the ActionScript 3 programming language, and often utilize Flash Builder 4 as their IDE.  Their work usually ends up being a SWF file that runs in the Adobe Flash Player, and is accompanied by a little HTML and JavaScript.

A lot of Flex developers come from traditional programming/computer science backgrounds, as opposed to art/design agency backgrounds like Flash Developers do.  Combined with the fact that the Flex community is diverse as well as continuing to utilize other technologies, many will utilize other IDE’s or a combination there of.  These include Flash Develop, FDT, Emacs, and IntelliJ amongst others.

They also utilize MXML and CSS in their work, and sometimes utilize other design tools such as Adobe’s Photoshop and/or Illustrator to integrate designs into their work.  A select few make use of Flash Catalyst to integrate complex designs into their Flex work.

Flash is not Flex

While Flash Developers also code in ActionScript 3, and deploy SWF’s to the Flash Player, they are not Flex Developers.  Flash Developers will utilize the Adobe Flash IDE, traditionally a design & animation tool turned hybrid programmer tool.  While many are capable of creating many of the same applications that Flex Developers can create, the clientele, not the developers are the defining factor here.

Flash Developers tend to work on smaller projects with shorter time frames, and often have a lot more design.  The projects’ development span from 1 day to 6 weeks.  Most do not have experience creating Enterprise applications.  Enterprise applications refer to the length of development, often from 4 months to 18 months or more.  This deadline differentiator belies a significant amount of skill sets that Flex Developers tend to have more often than Flash Developers (not always which adds to the confusion).  Famous keywords include OOP, Continuos Integration, TDD/Test Driven Development, Design Patterns, Frameworks, et al.

To add more to the confusion, many Flash Developers employ many of the same technologies & methodologies Flex Developers utilize.  These include using alternative IDE’s, using the mxmlc compiler included in the Flex SDK, and utilizing frameworks such as Cairngorm/PureMVC/Swiz/Robotlegs.

If a client asks you for a Flex Developer and you send them a Flash Developer, you are making a huge mistake.

It all comes down to the typical clientelle the develeper gets.  If their past projects last 4 months or longer, they can probably cut it.

Different Types of Flex Developers

There are basically 4 types of Flex Developers.

1. Junior
2. Mid-Level
3. Senior
4. Architect

A Junior is often someone with little experience, whether that’s in Flex, or in just programming in general.  Fresh out of school, or just starting a new career.  They’ve never done professional Flex Development, or little of consequence.

A Mid-Level Dev is often someone with some good experience, but either requires direction, or does not currently lead a team in development.  Leading a team here doesn’t mean management; it means providing technical & architectural direction to the rest of the team to ensure the project moves along smoothly.  Often times, you’ll have senior/architect developers from other languages who are learning Flex for the first time.  While they bring their often vast experiences, Flex is a new runtime and programming model, and as such, they are considered mid-level, and should not be leading a team.  Either way, they only have a couple projects under their belt, or a lot of projects not in Flex.

A Senior Dev is someone with a lot of experience and is familiar with current, best practices.  They have a long list of projects under their belt and a lot of experience.  They can be depended upon to develop Flex software successfully if setup to succeed.

An Architect is someone who could design the entire application, from scratch, correctly.  Often, these individuals will do back-end technologies as well to ensure they have the whole picture of how everything works together.  They can either lead the development team, or share leadership duties with other senior level devs.  There is crossover between Architects and Senior devs.

How Flex Developers Work

Flex Developers work just like any other normal person.  Some are W2, some are 1099, and some are W9.  You can also find all 4 skillets doing all 3 payment types.  Most Junior and Mid-Level are W2.  Most Senior and Architect’s are either employed at large companies that can afford their rates, or are through one of the larger consulting firms.

That said, finding a good W2 Flex Developer is extremely hard.  Most Senior and Architect level developers are 1099.  That, or they are working with consulting firms who often keep them busy.  Thus, getting them to lower their rates so your firm can take a higher cut to work on a potentially not so savory project is hard.  While the larger consulting firms do not always provide the top projects, because of the brands they develop, it’s easier for them to find the work that would interest Senior/Architect Flex Developers.  This is yet another challenge for recruiters.  The best thing you can do is be as concise and truthful (NDA’s nonwithstanding) as you can.  If you find a Senior developer between projects, they need to eat just like Junior’s do, thus this is a great time to strike.

Remember, even if they aren’t a fit, they may know someone who is.  The Flex industry is small, and it’s all about timing.

Where Flex Developers Work

With W2, it’s implied you’ll work on-site.  As long as the company has benefits, W2’s are sometimes willing to relocate.

This is complete opposite with 1099/W9 developers, especially Senior/Architects.

Most Senior and Architect 1099/W9 developers prefer telecommuting.  Many aren’t willing to relocate, although many are willing to do some travel.  Sending an email asking for W2/relocation is a sure fire way to get your email/LinkedIn/Tweet ignored by such individuals.  If you can find out that those individuals are in fact senior, (via Blogs/Twitter/LinkedIn) a phone call is often better because you can more quickly respond that “1099 can be worked out”.

The telecommuting part is tricky.  Almost all clients, especially those large enough to afford Senior/Architect Flex devs, will not blindly accept telecommuting.  Often, the engagement is of a consulting nature, and many non-progressive companies view remote with insecurity, and thus not solving their immediate cluster fire.

Rather than state that the position does not support telecommuting (unless you know for a FACT it does not), explain to the potential hiree that it’s up them to negotiate telecommuting terms.  There aren’t many Enterprise sized Flex projects that are 100% remote.  It’s MORE than reasonable for a client to expect a Senior/Architect to be on-site for the first 2 weeks, during milestones, and then towards the end of the engagement.  That’s 15 days over the course of 4 months: completely MORE than reasonable.  A freelancer/consultant almost can always work out those agreements with the client.

That said, it is a major risk, and I’ve seen people walk away from gigs 2 weeks in because these terms couldn’t be worked out which then puts your firm in an uncomfortable position.  I recognize that educating the client on such things is challenging.  Usually talking to the person running the project directly ensures you can get an unofficial yes to assuage your potential Flex candidate.

Rates

Rates are all over the map.  That said, the cream of the crop has extremely high expectations, especially those who live in coastal cities like New York and Los Angeles, or who are just in the know of what the going rate for their skills are.  Here are some good metrics I’ve seen.

Those who work with consulting firms, or have experience as such, will sometimes expect higher rates.  As such, they build up a common perception that they’ll never get work from recruiters, so just keep this mind.

Prima Donnas?

By this point, you may have developed the opinion that high-end Flex Developers are Prima Donnas.  That isn’t true.

This is what is true: First, they know they are rare.  It’s way easier to be a rockstar in the Flex world than the Java world.  As such, some recognize the rules of supply and demand, and capitalize on it.

Second, the Flex community is small in comparison to the Java, .NET, and JavaScript ones.  This close knit nature allows the free exchange of gigs, recruiters, and general news.  Since Flex developers have an easier access to others in the Flex community through Twitter and Facebook, and it’s easier for them to find gigs, W2/1099, on their own without the need of a 3rd party.  This expectation, real or not, affects their communication with those offering sub-optimal rates with sub-optimal conditions (W2, on-site, etc).

Third, Flex is hot and new.  This means that clients adopting it tend to have an ounce of progressiveness somewhere.  Therefore, if you pitch the position as anything beyond hot and new, Flex devs will listen to the alarm bells going off, warning them that their attention spans may not surivive, and thus look for more lucrative offers.

What’s a Recruiter to Do?

As a recruiter, there are a few things you can do.

First, recognize the community is small, and pitch this to your client.  Unlike Java where you have to weed through hundreds of unqualified individuals, Flex has a way smaller pool.  Yes, it’s growing, but it’s still small in comparison.

Second, recognize that you only need to establish a good relationship with 1 known Flex Developer to gain access to the rest.  No, I’m not talking about those using Monster/Dice, I mean the Senior/Architects you’d kill to give to your clients.  Often these people participate in some fashion with the social networking scene.

Third, and yes, I recognize this is hard: you need to sell the project.  Using a bunch of adjectives in a long email has the opposite effect of what you’re looking for.  Instead, see if you can get some more real details that HR people from large companies will never give you.  I don’t care how you do it, just do it.  An example could include calling up the company HR:

“Yes, hi, this is Jamie from Tech Recruiting.  I was hoping to get some more technical details that weren’t included on your candidate sheet.  Could you perhaps let me ask the Director of Engineering 2 questions I had a variety of potential candidates ask me?”

This gets you to the person who’s hiring, and hopefully can get him/her to deluge you with the technology stack they using.  THESE are the keywords you want to put in your emails.

“Large company doing cool, new things with Flex” == pathetic.

“Real-time data using Blaze DS with extremely custom UI created in Catalyst” == fuck yes!

They wouldn’t call it work if it were easy.

Conclusions

Hopefully the above gives you an idea of what a Flex Developer is, how they are different from Flash Developers, and how you can lure them in.  Flex Developers tend to build Enterprise Applications where as Flash Developers do not.  Ensure that the candidate has past clients/work that lasted longer than 3 months.

A lot of the senior Flex Developers that are known in the industry are 1099 only, and many only want to do 90% telecommuting.  These things are all about timing and who you know.  You can’t help the first excluding being early.  For the latter, try to get as close to a “negotiable” as you can to lure potential hiree’s in.

While rates are often out of your control, it’s important to set your client’s expectations.  Flex Development is still new and lucrative, and the rates some people charge are outrageous.  The recession helped a little… but not much.

A lot of Flex Developers know the above.  Remember, you just have to develop a good relationship with 1 to have a gateway to the rest.  Use small emails with enough details of what you’re offering.  Copy pasted, 1 page or longer emails from the HR of the job with your company’s template is exactly what you shouldn’t do.  For the record, you shouldn’t have to capitulate to a bad attitude.  Everyone who was good that I worked with had a good attitude.

Anything you can do to get more technical details about what the team is actually doing makes it way easier to sell the gig.  It also makes you extremely attractive for a Flex Developer to talk to you since you seem to know what you are talking about, and thus seem to feel that the potential hiree is right for the job vs. a blind “I found on you Google/LinkedIn/Your 6 year old Monster/Dice post with keywords in it and it’ll take 4 emails over 4 hours to figure out wtf the gig is”.

Finally, if you’re bold, get them to answer my 8 Flex Developer Interview Questions (skip #8 unless you know what you’re doing).

Good luck!

*** Update: Paul Taylor (@guyinthechair) has a more recent post on the same subject. ***

*** NOTE: I’m a n00b at Cocoa and Objective C. Unlike Python, I don’t like learning it, either. If you perceive something below is inaccurate, please comment, and I’ll update. ***

Preface

I was having a lot of fun using the iPhone packager. Then Apple changed their licensing to prevent people like me from using ActionScript for iPhone/iPad, and instead being forced to use their toolsets, or those unofficially approved. At first I was furious. Then I tried to get a simple list to scroll in AS3. Even using a fake mask, device fonts, and cacheAsBitmap for all items + container, it just wasn’t smooth, even with just 30 items, regardless of frame rate. If you use an out of the box UITableView in Cocoa, it “just works”.

I built my career on Flash Player because “it just works”. It doesn’t “just work” on the iPhone, and now it’s effectively illegal to use. That, and Adobe has apparently abandoned ship on the iPhone/iPad/iTouch portion, and instead are focusing on Android.

I was amazed at what I could do using Flash Lite 2 on my Nokia 6680 3 years ago. AS3 was all the rage, and yet I took the time to build a component framework in AS2 for use on devices because I felt it was “good enough” to build experiences for consumers. That market never materialized unless you targeted Japan (which I didn’t).

After finally getting my simple SWF to compile to the iPhone, I was estatic at how easy it was to design & code in what I knew, it just worked, and looked like I expected it to. Once I started moving things via TweenLite, though, it all went downhill. I don’t have these problems in Flex. If I use a List control in Flex, it just works; I don’t have to be an AS3 game developer to theorize on GPU acceleration possibilities to get the best list scrolling performance. I don’t have these problems, at least from what I’m initially seeing in my early learnings, with Cocoa.

So, I’m learning Objective C so I can execute the ideas I have for iPhone and iPad. Unlike PHP, Ruby on Rails, and Python & Django, this has been a pretty miserable experience. Python and Django are my choices for back-ends currently… but I don’t really have a “choice” for front ends on iPhone/iPad.

In an effort to reduce the pain for others as well as help myself retain this knowledge, I’m writing it down.

I understand it might seem strange since Android is a lot easier to develop for, and Flash Player 10.1 actually runs natively on the phone… and well, I might add. For me, there are 3 reasons. First, there is no market right now. Yes, I understand we help create it, but I own an iPhone and iPad. I love them, and so do others. I have a gateway to others right now via the app store, and want to empower them to use my apps. Secondly, if you’ve ever used an iPad, the additional screen real estate just fills you with ideas. Third, everyone wants an app right now. While the consumer data shows it’s hard to make money, it’s REALLY easy to make money for services; aka, a company hires you to build an app for them. This is especially true with the OS4 announcement of Enterprises having more control over deploying their own applications.

Another good primer for me, Objective C for the ActionScript Developer, is Keith Peter’s five tutorials. He doesn’t really cover the UIKit, just Objective C in general which is a great first start.

1. AS3 to iPhone Tutorial 1
2. AS3 to iPhone Tutorial 2
3. AS3 to iPhone Tutorial 3
4. AS3 to iPhone Tutorial 4
5. AS3 to iPhone Tutorial 5

Introduction: Nomenclature

There are a lot of new terms to learn. I just want my code to run on the iPhone, yet I have to learn a bunch of new terminology to ensure I understand what it entails, as well as their “meaning”. For example, MVC means something different to Objective C guys than it does to us. Yes, it’s subtle, but when they say it, it’s assumed you mean “their” version. It helps to know what the nomenclature of the Cocoa community is to learn, so first up, here’s some common terms.

Cocoa: The API you code in for the Mac. It’s like saying “Flex”; it’s all the things that fall under “Flex” like the compiler, the sdk, the ide, the runtime, etc. However, it’s a lot more than that. For example, there are Human Interface Guidelines that Apple puts out that Cocoa apps need to comply with (I don’t currently know how this is enforced, excluding iPhone/iPad). For the sake of this article, all you care about is “Foundation” and “UIKit”, 2 libraries that make up a lot of what people know of as Cocoa for iPhone. It’s also built on the MVC concepts we’re used to. The main difference is Cocoa is huge; it is a layer atop an OS, whereas Flex is a layer atop the Flash Player.

Objective C: C like programming language you code in that borrows some cool things from Smalltalk, similar to how we code in ActionScript. It’s from the 1980’s, and boy does it feel like it. Anytime I start coding, I have Megadeth on in the background, my Pontiac Firebird Trans Am in the driveway does a turbo boost, and Fletch watches over me, commenting how it’s all ball bearings these days.

Foundation: Provides all the low level stuff you need and shouldn’t have to write yourself. This includes data types like NSNumber (vs using int/float yourself), sockets, etc. Basically, if you can’t see it in a GUI, the class is here. Everything is prefixed with “NS” for NextStep, one of the companies responsible for the early development.

UIKit: All your GUI controls including support classes. Things like UIButton, UIAcceleration, etc. The UI prefix stands for User Interface (duh). You’ll hear about references to Application Kit; that’s the desktop version.

Core Data: Basically the model layer of your apps. This is actually kind of cool, and what we should have in Flex (I know of 2 people who have tried to create an open source one, and then shortly thereafter abandoned the project… too bad too). Right now, there are things like it in LiveCycle, I believe, but only Enterprises can afford that, so its’ not for “everyday use”. Basically, you create ValueObject’s, and they can be persisted in local XML or SQL databases automatically, vs. you having to manually write Factories, parsers, and versioning. Pimp.

Xcode: The IDE that you code Objective C in. You can build & debug your iPhone/iPad applications directly from here.

Interface Builder: The IDE that you use to visually build your GUI apps. You can actually create variable & method definitions here, wire them up visually, and then have it code gen the classes for you. It can also read your header files (imagine if every ActionScript class had an interface class associated with it that defined what it did). As a n00b, I’ve found it really easy to confuse this program and make it explode. Also, someone forgot to add tab order when they made it.

Objective C

Objective C is the programming language you write your applications in. It is effectively an extension to ANSI C with Object Oriented syntax. In Flash and Flex, you utilize ActionScript 3. Objective C has a lot in common with C and C++, and some of the lamesauce as well, namely pointers. Objective C also has multiple environs it can run on while ActionScript runs in just the Flash Player.

If you know ActionScript 3, you can read C, and thus Objective C. Like Java, the type definitions are on the left instead of right, but other than that, they are extremely similar. Like another article mentioned, if C didn’t have pointers, PHP and C would be nearly the exact same. Since Objective C has a lot in common with C, they too are similar.

If you’re coding Objective C for the iPhone/iPad, you don’t get Garbage Collection, and have to manually get rid of your variables/objects. Once you get used to the syntax, it’s almost the exact same as cleaning up your mess in ActionScript. In ActionScript, you set your Object references to null; in Objective C it’s called nil. More on that insanity later.

You can read more here about here.

Yes, you code in Objective C 2, not 1. 1 is even more lame than 2 (thankfully?).

Objective C Syntax: Methods

Objective C has a lot of the same things that ActionScript 3 has. They both use the same bracket syntax, and have the same cuddled vs. not wars. They both end lines with semi-colons. There isn’t as much dot syntax. They both have methods. Here’s how you invoke one in ActionScript:

mySound.setVolume();

Here’s how you invoke it in Objective C:

[mySound setVolume];

Notice in Objective C, they use brackets to indicate the containment of a method call. You can nest these as well, but they recommend you only go 2 deep since it becomes un-readable after that.

Here’s ActionScript storing a return value:

volume = mySound.getVolume();

Here’s Objective C doing the same:

volume = [mySound getVolume];

Passing in parameters is a little different and takes some getting used to. This, to me, is the same thing that threw me off in Ruby, and where Objective C totally ignores how C does it. Here’s ActionScript:

mySound.setVolume(value);

And here’s Objective C:

[mySound setVolume:value];

Ok, not so bad… except, the 1st parameter is always the only one WITHOUT a named parameter. Observe the following ActionScript 3 function with 2 parameters:

mySound.setLeftAndRightPan(left, right);

…and Objective C:

[mySound setLeftAndRightPan:left, rightValue:right]

Notice there is no “leftValue:left” here, just left. The first parameter is always nameless, yet every one after it has one. I guess they wanted more obvious parameters during function invocations… except forgot to build in one for the 1st parameter. *face palm*

For example, here’s an ActionScript 3 function definition:

private function setLeftAndRightPan(left:Number=0, right:Number=0):void

Here’s the equivalent Objective C:

- (void)setLeftAndRightPan:(NSNumber*)left, right:(NSNumber*)rightValue

Notice 4 important things. First, the return type is in the beginning and wrapped in paranethesis (void in this case). Second, notice that Objective C doesn’t allow for default values for function parameters like ActionScript. Third, notice the type definitions for the function parameters are in the left side vs. the right (in this case NSNumber). We’ll get to the asterisk later. Fourth, notice the dash in the very beginning. That signifies that this is an instance method on the class. If you want ActionScript’s static, use + instead.

Objective C Syntax: Variables

Variables are slightly different because Objective C has pointers as well of built-in helper methods to make memory management easier.

Here’s a variable in ActionScript, first defined using a String literal (pimp syntax) and the old school way:

private var name:String = "";
private var name:String = new String();

And here’s one in Objective C:

NSString* name = [NSString string];

There are a ton of caveats here. Notice we’re calling the string method on NSString; it’s basically a factory method to give us a string; similar to going new String(). When I did “” above, it’s called a String literal; the same as going {} vs. new Object(), or [] vs. new Array(). In ActionScript, each of those constructors has nice features, the effect is the same; you get a variable of that type back.

Notice the asterisk in the Objective C example. This means it’s a pointer to the String, not the actual String. Also notice since we’re calling the string method on the NSString class, it’s autoreleasing (similar to the Doom spell in Final Fantasy; it’ll die soon; ie he’ll get ejected from the Pool soon, more on that later). If you want the guy be like Number 1 and live forever instead of a Rico’s Roughneck, go:

NSString* name = [[NSString alloc] init]

Just keep in mind you have to manually call release on him later whereas the former, you don’t.

Objective C Syntax: Pointers & Memory Management

Variables are different because of a couple reasons. First, since Objective C is based on C, it has all the pointer baggage. We ActionScript Developers are spoiled because we don’t have do deal with this… or if we do, it requires little thought.

For example, in ActionScript, there are only 3 variable types that are by value, and thus don’t have pointers: Strings, Numbers, and Booleans. Yes, I’m including int and uint as Numbers here. Every other construct is an Object, and thus is passed by val. If you wish for an Object based variable to be removed from memory eventually, you need to ensure no more references exist, or in the case of circular references, that no one else knows about the circular relationship (the Mark and Sweeper from the Garbage Collector will get those mofos). For Numbers, Strings, and Booleans who aren’t local variables, you just remove their parent Object, and they’re toast. For local variables, they go away at the end of the function (usually… depends on how aggressive the Garbage Collector is at that moment in time).

For Objects, you just remove all references, usually by setting them to null, or in the case of dynamic Objects like Dictionary or Object hash maps, using the delete keyword.

Objective C’s iPhone runtime, and ActionScript’s Flash Player both operate using reference counting. This means, for Objects, an internal number is incremented for every person who “knows” about an Object. When that person later set’s his reference to null, that reference count goes down. When that reference count reaches 0, it’s eligible for Garbage Collection. The Flash Player also has a Mark and Sweep part to take care of circular references in the case where 2 Objects know about each other, yet no one knows in your app knows about them, and thus their reference count will never reach zero. If you’re running on the iPhone, you don’t have Garbage Collection, so need to call release yourself (which calls dealloc internally). In ActionScript, you’d either null the reference out, or call your own destroy method, THEN null reference out.

Objective C has this built in as a method called dealloc. You don’t call, it gets called for you when you (or someone else) calls release. In ActionScript, people will either use a convention of public function destroy, or those fu@#(* IDestroy marker interfaces that people NEVER implement fully (did I mention that’s annoying?).

In ActionScript, for a complex class, it may look something like this:

public function destroy():void
{
	if(timer)
	{
		timer.removeEventListener(TimerEvent.TIMER, onTick);
		timer.stop();
		timer = null;
	}

	if(icon)
		icon.bitmapData.dispose();
}

In Objective C, this is built-in to NSObject, one of the main classes you often extend. The Objective C version of the above would look like:

-(void)dealloc
{
   [timer release]
   [icon release]
   [super dealloc]
}

As learn about how getter/setters are built into Objective C, you’ll see there is a better, and more common way to do the above (article I link to at the bottom describes this), but I need to get the point across here that you’re expected to clean up your own mess since Garbage Collection doesn’t exist, and everything can’t be an autorelease variable.

No Local Variables, Hence Autorelease & T3h Pool

In ActionScript, we have local variables. Basically, instead of storing it in memory, it’s stored in temporary memory that the stack is using (the stack of functions currently running). When one stack item is done (your function is done), those variables are removed. In ActionScript’s case, this isn’t immediate, but basically ensures that no one has references to those variables anymore. Later, Garbage Collection will come along and eat’ em.

Objective C doesn’t have local variables. Yes, I know, I’m face palming as well.

*deep breath* There IS a common way to deal with it. Your first thought may be to create a bunch of member variables; basically what game developers do for simple Object Pooling. That’s ghetto, though. You may think you could just create variables on the fly… the problem with that is you have to manually release them, and for return values, they’ll die before they get returned.

This is where autorelease comes in. Remember before when I talked about the 2 ways to create variables? Let’s revisit it, and show again how you kill things.

This creates a variable you must manually remove:

NSString* name = [[NSString alloc] init];
[name release];

… and she’s dead. However, here’s one that’ll be added to a pool, or rather “a Pool”:

NSString* name = [NSString string];

This is the same as doing:

NSString* name = [[NSString alloc] init];
[name autorelease];

You can then safely return these variables from functions, knowing that the caller will get it. It’s also considered good practice to do, specifically for encapsulation. There isn’t really a language construct to say “Hey dude, this guy is going to send you a variable it also has a pointer to, so please make sure you call his release first”. Crap like that is insane; it’s just easier to get either copy’s of variables so you don’t inherit their pointer baggage, or use autorelease so you don’t piss off people getting variables from you, and causing leaks if they forget to kill you first.

Yes, all of that above is a shortened version of what you have to do because there are no local variables. Yes, I’m face palming again.

If you’re curious about what this Pool is, imagine if a static class was created every time you ran some code.. and Garbage Collection ran immediately when you null’ed out your variables. The first thing it did was keep a reference to any variable that has autorelease on it. Then, 1 frame after the stack has been complete (all your code has run, and the next enter frame runs), it kills all the variables it has stored. That’s the AS version of what an Objective C Pool is.

Conclusions

This sucks. I blame Adobe AND Macromedia for my suffering.

BTW, if you’re looking for some pimp tutorials to learn this stuff, my compadre Brian linked me to it, called “Cocoa Dev Central“, specifically this article.