Some of these ideas are great, many are not. But regardless of their quality, I want to try to reset the expectations of the idea generators. I hope this post sheds some light on the legal, social and practical implications of these ideas and provides some ground rules that will help bring these ideas into fruition.

(Read the full article after the jump)

First of all

If your idea includes the words “like [a social network] but better” stop right there. I had an idea for a car that’s like a Ferrari but it’s twice as fast gets 1,000 miles per gallon! Fuck you.

The value of your idea

Great achievements come from great ideas. Most of the time, however, people are all too willing to start planning their retirement before the thought of a business plan ever crosses their minds. Making an app can cost a lot of time and money and there’s lots of competition. Most don’t sell well after their first month. While it’s true that you can make a million, it doesn’t happen every day.

In reality, your idea is probably worth a great deal less than $1,000,000. In fact, it’s probably worth very close to $0. Why? For one thing, can you even reasonably define what an idea is? For example, If you have a $1M idea but I have an idea that makes your better, how much is mine worth? What if 5 other people had that idea independently? (Even Calculus was discovered by at least two mathematicians working separately and they drew from centuries of previous concepts.) So the answer is simply this: ideas (even good ones) are worth nothing until they’re turned into something.

The good news, how ideas are implemented is at least as important as the intial idea. Google didn’t invent the search engine, they just made it better. That means that you don’t even need a new idea to make a million (or 189 billion)! There’s always room for improvement. The App Store is full of garbage apps that could be made better.

Release early, Release often

If you’ve had an idea, great! Me too. Keep having them. Have as many as you can. Write them all down. Take the best ones and make them!

Any photographer will tell you that for every 100 photos you take you’ll be lucky if you get one good one. Ideas are the same way. I have a long list of ideas for apps, games, products, etc. that I maintain and regularly review. A couple are (I think) really good. Some are good but would require a huge amount of work to execute. Most of them, over time, seem so stupid as to make me wonder what the hell I was thinking. The important thing is that I have lots and lots of them and I recognize that they all need work.

To continue with the analogy of photographs, if you leave them as negatives or let them just sit on your camera card, you might as well not have bothered. Ideas are the same way. They need to be developed into something tangible to be worth anything.

Who owns your idea?

If you think your idea is something you own that people want to take, you’ve got it backwards. You don’t own the idea and people are free to take it but they don’t want to.

Now I’m not a lawyer (and this is not intended as legal advice) but if I’m not mistaken, unless you have made an agreement to the contrary, an idea alone cannot be copyrighted or trademarked. These protections are reserved for “things” that exist in the world. Even a unique concept carefully described in writing is little evidence when faced with a solid, working app. Think about it. If it were not true wouldn’t that mean science fiction writers could sue technology companies for stealing their ideas for robots, spaceships, etc.

Does that mean you shouldn’t tell anyone? Not necessarily. In reality, most people are not interested in stealing your idea and if they are, they still have to make something out of it. I can’t think of anyone who’s got the talent and capital and drive to build something great who is just waiting around for someone to slip up and hand him a genius idea. So you’re probably safe to talk about it. In fact, you’ll probably find it helpful to get other’s input.

If the idea of sharing still makes you nervous you can always use a non-disclosure agreement. You can find many examples online.

The right way to do it

Despite everything I’ve said, I don’t want people to stop contacting me with their ideas. I just want to set the level of expectation back to a reasonable level. Here’s a checklist for you potential idea-havers:

• Lower your expectations. This is the crux of the whole article. Put the concept of the million dollar idea out of your head and think about how to build a million dollar company.
• Develop your idea. Take your idea and make it better. Find out who your competitors are. Spend some time researching, designing, polishing. In other words, turn your idea into a plan that you can use to build.
• Make yourself useful. If you think you deserve 50%, you better be ready to do 50% of the work. That means writing business plans, fundraising, designing the interface, hiring a team, or doing whatever it is you can to make it happen.
• Respect other people’s professions.Building an app or website is hard. It can take months or years of man-hours. You wouldn’t expect a carpenter friend to say yes to building a new restaurant in exchange for 50% of the sales. But he might if you had blueprints, a star chef, and $500,000! See the difference?
• Don’t stop sharing your idea Ask for feedback. Try not to take it personally if you don’t like what you hear.

The last thing I have to say is a note to myself: Take your own advice. Stop talking about it and go make some $1,000,000 apps and things!

