Tom Byrne

Internet Archive Android App

tom — Mon, 06 Feb 2012 08:06:46 +0000

I’ve just released a new Android App.
It allows you to watch out-of-copyright videos from the Internet Archive Database on your phone or tablet.
It’s currently early days and it doesn’t really have any browse functionality yet, just search fields.

An iOS version will be coming soon also.

Evolvex Furniture Builder

tom — Sun, 15 Jan 2012 23:01:10 +0000

In this flash app I built for Evolvex, users can assemble furniture from different components in a 3D environment. When finished the furniture can be purchased, all of the components, along with a diagram of the furniture gets sent to the user.

To build this I used a component architecture which I began to develop for the Nokia Bill Exchange job the year before.

The 3D is run using the new Stage3D API of Flash Player 11 and Away3D 4.

Check it out here

SWC packaging ANT Task for Flash Builder

tom — Wed, 03 Nov 2010 11:58:33 +0000

Download the SWC Packager ANT task here (source included)

Often, my project workflows include checkouts of other remote code repositories. This means I can directly edit the code and have it immediately compiled into my project, without having to compile an SWC and copy it into my project. This can lead to problems when the project needs to be rolled back to a previous revision (there is no easy way of knowing which revision the remote repositories shuold be checked out at), and issues with remote repositories that are moved/removed.

In the past I have used the SVN externals to achieve this (including using the ‘-r’ option to pin externals to specific revisions), but this solution still didn’t get around repositories that are moved/removed.

I ended up writing an ANT task which can build an SWC based on a Flash Builder project file. This way I could integrate regular SWC creation into my deployment process, backing up all external code.
The ANT task also has the option to export a manifest XML file detailing all of the classes included in the SWC.

These are the compilation arguments taken from the project file:

All classpaths & SWC paths
Accessibility setting
Target flash player

These are the additional options:

sdk – a path to the sdk folder. This is used to find the frameworks directory and the compiler.
projectPath - a path to the root folder of the project.
sourceExceptions (optional) – a comma separated list of source paths to exclude from the SWC (they will still be compiled against, just not included)
linkReport (optional) – a path to a link report XML file (as output by the mxmlc compiler), this can be used to specify a list of classes to include. By including the link-report argument in your main project then passing this path to the SWC Packager your SWC will only include classes currently used in your project.
includeMainSource (optional) – a boolean specifying whether the main source path should be included in the SWC. Defaults to false.
manifestOutput (optional) – a path specifying where the manifest XML file should be saved.
computeDigest (optional) – a boolean specifying whether a catalog.xml file should be generated (for use by RSL). Defaults to false.
outputAsDirectory (optional) – a boolean specifying whether the compiler should output a folder with AS files instead of an SWC file. Defaults to false.
additionalArgs (optional) – additional compiler arguments can be passed through here.
configXML (optional) – a string pointing to an additional config XML file.
compileDebug (optional) – a boolean specifying whether the debug compiler option should be used. Defaults to false.
verbose (optional) – setting this to true will make the SWC Packager print out the full compiler command before executing it. Defaults to false.

When includeMainSource is set to true and a link-report is specified, only classes that meet both conditions will be included.

Here is an example of how the task can be used in your ANT script:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

name="SWC Packager" basedir="../">
name="FLEX_HOME" value="C:\FlexSDKs\4.5.0" />

name="swcPackager" classpath="${basedir}\build\SWCPackager.jar" classname="org.farmcode.antTasks.SWCPackager"/>

name="Package All Source" description="Builds all AS code into an SWC.">
sdk="${FLEX_HOME}" projectPath="${basedir}"
includeMainSource="true" swcOutput="${basedir}/build/allCode.swc" configXML="config.xml"/>
>

name="Package All Third-party Source" description="Builds all AS code except main src dir into an SWC.">
sdk="${FLEX_HOME}" projectPath="${basedir}" includeMainSource="false"
includeMainSource="true" swcOutput="${basedir}/build/thirdPartyCode.swc" configXML="config.xml"/>
>

