(above: Joshua Davis doing the very last session of the conference.)

Here's how it works: 'Organisms' (the colored moving squares) are thrown into an infrastructure (a collection of connected points, i.e. the circle/star with connected dots). Each organism is assigned a certain destination-point within the infrastructure and carries with it a pathfinder (a polished version of the algorithm I posted about some time ago).

The pathfinder will figure out which points to travel (trial and error, guessing together a route to the assigned destination, see previous post) in order to reach the destination and will then tell its organism where to go.

When two organisms happen to travel the same connection (line between two points in an infrastructure) they will share and compare their knowledge about several of the paths they have traveled, this is visualised by both organisms becoming semi-transparent.

Here's the rough guide to having spaces in your Flex Builder Actionscript-only project-names:

Kind of leaves me wondering, why all the fuss in the project-wizard if we can rename our projects in the navigator?

A few days later however, I concluded that it was not so much Flex 3 that was causing this issue, but rather Subversion.

Whenever I commited my changes to the Subversion-repository, the latest run-files (Main.swf and Main.html) from the bin-debug-folder on my harddisk would be commited to the html-template-folder in the repository.
As the html-template-folder serves as a template-depot (duh) for your Flex project, any files in it will be copied to the bin-debug-folder after compilation, effectively overwriting your freshly compiled SWF in this scenario.

Initially, this may go by unnoticed, as it will not be untill you update your project (or do a new checkout of the same project), that the run-files will be in the html-template-folder.

I work around this issue by commiting, updating, and removing the run-files from the html-template-folder, but I have yet to come across a proper solution for this problem. So any suggestions are more than welcome. The same goes for any explanation about this strange issue with Subversion..

UPDATE:Through the comments someone exlained where this issue is coming from, here's a quote:

"your bin, bin-debug and html-template directories should *NOT* be committed to svn.

The problem you are having is that it’s copying all of the files in the html-template folder into the bin-debug folder, including the .svn hidden folder. SVN uses the .svn folder to determine where to put the files in the repository, so when you copy that folder, even though it’s in a different folder than when it started, the files will continue to be copied into the original location."

UPDATE: ..also, if you would like to keep these folders in your SVN-repository nevertheless, here's what you'll need to do (credits go to Matthew for this one):

"Goto your project properties and pull up the Flex Compiler tab and the first checkbox you should see says somethign to the effect of “Copy non-embedded files to the output directory”, well uncheck that. This will allow you to keep your bin folders in the repo"

I might've also have called this post "How many more times will I have to re-import my projects into Flex Builder 3!?", this sucks..

Today I decided to work on a project of mine, so I pulled in the latest version from my Subversion-repository and opened up Flex Builder 3.
I started making some additions in classes etc. and eventually I ran the project. To my confusion the SWF I saw didn't reflect any of the changes I'd made, so I made some bigger changes and still nothing changed in the generated SWF.

Long story short, Flex just kept showing me the SWF of an older version of the project. Nothing I did helped; I cleaned the project, refreshed it, renamed it.
Eventually I worked around this issue by deleting the project (not the files) from Flex Builder and creating a new one (same location and same main project-file).

Although I fixed this thing for now, my (fairly big) concern now is mainly about how many more times I will have to re-import my projects into Flex Builder 3..
My guess is that this has something to do with the compiler-cache and incremental compilation, but either way, I'd really appreciate it if the Flex Builder development-team would fix this.

Any suggestions are more than welcome.

The algorithm is pretty simple in essence -- it starts at one point, looks for connected/surrounding points, picks one at random, and repeats these steps until it reaches the destination-point (success) or comes across its own trail (failure). In the latter case it'll start all over again from square 1, so to speak .

Check it out, when the destination-point has been found click the demo to start over.

Here's a quick summary:

Record type - The record type is like a light-weight class and lets you define a set of properties that any variable of that type should have.

Array type - The array type lets you specify the allowed datatypes for values in your array, in a semi-indexspecific way:
type someArray = [boolean, int, string];

This also goes for rest-argument arrays in method-signiatures, which is hellacool.

Union types - ECMAScript 4 allows you to specify multiple allowed datatypes for a property, return-type, etc:
var n:(int|uint)

Nullable & non-nullable types - With the ? and ! characters you can (respectively) allow or keep variables from carrying null-values. The same goes for classes.

Lexical block scoping - ..gives you just a little more power over the scope to which your variables and functions are local. Just surround the required scope with accolades ( { and } ) and declare your variable with 'let' instead of 'var'.

One-line methods - Lets you declare write a function in pretty much the same way as you would a one-line if-statement.

||= - Easy for assigning default-values:
iDontWantToBeNull ||= "not null" // value is only assigned if var is null

Method overloading! - Hooray. Yeah.

..use the generic keyword.

Operator overloading - Useful if you would want to have + (the plus-operator) perform a concat-operation when executed upon arrays.

cast-operator - As in AS3 there's still a difference between the as-operator and the oldskool-way of casting (MyClass(myVar)), the cast-operator will be introduced to replace the latter.

Datatype switching - ECMAScript 4 will allow for variables their datatypes to be evaluated through a switch-statement, which is kinda cool.

Multiline strings - Putting three double-quotes at the start and end of your string will allow you to have it spawn multiple lines, you also won't have to escape any double-quotes you have in your triple-quoted string.

.

For those of you interested, here's the online version of Colin's presentation:
moock.org/lectures/newInECMAScript4

Having overslept I walked into today's first presentation not before halfway through, and honestly I instantly regretted not having been on time. Koen de Weggheleire did a really good job entertaining the audience (which still seemed kind of sleepy and reluctant with applauding) with his presentation about bitmap-manipulation. Especially the fly-smashing part really got me smiling.

The rest of the day was really just one big bunch of inspiration, seeing some really beautiful artwork by Jared Tarbell (here are the pieces he showed) and also Erik Natzke.
Also really mind-blowing was all of the audio-stuff Andre Michelle had to show (but more about that later).

In my opinion the best part of today was James Paterson's (most inspiring) presentation. I was already familiar with the work he's done for VH1 and as it turns out I had already come across his website a couple of years ago, so seeing him show off all of his insanely awesome animations, characters and drawings was althemore exciting/interesting.

I'm particularly excited about getting to see Joshua Davis talk, I remember being baffled when I first saw his work. Also, I'm very curious as to what Erik Natzke will be talking about, but I guess I'll find out tomorrow..

I'll try to keep you guys posted over the course of the next two days.

The main reason behind this was to get a grasp of the utter basics of AI. Alongside that I also thought it'd be cool to try to have classes work with as little knowledge as possible about other classes. Do mind that this is not an example of best-practices, merely a little experiment of mine.

In this project is that there are three different types of organisms; rock (blue), paper (red) and scissors (green). Naturally if a paper encounters scissors then paper dies. If two organisms of the same type (i.e. two papers) encounter eachother, another organism of the same type will be born.

Check it out by clicking the image below, source-code is available as well. You can toggle the visualisation of the grid by hitting the space-bar.

Oh, and sorry for being too lazy to think of a clever name