P.S.

During the writing of this article, I was trying to do some research into the copyrights of ideas themselves and found a couple of great articles on the same topic by Pek Pongpet so apparently I’m not alone.

The myth of people stealing your ideas

I’ve got this great idea if you only build it

The problem:

You’re positive that you just upgraded to the Debug version of the Flash Player, when you go to test it in Chrome it says that you don’t have the debug version even though it works fine in Firefox, Safari, Opera, and who cares if it’s working in IE because you would never use IE right?

The solution:

You can reinstall the player until you’re blue in the face but it won’t help. Why? Chrome manages it’s own version copy of the player so it can provide automatic updates. You’ll want to disable this version and use your default one.

Open up your Preferences in Chrome. Go to Preferences > Under the Hood > Privacy > Content Settings… > Plug-ins > Disable Individual Plugins (Or just paste chrome://plugins/ into the address bar).

You should see a plug in called Flash. If you click the Details+ button in the top right, you’ll see more info about the plug-in files themselves. You’ll probably see two versions here; one will point to the plug-in installed by Chrome

e.g. /Applications/Google Chrome.app/Contents/Versions/15.0.874.92/Google Chrome Framework.framework/Internet Plug-Ins/Flash Player Plugin for Chrome.plugin

The other points to the system folder

e.g. /Library/Internet Plug-Ins/Flash Player.plugin if you’re on a Mac

Disable the one in the Google Chrome folder and you should be good to go!

This information was originally provided to me via Arron West’s blog which has more pictures than this post if you still need help.

Now, I wouldn’t really recommend using this code in a project. There are ways to do the same thing that are much more readable and less error prone. Instead, I thought it was an interesting experiment to show off some of how AS3′s syntax works for those of you who may not have seen something like this.

What’s happening here? Let’s break it down.

• ["Alpha", "Bravo", "Charlie"] – Here we are instantiating a new array and populating it with three strings. This is essentially the same as:

  var a:Array = new Array();
  a[0] = "Alpha";
  a[1] = "Bravo";
  a[2] = "Charlie";
  

• [...] – next is another pair of square brackets. This is an array access operator. In other words, everything between the two brackets will be evaluated as the index of the array to retrieve.
• int(...) – This is an explicit type-cast to an int. That means that everything inside those parentheses is evaluated and flash attempts to convert from whatever data type it is to an integer. In the case of decimal numbers, they are rounded down so this is similar to using Math.floor().
• Math.random() * 3 – random() of course produces a random floating point (decimal) number between 0.0 and (almost but not quite) 1.0. Multiplying that number by 3 (the length of the array) produces a number between 0.0 and 3.0 (technically, between 0 and 2.99999999etc).

The result, an array is created with three strings, a random number between 0.0 and (almost) 3.0 is generated, it is rounded down to an int between 0 and 2, that number is used as the index of the array to look up. The result will be randomly one of the three strings.

I hope you found this interesting!

What followed was the discovery/invention of just such a thing, a nested, super-verbose function. The function achieves this by returning an instance of an internal class with nothing in it except for the next step in the chain.

package
{
	public class Bind
	{
		public static function updateProperty(object:Object, property:String):BindSource {
			return new BindSource(object, property);
		}
	}
}
import mx.binding.utils.BindingUtils;
class BindSource {

	private var targetObject:Object;
	private var targetProperty:String;

	public function BindSource(targetObject:Object, targetProperty:String):void {
		this.targetObject = targetObject;
		this.targetProperty = targetProperty;
	} 

	public function whenSourcePropertyChanges(object:Object, property:String):void {
		BindingUtils.bindProperty(targetObject, targetProperty, object, property);
	}
}

To call this function you would use:

Bind.updateProperty(foo, "bar").whenSourcePropertyChanges(baz, "bar");

Kinda cool! I soon realized that this technique has some characteristics that Objective-C messages don’t have. For example, each step can use more than one parameter (plus they each get their own code hinting). You can also provide multiple choices for what to do next providing a sort of branching behavior.

AngleFinder.getAngleOfVector(4, 4).inDegrees() 	// 45°
AngleFinder.getAngleOfVector(4, 4).inRadians() 	// π/4

You can even do free-form stacking of functions like this.

new Calculator	(5)                    // 5
                        .plus(3)            // 8
                        .times(2)          // 16
                        .dividedBy(4)   // 4
                        .minus(1)         // 3
                        .plus(2)            // 5
                        .equals();

I proudly named these “Matryoshka Functions” after the Russian stacking dolls even though I’m sure I’m not the first to try something like this. As it turns out, they’re about 10% practical and 90% clever hack. Even though there could be some potential use for this (especially with complicated, repetitive tasks), this technique conflicts too much with the way we normally code in ActionScript. Still, I thought it was cool enough to share with everyone.

Pros:

• Very descriptive
• Branching and stacking effect is interesting and potentially useful
• Code hinting shows the next step in the function as well as the parameter names
• Looks cool!

Cons:

• Abominable code style. Too weird to be useful.
• Difficult to know when to stop calling functions
• Not completing the function will produce unexpected results with no compile-time errors
• Each step requires you to pass the parameters from the previous step

Can you find any use of these? Can you think of a more efficient way to write the functions? Any other thoughts?

Check out the source with multiple examples (FlashBuilder project).
MatroshkaFunctionDemo

Turning a DisplayObject into a 3D DisplayObject is as simple as assigning a value to its rotationX, rotationY, rotationZ, or z properties. But how do you turn it back? I tried giving all these properties a value of 0, but after their animations completed they were already 0. An object at z=0 still renders in 3D, using bitmap caching. Setting these values to NaN was no better.

The solution I found is to null out the 3D transformation matrix and assign a 2D transformation matrix. This can be accomplished like so for a DisplayObject named sprite:

var matrix:Matrix = new Matrix();
matrix.translate(sprite.x, sprite.y);
matrix.rotate(sprite.rotationZ);
sprite.transform.matrix3D = null;
sprite.transform.matrix = matrix;

In this code I simply drop the transformations that are inapplicable to 2D space. This is fine when your object is already coplanar with the stage.

Anyway, quick tip if this ever had you scratching your head too.

Interfaces are amazing things. When I was young and green, I didn’t understand their purpose, but after working with them for a while, I will defend their use to the end. I try to create lots of interfaces early on in my projects and I find that by keeping things flexible, it saves more time despite the extra typing, pardon the double entendre.

But this is not an article about why interfaces are so great. No, this is an article about the mysterious gap in the Flash Player API with regards to an interface for DisplayObjects. If you have a class typed as something like IView, there’s no way to enure that IView can be a parameter of display list functions like addChild().

Why can’t we guarantee that something is a DisplayObject through interfaces? There is a practical answer. The inner workings of the Flash Player are slowing unfolding to us with each version. We now have low level access to sound, byte streams, and text rendering. However, the display list still relies exclusively on one of the only truly abstract classes in ActionScript 3.0, the DisplayObject. Because a low-level drawing engine is not exposed to AS3 programmers, we don’t know how it works and we cannot guarantee through an interface that an arbitrary class can be drawn.

Fortunately, there are some workarounds that can help, each with their own strengths and weaknesses. Personally, I think #2 is the way to go. It’s practically dripping with polymorphic goodness.

1. Make your interface inherit from IBitmapDrawable and IEventDispatcher

   DisplayObject is the only class that uses both of these two interfaces so by combining them in your interface, you can sort of be sure you’re working with a DisplayObject. Still, this is my least favorite solution

   Pros:

   • Uses interfaces exclusively.
   • Only a DisplayObject would implement both of these.

   Cons:

   • There’s nothing to stop you from using this to create a class that isn’t a DisplayObject and that could cause problems.
   • You would still have to type cast to DisplayObject to use this as an argument for addChild().

2. Create an interface that exposes a method to return the object as a DisplayObject

   My personal favorite solution. It not only solves the problem of guaranteeing that a class can go in the display list, it doesn’t even require that the class be a DisplayObject.

   Here’s an example of what this would look like. IDisplayObject.as

   Pros:

   • Flexible solution that conforms to good OOD principles.
   • Uses interfaces exclusively.
   • Easy to apply. You can usually implement it with a single line of code: return this;

   Cons:

   • Requires you to use asDisplayObject() every time you want to use the object as a DisplayObject.
   • Calling foo.asDisplayObject() would throw an exception if foo was null so additional checks may be necessary.

3. Use an abstract class that inherits from DisplayObject

   Not an ideal solution primarily because Flash doesn’t have true abstract classes (although there are workarounds) but still totally valid.

   Pros:

   • Guarantees that the object is a DisplayObject. No type casting required.
   • Abstract classes can be treated virtually the same as an interface for practical use.

   Cons:

   • No true abstract classes in Flash.
   • Not as flexible as an interface-based solution since it forces you to inherit from DisplayObject.

By the way, even though I attend conferences for programmers, I believe these guidelines are good for any conference attendee.

1. Talk to people

   When you break it down, the whole reason to go to conferences is to talk to people. The sessions are good too but I tend to find satisfaction from them only about 50% of the time. People are why I’m there. Don’t be surprised if people aren’t rushing up to talk to you, especially if you’re attending a conference with lots of programmers. Make an effort to approach people and start the dialogue. It doesn’t have to be fancy. You can literally walk up to a stranger and say “Hi. My name is Mims. How’s it going?” and you’re doing it.

2. Know your story

   You’re going to get a lot of chances to tell people about yourself, your company, your projects, and your brand so make sure you know what you’re going to say when someone asks you. There’s a good chance that you’ll be speaking to your industry heroes which can feel very intimidating. Know your own story and be able to communicate it concisely and confidently even if in you’re head you’re thinking “I’m not worthy.” Keep it short and positive.

3. Be interesting

   In other words, have good conversation skills. Of course, this is easier said than done for most people. But even YOU can be interesting with a couple of little tricks. Aside from telling your story, ask them about their story. It’s mysterious but true, asking people about themselves makes you seem more interesting! Furthermore, someone wiser than me once said that if you want to find success, ask your clients what’s keeping them up at night then tailor your service to help them solve the problem. Asking about what’s been inspiring them at the conference is good too because it’s usually something they’re excited to discuss and there’s a slim chance they’ll accidentally tell you their million dollar idea.

   Also, don’t talk forever, just say “Hey, great meeting you. I’ll check out your stuff.” and you’re done. You don’t have to wait for an awkward silence, you can end it on a high note.

4. Bring lots of business cards

   Your card reminds the people you talk to of the conversation you had with them and tells them how to find out more about you. That’s really it. You can make really flashy, expensive cards but printing them on your inkjet works just as well in my opinion. What doesn’t work is when you don’t have one. They’ll go faster than you think so bring a bunch.

   Also, when you trade cards, you can write a note on the back of your card about the project you discussed and do the same for yourself when you receive a card from them.

5. Not a vacation

   It can be tempting to get drunk every night, or blow off sessions, or even to see some sights while you’re away at a conference. I’m not saying you shouldn’t have fun and I’m definitely not saying you shouldn’t have drinks with your industry colleagues. Just remember that you (or your company) are paying a lot for you to be there and every minute is an opportunity to learn something or make a connection with a new client, employee or friend.

   

6. Do some research about the speakers / topics / sponsors

   Obviously, it’s a good idea to review the schedule to see which sessions you may want to attend. It can also be good to do a quick background check on the companies that will be speaking. A quick visit to their website will do usually and you may discover that they did some work you really admire. Chances are, they did or they wouldn’t be speaking. If the schedule is too overwhelming, you can always bring the program home and research retroactively.

7. If a talk is bad, it’s okay to leave

   Unless it would be an obvious or odious disturbance to the session, there’s no rule that says you have to sit through a boring or irrelevant session. Duck out respectfully and go into another session or just mingle in the hallway.

   

8. Attend some sessions that aren’t targeted at you

   I’ve found that some of the most interesting talks at conferences are ones aimed at other jobs. It’s eye-opening to see what business-people, project managers, and programmers from other languages are talking about.

9. Use Twitter

   Like it or not, at a conference, Twitter is the little bird that tells you what’s happening all around you – what talks are worth attending, what news is being announced, where the party is at, and who you need to talk to. Using and watching hashtags suddenly makes your tweets visible to people who otherwise wouldn’t see you and vice versa. I meet lots of strangers through twitter at conferences. For example, this year I had lunch with the cool dudes at Tribal Games who I met simply because they tweeted “going to lunch, who wants to go?” An icon that shows your face helps too – I recognize a lot of people from their icons! Finally, if you don’t have separate accounts, try not to twitter about your personal life at the conference.

10. Don’t waste the momentum

    You’re going to meet people, see new things, and be inspired on multiple fronts. When you get home, do something with all of that good energy immediately. If you just go back to your routine of clients, meetings and daily bullshit, it’s going to go away.

But resource bundles can’t help you in every scenario. I often find myself needing to construct a sentence with live data inserted. For this, the resource strings are less helpful. For example, how would you write:

"At " + time + ", you received a message from " + userName + "."

With resource strings, you would have to do something like

at=At
message=, you received a message from
period=.

Which completely negates the whole point of using resource bundles. What to do?

Token replacement

What I really wanted was a way to inject data into the string. I’ve seen this done by use of tokens in other languages like Objective-C so I thought I’d give it a try. The result was surprisingly lightweight.

I created this utility that lets you use tokens (delimited by % signs) that can be replaced by live data when you retrieve the resource. Using this class, the example above would look more like this:

receivedMessage=At %time%, you received a message from %userName%.

// then in your code
trace(ResourceStringUtil.getResoureceStringWithTokens("receivedMessage", {time: "11:49", userName: "Mims"}));

// displays
At 11:49, you received a message from Mims.

Here’s the source code Feel free to use it and modify it for your purposes.

Now that you’ve been through 3 exhaustive tutorials on ant for flex, it’s time to use your knowledge you’ve gained to turn your back on the built-in Flex compiler and switch to ant for your builds. This part applies to FlexBuilder (and FlashBuilder) users only although it may apply if you’re using some other eclipse-based plugin. If you’re using another program like TextMate or Flash CSx, you can skip this article.

Replacing the default builder with your ant tasks

The rest of this article will show you how to use your ant build script to perform the building actions found in FlashBuilder.

In FlashBuilder, the following building actions can be executed

• Build Project – Occurs when the user manually builds the project.
• Build Automatically – When the option is checked in the Project menu, the code is automatically build when you save a file. Usually incrementally.
• Clean – ‘cleans’ the project folder by doing a complete, non-incremental build and removing temporary files.

These actions are all called by various actions and handled by one or more builders. In terms of the eclipse SDK, a builder is an XML file that describes how the various build actions will be executed. In FlashBuilder, all of these are set up to use the Flex “builder” by default. You can add new customized builders to supplement these build actions. You can also deactivate the default builder an just use your ant builds instead but you will lose the ability to see inline errors in your code.

In order for this to work however, you need to start out with some solid, well-tested ant tasks.

Step 1 – Create the appropriate ant targets

Create a target in your build.xml for each of the actions listed above. Call each target “build”, “autoBuild”, and “clean”. You can probably start with the “build” target and reuse it for the other two. To write an incremental build target (used for the build-automatically action) there is an example in Part 2 of this article.

Before moving on, please test your build script thoroughly to be sure there are no errors and that your files are compiling correctly.

Note, I’m not going to go into the details here about exactly how to write your ant script. If you’re considering switching to ant as your primary builder then A) your project has special needs that need to be addressed by a custom build script and I don’t know what those needs are and B) you need to know what you’re doing with ant before completely abandoning FlashBuilder’s defaults. I will say, save the fancy stuff for your release build targets and do incremental builds by default since you’ll be running these scripts quite a lot.

