So here’s how you can fix the problem, if you’re experiencing this annoyance:

Open Keychain Access, and search for the stored SVN repository credentials. The credentials are stored as an application password item and you can usually find them by the repository name. Open the Get Info window for the keychain item. Under Access Control, select the option to Allow all applications to access this item. And that’s it. Subclipse will now happily do commits and updates and whatnot without bugging you for the password.

Yeah I know, some security freaks will freak out, but those guys can stop whining and carry on entering their freaking repository password every time.

I’m quite sure this approach could be made “safer” by finding out the exact application that needs to be added to the Access Control list of allowed apps, but I didn’t have to persistence to find it out. Let me know if you do.

10 years ago I was teaching multimedia programming in the Helsinki University of Tehchnology. I proposed my superiors to start moving away from Director and looking into where Flash was going. Back then Macromedia Director was considered programming, while Flash was thought of as scripting. But it was clear for me to see it was a superior approach: Macromedia’s Flash team was looking into changing how the web was being used, while the Director team was adding new features on top of something already getting old.

For a while I’ve been saying the time for Unity 3D is here. Adobe has failed to hold it’s domination in web gaming and originally a 20-person company from Denmark has taken over browser 3D for a while.

The main reasons clients shy away from Unity 3D are the fear of new technology and the fear of being stranded after a small tech company goes belly up. The web player has no penetration compared to Flash. But times are changing. One-click install of the web player is quite OK for web gaming. It’s easier than Shockwave used to be and the quality of games seen even now is amazing. Check the Unity 3D paradise demo if you don’t know what the fuss is about.

One good reason to choose Unity 3D is the paradoxically fierce competition in the field. While choosing between Flash and Silverlight is forcing you to practically choose the tools you work with (you often choose Flash since it just works with Photoshop and Illustrator – and is also bundled in deals). But Unity’s praised-for-reason asset pipeline is not locked into Unity-related products at all. If you develop a Unity project now, but one of the other promising Web 3D platforms take over (eg. Torque has some promising stuff out already, and Unreal engine is also looking good), big part of the work does not need to be ported. You just import your 3D Max/Maya/Photoshop files to another environment and off you go.

So choosing Unity is not choosing Unity. It’s betting this kind of tools will be used for publishing 3D to the web, iPhone, and for casual console games. You don’t dig a hole with the nice hammer you’re familiar working with, waiting for Adobe to upgrade it to a more suited version. Get a shiny shovel from a shop and start digging. I’d propose starting with Unity, since it has a free version and the tutorials are just great. Or start with the Unreal Engine. Just keep your eyes open for the other players in the field.

We delivered our first tiny Unity3D project to a client, and are definitely looking to explore the technology further.

Meanwhile, an old Matrix12 has finally been given a new life after spending weeks in the garage. There’s still something to be fixed with the filter resonance, before it’s good to go into the studio. Here’s what a happy Redberg Robot Repairs customer looks like:

It can melt small amounts of iron, copper and magnesium, and open a frozen door. So much has been proved.

While many of the existing ActionScript tweening libraries compete on features and the amount of shortcuts or convenience functions, we wanted to have a fast and robust tweening engine, which allows tweens to be set up in the code strictly using a single approach. The result is a highly simplified approach, where the programmer creates a new Sequence object, then adds as many tweens (sequence steps) inside the sequence as needed (using a single add() method), and finally starts playing the sequence. This approach allows sequences to be reused, reducing or even eliminating the creation and deletion of new objects while tweening.

Sequence can (naturally) do simple tweens for one object at a time, but if your daily work involves complex, dynamically created tweens with many simultaneous tweened objects and parameters, we really urge you to try out Sequence. You just might learn to love it.

But why?

You know those projects where your code slowly becomes a mess of direct references, while changing and even maintaining the code starts to feel more and more painful at every moment? That project where your MagicButton instance is listened to by ten other objects, and it gets moved into a new Sprite on a totally different corner of the user interface, and it’s Friday afternoon and you’d like to head to the park with beverages, but you need to start hunting down and rewriting all the listener references instead?

You might solve the problem with your Find & Replace wizardry, or you might even go as far as delve into the hazardous world of patterns, start creating your own singleton ReferenceManager class, or something silly like that, which you will regret on Monday morning.

But fear not. Message Relay is there to help you keep your code clean, while providing an understandable method of communication between objects. Enough advertising? Go and look at the examples.

As you can see on their site, FLARToolkit is an AS3-conversion of NyARToolkit, which in turn is a Java-conversion of the original ARToolkit, written in C. Having seen the FLARToolkit in use commercially (the GE SmartGrid campaign comes to mind), I find it pretty interesting that all uses of FLARToolkit are subject to the requirements of the GPL license, originating from ARToolkit. In particular, the license requires derived works to be fully open sourced. Let’s see if we can get a client to accept that…