name="Package All Referenced Source" description="Builds all referenced AS code except main src dir into an SWC.">
sdk="${FLEX_HOME}" projectPath="${basedir}" linkReport="${basedir}/build/linkReport.xml"
includeMainSource="true" swcOutput="${basedir}/build/allReferencedCode.swc" configXML="config.xml"/>
>
>

Download the SWC Packager ANT task here (source included)

Nokia Bill Exchange

tom — Wed, 06 Oct 2010 01:40:31 +0000

This is a microsite I built for Nokia with the great group at JWT.

I built the physics portion of the site, all of the items and navigation moving around in the background using Box2D. I also built several of the pages.

Check it out here

The Bad Eggs

tom — Thu, 16 Sep 2010 22:48:14 +0000

I’ve been doing some work down at JWT recently and found myself building this silly physics prototype.
You can add eggs and then smash them against one another or the walls.

A more general CSS

tom — Fri, 06 Aug 2010 04:24:42 +0000

As a language, I like CSS, it has a simple elegance that achieves it’s humble goals very nicely.
It’s these humble goals that bother me.

HTML is an XML based language, and fundamentally, all CSS is doing is targeting nodes within this XML and modifying their attributes. Of course, it’s not possible to, for example, modify the href property in an anchor tag, and this shows that the implementation of CSS is stifled by it’s modest goals.

Also, CSS’ ever-growing list of selectors shows a fundamental inflexibility in it’s syntax. Selectors basically target specific nodes within your HTML, this sounds to me an awful lot like the job for XPath.

Imagine a CSS where XPath statements replace selectors and a generalised set of property modifiers replaced style declarations.
In this way you could (for example) set all the target attributes within all anchor tags to "_self".

1
2
3

//a {
target:set("_self");
}

Or you could remove all the width and height attributes from img tags that don’t have a src attribute.

1
2
3
4

//img[not(@src)] {
width:remove();
height:remove();
}

Or you could add some copyright info to the alt attribute of any img tags within any div tags with class="portfolio".

1
2
3

//div[@src="portfolio"]//img {
alt:append(" © 2010");
}

The biggest issue I can see arising from this is that styles on HTML elements are not individual attributes but a collection of declarations compiled into a single attribute.
To get around this I have a few solutions.
Firstly we could create a Regular Expression based string modifier which gets executed on the specified attribute of the targeted nodes (in this case the ‘style’ node), something like this (here I’m setting line-height=20px; on all p tags).

1
2
3

//p{
alt:mod("line-height\:.*;", "line-height:20px");
}

I think you can probably see that this is not ideal though, it is very verbose, difficult to read and would make cascading declarations a nightmare for the browsers reading this code.

The ideal system (IMO) would unfortunately require a modification to the HTML spec, it would require styles to be broken out into their own child node, for example:

1
2
3
4
5
6

And then, to set our style would be a normal attribute setting modifier.

1
2
3

//p.style {
line-height:set("20px");
}

Alternatively, we could create a style specific attribute modifier. I am reluctant to vouch for this because it is a special case but it could be the more feasible (as it doesn’t require changes to the HTML spec). It’d look something like this:

1
2
3

//p{
style:setStyle("line-height", "20px");
}

You can see that vastly broadens the scope of CSS to the point that Cascading Style Sheets is no longer an appropriate title (maybe XMod or something is better).
Here are several situations I can think of where such a system could be useful (outside of styling). Remember, none of these permanently affect the underlying XML, they’re more of a filter through which XML can be viewed.

Applying formatting to Word documents using the XDOC file format.
Creating a mobile friendly version of flash files using the XFL file format (i.e. removing filter effects, removing embedded fonts, etc).
Modifying the Firefox UI using the XUL interface files (as if we need another way to customise Firefox).

Environmental Controls

tom — Thu, 08 Jul 2010 07:56:17 +0000