Step 2 – Create a builder for your ant build script

1. Open the properties for the project you want to edit. Project -> Properties
2. Select the Builders item in the left menu. You will see that the default builder “Flex” is already set up.
3. Click the New… button. A dialog will come up with templates for the new builder.
4. Choose the “Program” type. (On my configuration, I see an option for “Ant Builder” also which is what I should probably be using, however, I haven’t gotten it to work yet and it doesn’t seem to generate any specific errors when it fails so I gave up and went with Program. If you know how to fix this, let me know!)
5. Name the builder “flexAntBuilder”
6. Set the location field to the ant binary you’re using. If you’re not sure where the binary is located, you can use the command which ant in the command line. Mine is at /usr/bin/ant
7. Set the Working directory to your project’s home directory. If you’re not sure, browse to it.
8. In the arguments field, enter the name of the target you want to run. In this case build.
9. Optional: Click on the Refresh tab. Here you can chose whether to refresh the files in your workspace when the build completes.
10. Click on the Build Options tab. Here, under the “Run the Builder:” heading near the bottom, is where you’re going to set the properties that determine when this particular task is run. For the ‘build’ target, uncheck everything except “During Manual Builds”.
    • For your “autoBuild” target, you’re going to uncheck everything except “During auto builds”
    • For your “clean” target, you’re going to uncheck everything except “After a clean”
