The random utterances of David Arno

This is part 2 of a of two-part article about the Try { harder } conference. I’d recommend reading days 1 & 2 first as this article will likely make more sense that way.

After a full day’s pair programming workshop, day 3 (Wednesday) was a much more normal conference-style day involving a series of technical presentations.

Day 3
Simone Vicentini – Continuous Delivery with Git
Day 3 kicked off with a great presentation by Simone Vicentini that set the tone for the next two days. This was no “Look at me, aren’t I great?” presentation by an “inspirational” speaker; instead Simone dived straight in to a complex subject (Git) and clearly explained some of its more complex features, especially rebasing and squashing. Whilst I don’t particularly like Git, I have accepted that it is here to stay. I really appreciated therefore having someone explain some of the more advanced – and useful – features of Git in such a clear way.

Dominic Graefen – Build like you code
Next up was a session on Buildr by Dominic Graefen, the groovy-based alternative to the likes of Ant and Maven. Specifically, Dominic covered an extension for Buildr that he had created called Buildr-AS3. This provides the means to create simple Groovy scripts for compiling AS3-based Flash and Flex projects. The build scripts for Buildr tend to be much smaller than either Ant or Maven. For example, the following script is all that is required to compile a project to a SWC:

require “buildr/as3”
 
define “MyProject” do
  compile.using :compc
  compile.using :flexsdk => FlexSDK.new(“4.5.0.168”)
end

Buildr definitely looks like a tool worth experimenting with and as an added bonus it gives me an excuse to learn Ruby, a language that I feel I should know but, until now, I’d seen no personal need for.

Me – The art of ABC
I was up next with a talk on doABC tags, bytecode and the like. This seemed to go down well, but I’ll say no more about it here as this post aims to talk about what I got from others’ talks, not my own.

Mike Cann – HaXe
In the last session before lunch, Mike Cann took us on a whistle-stop tour of haXe, a language that can compile to SWFs, JavaScript and native C-based applications. It is a really nice language with huge advantages over AS3 in most areas: better typing, generics, partial function applications, enums, faster executables, faster compilation etc. The list goes on and on. Mike has written about his talk here, so you can read up on the details he presented.

Robin Alexander – Roach Killers
After lunch, we kicked off with Robin Alexander presented us with a talk on tools that can assist with testing, debugging and killing those bugs dead. The main topic of the talk was about Charles, a really useful tool for analysing and controlling the data within client/server requests and responses. Charles can act as a proxy to enable re-routing of requests, you can apply breakpoints based on message content and inspect AMF messages to name just a few of its features. If you haven’t used Charles yet, I’d recommend downloading it and giving it a try.

Till Schneidereit – Dependency inception
Till Schneidereit is the man behind Swiftsuspenders, the inversion of control (IoC) implementation at the heart of robotlegs. Till has recently been working on version 2 of Swiftsuspenders and during his talk he discussed many of the ideas and influences behind the design decisions that have gone into the v2 changes. You can see the slides from his presentation here.

Alec McEachran – Death by 1000 SWFs
Following Till was Alec McEachra who presented details on how a company he has worked for in the past handled the problem of balancing inital load time for a Flash-based game that contains lots of assets against delays in loading those assets later. As a Flex developer who creates RIAs that are delivered over fast intranets, this was a whole new topic to me. If you bundle the assets in the main SWF, the initial load time is too long and people will give up on your game before even trying it. If you have to load too many assets once the game is running, this can ruin the gaming experience and so people will still give up on it. Alec presented some great information on how one goes about finding the “sweet spot” balance between the two.

Shaun Smith – Restfully Serving Promises
Shaun Smith is the author of some really nice Restful extensions to Robotlegs called Oil and his talk was a good mixture of basic HTTP theory, Restful interfaces and how to use Oil. His talk contained numerous useful tips, such as how to take advantage of HTTP caching, rather than fighting it and how to work around the fact that the Flash Player only reports results with a 200 status. In addition, we were treated to a detailed discussion on how to use Oil to solve various Restful tasks.

And so ended day three of the conference. What made this day very different from other conferences was that I’d paid attention to every talk. There was no hiding at the back of the conference room tweeting, blogging or checking work emails as there were only 16 of us in the room. Plus no one had tried to show off with fancy artistic demos: instead we each presented a solid technical talk that enhanced everyone’s knowledge. Between sessions, we made tea and coffee and chatted in the kitchen. This created a very informal atmosphere that enabled the whole thing to work I think. In a larger conference, such a large number of dry presentations could easily turn boring. Here they felt more like conversations than presentations. It work well and was a great experience.

Day 4
Richard Lord – Game architecture is different
So the last day of the conference arrived. Like day 3, this was a day of presentations and Richard Lord kicked things off with a lesson in entity systems and why they suite the gaming world so well. He started off with a classic example of using inheritance and demonstrated why inheritance models can quickly result in spaghetti code in languages that support multiple inheritance and lots of redundant members in classes in languages that do not. He took us through transforming this code into compositional objects, then showed how entities and processes can be used to greatly simplify a classic game loop. Richard managed finally get me to see the point of composition rather than inheritance and also explained entity frameworks really well.

Michał Wróblewski – Making mobile Flex apps blazing fast
As was the theme of Try { harder }, next up was something completely different. Michał Wróblewski presented a session jam-packed with hints, tips and general advice on how to improve the performance of Flex on mobile devices. He started with an overview of the various visual container components in mobile Flex and advice on when to use each. Next was a series of tips on optimisations such as BitmapImage versus Image classes, the correct renderer classes to use to achieve fast scrolling and the like. Lastly Michał suggested a series of tips such as ideas on correctly handling multiple devices all with different screen sizes and DPI settings. Excellent stuff. Update: you can see the slides for Michał’s presentation here.

Robin Wilding – A Brief Introduction to AIR Native Extensions (ANE)
David Wagner – Native under the skin
Robin Wilding and David Wagner presented back-to-back sessions on a new addition to AIR: AIR Native Extensions (ANE). These extensions can be written in Java (for Android), Objective-C (for iOS) or C/C++ (for all platforms) and enable developers to access device, platform and third party APIs that AIR doesn’t cover. Robin’s presentation introduced the topic and set the groundwork for the topic. David then followed this up with a more in-depth description of ANE and how to use this new feature. David’s slides are available online and can be viewed here.

Neil Manuell – Wrap up
Neil Manuell was given the unenviable task of – in just 20 minutes or so – encouraging us to think back over the four days and what we had learned from it and tried to write those ideas down on a whiteboard to form some conclusions. It worked really well and was a fun way to finish off the conference. Everyone really seemed to have enjoyed themselves and there was a lot of positive feedback and what had been a brilliant conference.

Afterthoughts
Try { harder } was an incredible conference and everyone there was both full of praise for Stray for organising it and keen to take part again next year. Having however taken nearly two months to get around to writing up my experiences of the event, Adobe have managed to put an interesting spanner in the works in the meantime. Will Flash still be a relevant technology in 10 months’ time when Try { harder } 2012 is due to take place? Whether the answer is yes or no, I think Try { harder } is such a good idea that it will happen next year regardless. I fully anticipate a lot less Flash content to the next one. I imagine there’ll be more JavaScript, a lot more haXe and maybe even sessions on the likes of CoffeeScript. Adobe may have effectively killed Flash, but Try { harder } will live on regardless. So here’s to many more years of us trying harder…