Grant Skinner, the renowned ActionScript developer, has recently been playing with applications that span both desktop computers and Android based smart-phones. An idea struck me that this dual-platform would be perfect for a environmental controlling system. Imagine, having installed a simple Remote Control app onto your phone, every time you walk into a hotspot certain controls can be sent onto your handset to give you control over certain systems around you.

For example:

Restaurant Menu – Pretty self-explanatory, you’re able to order you food from your table without waiting. Also, when your order is ready, your phone could act as a buzzer.
Stand-up Comedian Axer – Everyone in the room can vote to Axe the currently performing comedian.
Cafe Music Preferences – Enter your last.fm account name into the widget and the playlist will lean towards your tastes.
Bill-board Games – Use you smart-phone as a controller for a video game on a billboard.
Real-time sports betting – Bet in real-time on referee decisions whilst in the Arena stands.
Thermostat – Voice your concerns if the you’re too cold or warm.

For obvious reasons it would have to be opt-in. I envision the controls only being allowed a small piece of screen real-estate to allow multiple to sit on screen at once.

(Keep in mind, it would never be possible to see these three particular controls pictured at one time, they’re shown together only as an example)

The Robot’s Creole

tom — Thu, 08 Jul 2010 03:46:48 +0000

When I first began programming I was appalled at the simplistic nature of the tools being used to create software; and whilst there have been admiral efforts in the past to make programming a more intuitive affair (think node-based programming) very few of these tools have lived on.

In my opinion, this is symptomatic of a bigger problem in the way we build software; namely, the strong tethering between programming language, compiler & delivery platform.

Imagine a system where, when you typed (in your preferred language), and behind-the-scenes, your IDE was converting all of your code into an XML based representation of the language structures you are typing. These XML representations are what gets saved in your files, NOT your ‘human-readable’ programming language.

This effectively turns the code you view in your IDE into a ‘rendering’ of the core XML structures in the files.

Consider these benefits:

Formatting preferences (like the eternal cuddling brackets debate) would be stored in your IDE, allowing everyone to view the code however they want.
Programmers are not restricted to platforms or compilers. For example, anyone could happily write a Flash application in C#, because both languages would be saved into the same core XML structure.
Pre-compilers and IDE tools would be completely cross-language. Consider having refactoring tools that work across all languages, or code documentation tools that worked across all languages.
New ways of rendering code. Consider being able to have a Colour picker next to colour values, or a popout calendar next to date/time values.
Alternate views of code (e.g. Visual layouts for forms, Class diagrams of entire program, UML diagrams) would all become first class citizens and would be language agnostic.
Breaks down relationship between files and classes. You could have multiple packages/classes in one file, or alternatively you could split classes into multiple files (e.g. a function in each file). This would not change the way you edit the code within the IDE. This could make for easier file handling and version control.
Compilers and Pre-compilers would be faster in two ways; Firstly, they’d only have to parse XML instead of processor intensive human-readable languages; Secondly, this parsing need only happen once, then all compilers/pre-compilers could use the in memory standard data structures.

Arbitrary Formatting

When discussing this with people, I have found the biggest concern is to do with arbitrary formatting of code, i.e. occasionally it is beneficial to break ones preferred formatting rules to make code more readable. This could easily be solved by the IDE detecting whenever you’ve broken your own preferred formatting rules (as defined in the IDE preferences) and insert a ‘formatting’ tag into the XML structure, describing the custom formatting. Of course this formatting difference will only be applicable within certain languages, and so these ‘formatting’ tag would also be accompanied by information describing which language (or group of languages) the tag applies to. Alternatively this information could be stored in a separate file, keeping the code free of arbitrary data (and potentially making these formatting choices specific to the programmer who made them).

The Challenges

There are many challenges that such an idea faces, these are the initial ones that spring to mind.

Language Types & Paradigms

Which languages and structures should be able to be represented within this core XML language?

There are vast differences in the structures and paradigms of (for example) Functional Languages and OOP Languages, and much thought must be put into how similar these core items are. For example, the statelessness of Functional programming means that it may not contain non-local variables, this doesn’t mean that it is incompatible with this system, only that if you use local variables in your program you will not be able to use Functional Compilers.