11. Repeat steps 1-10 for the other two targets.
12. When all targets are added, optionally uncheck the “flex” builder from the builders menu in your project properties to use the ant tasks exclusively. Now your ant scripts will be used instead of the flex builder.

That’s it! Be sure to test things and make sure you’re not getting any errors.

What to expect from here

So you’ve unchained yourself from the system and are using your ant scripts to build your project. Congratulations, you’re a huge nerd! From this point on, changing the compile settings in the Project Properties dialog (like the build path) may be ineffective. You’ll need to make changes to your build path in the ant file.

The results from your builds will appear in the Console view. Here you can see the progress of builds and check for errors in the code. As I mentioned before, if you deactivate the flex builder you won’t get inline errors in your code any longer.

Finally, adding the new builders will create a new invisible folder in your project’s root folder called .externalToolBuilders where your builder definitions will be kept. You don’t need to do anything with this folder, but be aware that it’s there.

That concludes this 4 part epic post about ant tasks for flex! I hope you found it useful. If you have anything to add, please post comments!

This third installment talks about tips and tricks for using ant with version control systems.

Defining external properties for each user

Since not everyone’s machine is the same and letting everyone build a project is a major reason to use ant, it’s good to avoid hard coding paths to files within your build.xml file. As such, I use a lot of <property> tags to set up paths and such. But you also don’t want to have several people constantly editing your build.xml because it could get broken or out of sync. Oh no! What do we do!?