We will surely try to do something with the FLARToolkit, but we will be also looking at other, more light-weight approaches.

Nevertheless, I think there are projects where Flex could be the right choice:

• Quick protos with absolutely no concern with looks and user experience. The “create a Flex app in 15 minutes” examples included in the documentation, the ones that make you feel all great about your newfound Flex programming skillz, fall into this category.
• Small to mid-size projects (say, up to 6 man-months), in which you can live with basic CSS skinning and with the short-comings of the Flex components, and with the mediocre user experience resulting from those choices.
• Very large projects (12+ man-months), where the extensive time investment required to fine-tune the looks and perfect the UX of Flex components is justified. These are mostly projects where Flex competes against DHTML rather than pure ActionScript solutions.

This specifically leaves out the kind of projects we usually do: small to mid-size projects with great concern for aesthetics and user experience.

Well, a lesson learned (and an expensive one, if I may add).

Signs of a good programmer:

• Ability to break down a problem into tasks.
• Ability to estimate the time it takes to program and finish the tasks.
• Actual time spent on tasks matches estimates very accurately. Personally I think this might be one of the strongest signs of talent in programming; it also reflects the reality that a “good programmer” is only good if he knows the tools he’s working with.
• Ability to adjust their style of programming, from quick & dirty to fully thought-out and documented (both styles have their time and place).
• Related to the previous point is the ability to avoid overkill solutions, to know when a problem is best solved by programming in repetitive laundry lists, or when to build tools and additional complexity to handle the repetitive tasks for you.

This goes for everyone who needs to collaborate, but is vital also for programmers:

• Ability to ask for advice, and quickly and understandably explain problems to others who have no clue about the context of the problem.

To understand how E4X works, it is useful to remember that E4X is always querying the data. E4X is in fact searching the data for nodes and attributes, either by name or based on boolean rules. The queries can always result in zero or more matches, and the application will not know until a query has been executed. This is why E4X always returns an XMLList, even if there’s only one “hit” for the search. The automatic type conversion then ensures you can use the returned single item list as if it was an XML object.

This sounds all dandy — Flash is after all doing things for you, automatically. We think this is a bad idea though. The problem is that getting data in an unexpected type might break your application, the key word here being might. You never know, for the type conversion is automatic after all.

Here’s a good practice to avoid the worst pitfalls of automatic XML type conversion: Always use the array access operator [0] when you know you are accessing a single XML node in your data using E4X. To see what this means in practice, consider the following E4X statement which returns a list of id attribute values:

configuration.wireframe.house..wall.(uint(@id) == 12).color.@id

…vs. the same, explicitly stating the single nodes accessed on the way:

configuration.wireframe[0].house[0]..wall.(uint(@id) == 12)[0].color.@id

Putting the E4X full of [0]’s looks bad if you consider the readability of code in the same way as you consider the readability of a novel.

But it looks pretty good if you consider that code is more readable, when the workings of the code are clearly stated.

If you’re left wondering, here’s what the above line of E4X does: We know there will be only one company node in our data, so we’re getting that XML node instead of all company nodes. There’s only one maskareas node, too, under the company node, so again, we’re explicitly getting the XML node, not a list of all found maskareas nodes. Then we access all palette descendants, whose id attribute matches 12 (everything you get out of XML is of type String, so @id is typecast into uint to allow for successful comparision). Again we know there’s only one matching palette, so we state in the code we want the first found match, not a list of matches. The last two “words” actually need to match multiple product nodes and their multiple ids.

E4X resources:

• ECMAScript for XML (E4X) Specification (the spec is a 1.9MB PDF download)
• The E4X approach to XML processing (on Adobe Livedocs)
• Mozilla’s E4X tutorial

So what do we do? We work for clients, either to given specifications, or more often by helping them design the spec according to their goals and requirements for maintainability. We love project management, and consistently deliver on time and within set budget (with our latest project being the exception which confirms this promise). But more than anything, we love a challenge. Especially when it doesn’t come prefixed with “time” or “money”.

We’re inspired by many things, of which we were quickly able to list the following:

• Great user experiences — In fact, Niko sometimes goes around talking about it
• Space exploration and jet propulsion — What is there to explain?
• Sustainable living — Everyone should be inspired by sustainability, or this planet will break down soon.
• Generative visuals — Creating beautiful code that draws beautiful random things.
• Making things — We’ve made things out of wood, electronic components, and playdough, to name a few of our favourite ingredients.

This blog will be about our work: the things we create at our “office”, and especially the problems and a-ha’s we bump into while creating those things. Expect programming philosophy, ActionScript code, Flex agony, and pictures of electronic gadgets. Maybe an occasional “look what I can do” photo of wooden items thrown in.

So grab the feed, or subscribe by email to always stay on top of the latest posts. Welcome!