Compiler restrictions on language features

How will your IDE know whether the language features used in your program are available to the compilers you wish to target?

Consider you are writing your application in C# but intend to compile to JavaScript, you use getters and setters in your code (which are not a native feature of JavaScript). There needs to be some way for your IDE to detect that you’re using invalid code for the JavaScript compiler.

One solution would be to create a standardised way for compilers to declare which language features they support. The programmer would target the intended compilers in the project settings, then the IDE could report on invalid uses.

Interaction between Strong and Loose typing

Writing code in a completely loosely typed language (like JavaScript) would not provide enough information for some strongly typed compilers; whilst it would be possible to use a solution like the compiler declaration mentioned above, I believe there is a better solution to this.

Currently, in most OOP languages (Java, C#, AS3, etc) coders use specifically formatted comments to represent information about certain classes/members, which is then used to generate documentation. I believe a similar system could be used to add/display type information in loosely typed languages where adding this information outside of comments would break the language spec. It would be the language parser’s job to analyse these comments and put them into the correct XML data structures (and likewise I believe documentation information should be stored in standard XML structures, not in arbitrary comments).

Using native APIs and existing compiled libraries

All programs use native APIs and existing compiled libraries, whether it’s simply for base mathematics or multi-dimensional matrix operations (think MATLAB). These APIs need to be referenced in a manner that doesn’t tie your code to a specific Compiler/Platform.

One solution could be to develop a set of standard API interfaces. Then existing APIs would be packaged up to contain which of the API interfaces it supports and how those APIs get mapped to the internal classes and members. This would allow native APIs and external libraries to be interchangable, and eventually compilers could easily support features that are native to other platforms without modifying the target platform.

Russell Investment Calculator

tom — Sun, 09 May 2010 04:17:53 +0000

Here is an application I built for Russell Investment during my time at the Farm.
It allows customers to work out the best way they can distribute their contributions to maximise their returns.
It presented some interesting challenges like building an efficient Data-Grid, and formatting text as it is typed by users (I got to finally use a diff formula).

Please contact me if you’d like to see the finished result (as this is part of Russell’s product I’m not at liberty to publicly host it).

Bonds Hipsters

tom — Thu, 08 Apr 2010 07:41:29 +0000

While at the Farm, I built this site for Bonds, leading one other developer.
It connects with your Facebook account and plays a montage of your profile pics along with the Hipsters TVC.

Click here to check it out

Warner Videos

tom — Fri, 05 Mar 2010 02:35:35 +0000

Here is a site I built during my time at the Farm, leading with another developer.
Unfortunately, we (the Farm) didn’t get the opportunity to design it as they wanted it to match a design from the States.
That said, we did use it as an opportunity to finish building visual layout and data-mapping library, which means that based on the XML data coming from the back-end, the entire site can be re-laid out.

Check it out here

Wiggle Time

tom — Sat, 05 Sep 2009 01:40:03 +0000

I worked for about 9 months solid on this Virtual World for the Wiggles during my time at the Farm.
I was heavily involved right from the conceptual stage, which I think really helped in creating a really great looking and technically accomplished result.
In the end I lead a team of about 6 developers; 3 concurrently.

Children would move their customised avatar around in the Big Red Car; traversing a richly illustrated, parallax-based world. They could enter the houses of the Wiggles & Co. and had their own house in the world where all of their prizes were stored. To earn these toys, children played mini-games around the world, helping the characters achieve certain goals. It also included a TV to watch Wiggles video content.

We build a lot of interesting tools for this project including a bezier library, a small AI library and a parallax library. It also integrated with existing open-source libraries like the Box2d physics engine, goASAP tweening library and the flint particle engine.

Gathering bones in bed

tom — Sun, 05 Apr 2009 09:48:38 +0000

Open up to Mail

tom — Fri, 20 Feb 2009 04:28:09 +0000

This is a microsite I built for MercerBell/Australia Post in my time at the Farm.

It uses Papervision to move around the room, it took us a long time to get the room looking right, but I think it’s still quite a nice little execution.

Check it out here

Sunbeam Coffee School

tom — Fri, 30 Jan 2009 02:02:20 +0000

I lead a team of three on this site for Sunbeam during my time at the Farm.
I’m still very happy with the result, especially the navigation which still looks really great.

Click here to check it out

Outdoor Media Awards

tom — Tue, 06 Jan 2009 08:11:20 +0000

Here is a site I built for the Glue Society while at the Farm.
It was very simple and clean and I still like it. They must have liked it too because they used it for the next years awards too.

Click here to check it out

Brighton & Spain

tom — Sun, 28 Sep 2008 06:08:29 +0000

These are some of the drawings from a diary I kept on a trip to Brighton & Spain.

The Glue Society

tom — Tue, 05 Aug 2008 03:12:20 +0000

This is a site I built while at the Farm, I love the design.
It was a rebuild of their prior site (also built by the farm), to make it CMS driven.

Due to the extremely lightweight design, I was really looking forward to the challenge of making this site as tiny as possible. The finished site was drawn completely in code (except for the several cursor images, which were gifs) and was about 60Kb in size, about the same as a large thumbnail image. Needless to say, I didn’t bother putting a preloader on it.

Click here to check it out

Missing the last tram

tom — Sat, 02 Aug 2008 07:14:21 +0000

Mitsubishi Motors

tom — Wed, 09 Apr 2008 04:52:54 +0000

Here is a site I built during my time at the Farm, with several other developers.

Click here to have a peek

Centenary of NRL

tom — Thu, 06 Mar 2008 08:04:29 +0000

I built this card flipping application of the NRL when I was at the Farm, despite being pretty tiny it’s a nice little piece.

Click here to check out the Players Browser
Click here to check out the Clubs Browser

Bonds Homepage

tom — Sun, 30 Sep 2007 01:37:15 +0000

This is a site I built for Bonds during my time at the Farm.
It integrated existing pages from their previous site (i.e. the pages accessed from the top navigation), which restricted us to AS2.

Check it out here

The Inner Fulcrum Old

tom — Thu, 02 Aug 2007 08:10:24 +0000

Jaguar Banners

tom — Tue, 24 Apr 2007 02:27:59 +0000

Here are some nice little banners I built for Jaguar while at the White Agency.

BigPond – Combi

tom — Fri, 05 Jan 2007 03:55:51 +0000

This is a microsite I did for BigPond during my time at the White Agency.
The campaign was based around the Combi-van that featured in many of their commercials at the time.

Check it out here

Pump Banners

tom — Wed, 27 Dec 2006 02:57:56 +0000

Here are some nice little banners I built for Pump while at the White Agency.

Jaguar – Hunt For Gorgeous

tom — Fri, 20 Oct 2006 01:57:12 +0000

This is a site I did for Jaguar during my time at the White Agency.
The campaign centred around the narrator attempting to track down Gorgeous, keeping the dialogue ambiguous enough to refer both to the mysterious woman we see glimpses of as well as the car itself. It’s a well-worn formula but I think it worked really well.

I was the only developer on it and technically it was pretty simple. I did enjoy creating the code generated flames on the candles, as well as the transitions in and out of the videos, which required dynamically drawing/animating the video into place with a subtle warping effect.

Check it out here

The Scrawl

tom — Thu, 03 Aug 2006 03:18:09 +0000

Coke ’06

tom — Sat, 01 Apr 2006 02:58:53 +0000

I was lead developer on a Coke’s main Australian site in 2006.
Technically, it had somewhat lofty ambitions, and whilst I was never entirely happy with the final product, it did look great.

BigPond – Big Splash

tom — Mon, 05 Dec 2005 04:09:44 +0000

This was a Christmas e-card game I built for BigPond while working for The White Agency.
I believe there are some secret key combinations to make him do some weird moves, but only Brahma knows what they are now.

Click here to play it

A little piece of trivia; we shot the pool photos at my mum’s place.