Luckily, ant lets you define a set of properties in an external file. This is a simple text file containing name=value pairs and commented using #. By default, the recommended filename is build.properties. Here’s an example:

build.properties and version control

If you’re working with multiple people, you are probably using a version control system like svn. If you are and you want to avoid people accidentally checking in a build.properties file there are a couple of simple tricks. First, create a copy of build.properties and call it built.properties.template and check that into the repository. Then each user can make a local copy called build.properties. You can also add build.properties to the ignore list for your folder using SVN so that noone will accidentally check it in. Run svn pe svn:ignore and add build.properties to the list. Finally, if you need to make sure that your users have a local copy of build.properties, there’s a task for that!â„¢

Adding SVN tasks

As I work with SVN quite a lot, I found that including SVN in my builds can be quite useful. For example you could:

• Update your working copy when doing a clean build.
• Check in a release build automatically.
• Export your source code without those pesky .svn files to be included in a zip file.
• Include the revision number of the working copy as a constant definition in the code using conditional compiliation.

To do this, you’ll need to first download the SVN tasks for ant. They can be found on the Tigris.org website. Please note, that these tasks are a part of SubClipse, which is a free interface for working with Subversion from within Eclipse. I don’t know if the tasks will work without subclispe, but if you haven’t used it, I’d definitely recommend trying it out anyway. By the way, if you use CVS, there are already tasks included in ant. Once they’re downloaded, add the task .jars to the libs/ant folder in your project. You’ll need to use another <typedef> tag in your build script to get these to work. Here’s an example snippet that simply runs an update on the working copy. You can see all the available commands in the svnant documentation.

That’s it for part 3. In Part 4, I’ll talk about setting up a builder for your ant file in FlashBuilder.

In this part, I get more nitty-gritty about working with flex’s ant tasks.

Using the flex ant tasks

I spent quite a lot of time making tweaks to get my scripts to use the Flex tasks and hopefully, now you won’t have to. In the end, there’s very little benefit to using the official Flex ant tasks over using a generic <exec> task (a type of ant task that simply runs an executable file with nested <arg> tags for command line arguments) and if you’re having trouble with them, I’d recommend abandoning the flex tasks and using $lt;exec>. The main thing I had trouble with was getting the <taskdef> tag to work correctly.

For those new to ant, a <taskdef> tag is a required tag that defines a third-party ant task within the build.xml file. It associates a task name with a .jar file (compiled from the java code for the task). In the case of flex tasks, the java file is typically located within your flexbuilder sdk directory. On my mac, that’s here:

/Applications/Adobe\ Flash\ Builder\ Plug-in\ Beta\ 2/sdks/${SDK_VERSION}/ant/lib

Where ${SDK_VERSION} is your target sdk version (e.g. 4.0.0). There are a few ways to load additional tasks into your build.xml file. All of them require you to reference the .jar’s location somehow and then define a new task using <taskdef>.

1. Copy the .jar file for the task into ant’s lib directory. I don’t personally like this option because it makes it very difficult to switch between different versions of the sdk. Also, it requires all users of the script to copy the files on their local machines. (You can also add it to ~/.ant/lib to control the libraries on a user level)
2. Reference the .jar file’s location using a command line argument -lib. Even worse than the first option since it requires each user to add the library manually every time the build script is run.
3. Include the .jar’s location inside the build script. It took me a long time to figure this one out since I didn’t see it in the manual for ant, but it’s certainly my preferred method for adding tasks. It allows you to keep everything self contained within the build.xml so changing the location of the .jar is as simple as setting a property in the build script.

When using the 3rd option, you then have the question of where is the best place to put the .jar files you want to link to. There are two options that make sense to me.

1. The best place to put non-core tasks required by your build (for a Flex project) is in ${project_home}/libs/ant. This allows you to check your tasks into a repository along with your other referenced files (like .swc files).
2. Optionally, for the flex tasks you could reference the .jar file directly in the sdk folder. Use this option if the version number of the SDK doesn’t matter. If it does matter, use the first option. I use this option in my snippet below.

Linking to the official Flex ant tasks

Here’s a sample of my flex task definition along with some path definitions that point to various parts of Flex. I said this was a no B.S. guide so if you paste this snippet into your build script, you should be able to use the Flex tasks.

Using the tasks

Now we have the <typedef> in place and we can actually create a task to compile something. Again, I’m not going to go into all the details of what targets are all about or go into all the details about the flex compilers. There are plenty of other tutorials about that. Instead, I’ll show you a basic target to build an mxml file that is adequate for 95% of projects. Note: you may need to edit the properties defined in these scripts so that they point to the right paths for your project.

The toughest part about using these tasks is the seemingly arbitrary words that they expect for the attribute names of some tags (like using path-element in the <source-path> tag but dir in the <library-path> tag). Now the same but this time building a library SWC.

Making an incremental build

By default, FlexBuilder uses incremental builds when compiling your source code (except for clean builds). This is a very useful feature of the compiler because it saves time by only compiling the parts of your code that have changed since the last build. You can create an incremental build simply using ant by defining a second task that adds a flag for incremental building like so. Note that allows you to run other targets from within a target.

What about ASDocs?

Even though there are tasks for asc, compc, mxmlc, and generating HTML wrappers, they didn’t bother to include an asdoc task (actually, they did in Flex SDK 4.0.0). But that’s okay! As I hinted at earlier, you can still use the task to run this (as you can for all the other commands) and not only that, it’s way easier to set up than the official flex tasks! In fact, the only reason that I can think of to use the flex tasks is that they would automatically use the windows or mac version of the executable depending on your platform. Here’s an example for asdoc.

That concludes part 2. In Part 3, I’ll talk about working with version control systems in ant.

After spending hours wrangling with my ant build script and finally making everything work correctly, I am convinced of two things:

1. ant is a very powerful tool for compiling code but it can also do so much more.
2. The support for ant for flex online is abysmally frustrating.

So, I’d love to share with you some of the tips I’ve picked up after tweaking my script to the point where it finally worked!

Introducing ant

First of all, let me introduce the basics of what ant is. I couldn’t really say it better than the thousands of nameless editors of WikiPedia.

Apache Ant is a software tool for automating software build processes. It is similar to Make but is implemented using the Java language, requires the Java platform, and is best suited to building Java projects.

The most immediately noticeable difference between Ant and Make is that Ant uses XML to describe the build process and its dependencies, whereas Make has its Makefile format. By default the XML file is named build.xml.

Ant is an Apache project. It is open source software, and is released under the Apache Software License.

So in short, ant lets you use an XML based script to run a series of commands typically used to build software projects. It was originally designed to be “for Java, in Java” but it’s popularity and ease of use has created interest beyond the Java community. For flex, ant can be used for compiling ActionScript and Flex projects into SWFs, creating SWC files, generating documentation with ASDocs, and other actions associated with compiling.

There are a lot of great tutorials online that can cover the basics of how ant works so I’m not going to go into a general overview in this article. Instead, I’m going to try to focus on some of the practical aspects of getting a build set up when working with Flex. However, here are some links to the official ant documentation some helpful tutorials for the basics:

Ant Basics tutorial

Another basics tutorial (this time for Flex)

Official Flex documentations

Ant Folklore

After the jump, I’ll get into some of the ways that ant can be useful for Flash and Flex projects.

Applications for Flex users

Is ant right for you? It depends. For most cases, using the standard Run and Debug functions in FlashBuilder or Flash will be completely sufficient. However, if you work on a large development team or on a project with a complicated build process, it might save the group a lot of headache. Here’s a list of situations where I think Flex ant tasks can be helpful.

• Whenever your project requires you to make adjustments to the standard build process. For example, when you need to add additional flags to your compiler string.
• For Flex projects that are distributed widely, e.g. open source projects, where the configuration of the users’ dev environment is unknown. Build scripts allow users of various versions of FlexBuilder, FDT, or Flex SDK users on different operating systems to all be able to compile a project with more or less the same settings.
• If running or building your project requires you to configure options in the command line or to run a local server.
• For building release versions of an app and for deploying your app. For example, compiling, zipping and copying an app to a server using FTP.
• When you’re a total nerd and you want to use ant just so you can say you did it.

Beyond Compiling

One of the main benefits of using ant is that I think many people are unaware of is that it can be used for many things beyond running compilers. For example, in KitchenSync, I use a build script to create a temp folder, compile a SWC file into the temp folder, create an SVN export of the source folder into the temp folder, zip the source and SWC and name it with the current version number, then delete the temp folder.

There are loads of core tasks that are already defined within the ant library. They handle all types of common actions in the command line. There are even additional optional tasks that add higher-level functionality like copying files to a server using SSH or validating an XML file. Finally, additional tasks can be added simply by creating a new Java class that is a subclass of org.apache.tools.ant.Task. You probably won’t do this yourself, but there are a number of third-party programs that have created ‘plug-in’ tasks for ant such as SVN.

Once Flex projects became larger and more complex, many users began to look for more customizable options and began using ant. A couple of years back, Adobe released some official ant tasks which can now be found bundled in every version of the Flex SDK. However, as I said before the documentation of exactly how to get these tasks running is vague at best.

In part 2, I’ll talk about the details of getting flex ant tasks running.

• Part 1
• Part 2
• Part 3
• Part 4

XML-Schema (.XSD extension) are documents used to describe the format of XML files. They are similar to DTD (Document type declaration) files but much more powerful.

While working on some XML documents for a Flash site, I stumbled across the XML-Schema editor for Eclipse. The editor shows the XSD as a graphical representation of the model that you’re editing that looks similar to a UML class diagram.

Here’s a great article on how it works.

Benefits of using XSD

As I said, XSD allows you to define the format of your XML document but with much more detail that DTD.

• XSD allows you to type your data (integers, strings, booleans) so that you can better predict what format the xml will be
• It allows the creation of custom types which gives it an object oriented aspect
• You can use all kinds of restrictions for what kind of content can appear within a tag including the number of elements, whether values are required or not, you can even use regular expressions to limit the acceptable values. This is very nice when you’re working with a 3rd party who is generating the XML data.
• Using an XSD file can allow you to automate the validation of an XML file’s format

Once you’ve created your XSD file, you can use the new XML document wizard to create an XML file that links to your schema file. The wizard will automatically populate the XML document with valid data! Furthermore, as you edit the XML file you will get warnings and errors if you go outside the formatting requirements defined in the XSD. For example, if you define a tag <description> as having a maximum length of 128, you will see a visual error if your tag contains more than 128 characters. It’s a great way to forsee problems as you write them.

I hope in the future to write some kind of tool to parse XML based on an XSD file in flash. Apparently, Adobe had created an undocumented Flex feature to validate XML against XSD. Via Misprintt

Installing the XML extensions

Unfortunately, the editor is not installed by default and nstalling software in Eclipse is not very intuitive. I’ve done my best to describe the process here but if you need further help, check this entry.

1. Open Eclipse or FlexBuilder
2. Go to Help>Software Updates… ( > Find and Install for Eclipse 3.3)
   
3. Make sure you have the Europa or Ganymede update sites in the list of update sites:

   Eclipse 3.4 users:
   http://download.eclipse.org/releases/ganymede/
   
   http://download.eclipse.org/releases/europa/site.xml

4. Select the XML and XSD extensions in this screenshot. In Eclipse 3.4 you can search for them, in 3.3 you will have to look through the packages for them manually.
5. Restart Eclipse after the install is complete