The bug which is mainly causing me despair at the moment, is that there seems to be a small delay between telling a sound to play and it actually playing. Although small, it is noticeable enough to make the game I’m working on feel like it’s a badly dubbed film.

Example

This is can be illustrated by the following Flash movie. When you move your mouse over the blue rectangle, you should hear a rather jarring BZZZZ noise and simultaneously the square should turn red:

On non-Chrome browsers, or if you disable the PPAPI version of Flash in Chrome, this is indeed the case. However, if you try it in Chrome with the PPAPI Flash plugin, there’s a very short delay after the square turns red before the sound plays. It’s easier to see and hear when comparing it with another browser using the standard Flash plugin.

Sadly, I can’t work out any suitable hack to get around this issue, so I’ve opened a bug on the Chromium project:

• http://code.google.com/p/chromium/issues/detail?id=161387

Example Source

Lest you think I’ve coded anything especially insane, you can grab all the sources for the test movie:

• https://gist.github.com/4077864

Being lazy I searched around to find out which one seemed fastest or easiest to use with mobile, and I found a very useful post on the three common ones at http://www.mfoot.com/2012/01/choosing-a-maths-library-for-cross-platform-c-game-development/. Unfortunately, the tests had been run only on desktop and Android, so I’ve forked the repository and added an iOS runner for the tests. You can find it at:

• https://github.com/mnem/Math-Library-Test/tree/ios-test

I also added a branch with the current latest source code for each of the libraries:

• https://github.com/mnem/Math-Library-Test/tree/update-mathlibs-to-latest-version

A full description of the tests can be seen in the source code, or you can read through the original article by Martin.

Here are the results for running it on my iPhone 4 with the original library versions:

                        iOS release build
Eigen additions         2515
Eigen multiplications   6915

GLM additions           3549
GLM multiplications     7347

CML additions           3004
CML multiplications     11511

(Timings in milliseconds. Smaller is better.)

And once more with the latest library versions:

                        iOS release build
Eigen additions         2161
Eigen multiplications   6721

GLM additions           3340
GLM multiplications     5865

CML additions           2964
CML multiplications     11112

(Timings in milliseconds. Smaller is better.)

I haven’t fiddled with compile settings beyond using a release build, so it’s quite likely the performance can be improved.

The results for the CML multiplications are suspiciously slow, so I wonder if something odd is going on there, but overall it seems to come down to Eigen or GLM.

I think, for the moment, I’ll use GLM for a couple of reasons: it’s geared towards OpenGL use rather than being a generic linear algebra library, and it has more straightforward MIT licensing.

$ easy_install Pygments
Traceback (most recent call last):
  File "/usr/local/bin/easy_install", line 5, in <module>
    from pkg_resources import load_entry_point
  File "/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/pkg_resources.py", line 2607, in <module>
    parse_requirements(__requires__), Environment()
  File "/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/pkg_resources.py", line 565, in resolve
    raise DistributionNotFound(req)  # XXX put more info here
pkg_resources.DistributionNotFound: setuptools==0.6c12dev-r85381

I cursed Apple for breaking things again, but it turns out it was my fault. Something had installed a version of easy_install in /usr/local/bin/ which was shadowing the correct one in /usr/bin/. Silly me.

The solution? Delete /usr/local/bin/easy_install and all becomes right with the world. I also had /usr/local/bin/easy_install-2.7 which met a similar fate in the fiery jaws of rm. I should probably re-install OS X sometime to decrustify it a bit after all the random shite I’ve inflicted on it over the years.

Coding pains.

Deleted three hundred and seventy two files and forget to use git rm? This one liner will do it for you, if you run it from your repository root:

git status --porcelain | awk '/^.D .*$/ {print $2}' | xargs git rm

The --porcelain command is great for batch manipulations of your staged and unstaged files. Just replace the D in /^.D .*$/ with the status letter for the sort of files you want to perform a batch operation on, and then replace the git rm at the end of the command with whatever you want to do to them. The filename will be passed at the end of the git command.

When you change the letter, where you place the dots are important. .D is used for unstaged deleted files, whereas D (no dot before) indicates a staged deleted file. Those 2 columns can have many character combinations, so you may have to play with the awk matching string a little to filter what you want. To test the pattern safely, you can use:

git status --porcelain | awk '/^.D .*$/'

This will print any matching lines. If there’s no output, the filter doesn’t match anything.

You can find more information about the status letters in the man page for git-status.

Enter ipfw.

ipfw is more generally thought of as a utility for managing firewall rules on OS X, but it’s also great for shaping traffic. Doing that is a simple two step process: create an ipfw pipe for a data flow and then configure how big that pipe is.

First, create a pipe which matches a flow of data. A pipe is a combination of source address, destination address and optional matching patterns. In my case I wanted to affect outgoing traffic to port 22 which is used by ssh, the program git generally talks to servers with:

$ sudo ipfw add pipe 1 ip from any to any out dst-port 22

I’ve been a bit lazy here by using any for the IP address fields. I know that only my connection to github will be using dst-port 22. The from IP address and to IP address may be written as a specifc IP, or a range of IPs using CIDR notation, instead of the any wildcard. I’ve specifically set the rule to only match out going traffic. If you want to control the flow of data in both directions, you would generally create an in pipe and an out pipe separately

Note that I’ve named this pipe 1. This number is used to uniquely identify the pipe when carrying out other operations on it. If you create more than one pipe, be sure to use unique numbers for each one.

Next, we have to configure the pipe to control the data flow:

$ sudo ipfw pipe 1 config bw 75KBytes/s

The bw setting ensures that data passing through pipe 1 is transferring at most 75 KBytes per second. You can set this to whatever value is suitable for your connection.

If you want, you can check what connections are being affected:

$ sudo ipfw pipe list
00001: 600.000 Kbit/s    0 ms   50 sl. 1 queues (1 buckets) droptail
    mask: 0x00 0x00000000/0x0000 -> 0x00000000/0x0000
BKT Prot ___Source IP/port____ ____Dest. IP/port____ Tot_pkt/bytes Pkt/Byte Drp
  0 tcp    192.168.0.100/61291  207.97.227.239/22     685   991700 31 43792   0

Finally, don’t forget to remove the pipe when you no longer need to limit the data transfer rate:

$ sudo ipfw pipe delete 1

There are many other options in ipfw for shaping traffic, including commands for dropping a certain percentage of packets (great for testing game networking code), and you can limit the bandwidth to very small rates which is handy for seeing how slow connections experience websites you create. Check out the man page for more details.

Apple Mach-O Linker Error
Command /Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/clang failed with exit code 1

Experiencing clang failing with no other error information?

If so, then check the scheme name you are building. If it has a space in it, that’s probably the issue. This had me tearing my hair out for about an hour.

If you run the full command which Xcode is using, you can see in a terminal what’s causing the failure:

$ export IPHONEOS_DEPLOYMENT_TARGET=4.3
$ export PATH="/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin:/Developer/usr/bin:/usr/bin:/bin:/usr/sbin:/sbin"
$ /Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/clang -arch armv7 -isysroot /Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS5.0.sdk "-L/Users/mnem/Library/Developer/Xcode/DerivedData/Cartouche-gptqetvxyitumqejkandgswxgqob/ArchiveIntermediates/NAH Distribution/BuildProductsPath/Release-iphoneos" -L/Users/mnem/Developer/github/private/Cartouche/ios/Cartouche/../third_party/Flurry -L/Users/mnem/Developer/github/private/Cartouche/ios/Cartouche/../third_party/TestFlightSDK "-F/Users/mnem/Library/Developer/Xcode/DerivedData/Cartouche-gptqetvxyitumqejkandgswxgqob/ArchiveIntermediates/NAH Distribution/BuildProductsPath/Release-iphoneos" -filelist "/Users/mnem/Library/Developer/Xcode/DerivedData/Cartouche-gptqetvxyitumqejkandgswxgqob/ArchiveIntermediates/NAH Distribution/IntermediateBuildFilesPath/Cartouche.build/Release-iphoneos/Matching Set TestFlight.build/Objects-normal/armv7/Matching Set TF.LinkFileList" -dead_strip /Users/mnem/Library/Developer/Xcode/DerivedData/Cartouche-gptqetvxyitumqejkandgswxgqob/ArchiveIntermediates/NAH Distribution/BuildProductsPath/Release-iphoneos/libSparrow.a -ObjC -all_load -lz -fobjc-arc -miphoneos-version-min=4.3 -framework Twitter -framework Accounts -framework MessageUI -framework UIKit -framework Foundation -framework CoreGraphics -framework AudioToolbox -framework AVFoundation -framework OpenAL -framework OpenGLES -framework QuartzCore -lFlurryAnalytics -lTestFlight -o "/Users/mnem/Library/Developer/Xcode/DerivedData/Cartouche-gptqetvxyitumqejkandgswxgqob/ArchiveIntermediates/NAH Distribution/InstallationBuildProductsLocation/Applications/Matching Set TF.app/Matching Set TF"

clang: error: no such file or directory: '/Users/mnem/Library/Developer/Xcode/DerivedData/Cartouche-gptqetvxyitumqejkandgswxgqob/ArchiveIntermediates/NAH'
clang: error: no such file or directory: 'Distribution/BuildProductsPath/Release-iphoneos/libSparrow.a'

You can see fairly clearly that clang is failing to find a directory because of the space in the scheme name, ”NAH Distribution”. If you dig through the command text, it appears that Xcode doesn’t use quotes for the library passed to the -dead_strip command. This may be peculiar to projects with sub-projects.

Whitespace problems in 3178. Oh dear.

I’m not brave enough to venture into that battlefield, but I can at least point the weary foot soldier towards the tent of General Uncrustify and his Marvellous Xcode Contraption.

Xcode Scripting

Previous versions of Xcode allowed fairly powerful scripting. Sadly that feature has gone. It has been replaced by Behaviors instead. While they aren’t quite as flexible, they can be used to run a shell script from wherever your project has been saved.

First download the wrapper script I created for uncrustify. You can either save the script from your browser by visiting the gist page, or you can clone the gist with git:

$ git clone git://gist.github.com/1641451.git nah_xcode_uncrustify

If you download the script from your browser, don’t forget to make it executable:

$ chmod a+x nah_xcode_uncrustify.rb

Have a quick look over the script to make sure I’m not doing anything evil, like tarring all your source and emailing it to my swiss github account. Next, make sure you have uncrustify installed. If you have the nifty package manager Homebrew, then installing is as simple as:

$ brew install uncrustify

If you have another package manager installed such as MacPorts, then you can probably use that to install uncrustify. Otherwise you’ll have to build it from source and put the executable in your /usr/bin folder. See https://github.com/bengardner/uncrustify for more details.

Now add a new Behavior to Xcode. From the Xcode menu, select ”Edit Behaviors…”:

Click the + icon in the list to add a new Behavior, give it a name and scroll to the ”Run” script check box. Tick the check box and then select ”Choose script…” from the drop down list next to it:

Navigate to wherever you have the nah_xcode_uncrustify.rb script and select it.

Optionally, you can assign a keyboard shortcut to the Behavior by double clicking on the command symbol next to the Behavior name. In the screen above I’ve assigned alt-shift-f to the Behavior.

Now for a test run. Open an Objective-C project. Make sure you have it safely under version control. This is very important because uncrustify has been set to run without creating a backup of the source files. If you don’t have your source under version control and you hate what it does to your files, then there’s no going back.

Save all the open files by pressing alt-command-s (the script modifies the files on disk, you need to save first) and be sure to stage any new source file changes or whatever the equivalent is in the VCS you are using. Now run uncrustify either by selecting the Behavior you just created from the Behaviors menu, or using the keyboard shortcut you assigned.

Depending on the size of the project it may take a few moments to run. When it’s finished, you should see that the source controlled files are marked as modified and any open ones should reload with nice uncrusted spacing.

If you’re really eager to have formatted code, you can edit the ”Build starts” Behavior in Xcode and tell it to run nah_xcode_uncrustify.rb before each build.

I Hate Your Uncrusting Config, How Do I Fix It?

The first time the script is run, it creates a file called .nah_xcode_uncrustify.cfg in your home folder. To change or tweak how nah_xcode_uncrustify.rb tells uncrustify to format your source, simply edit that config file.

NOTE: the config file starts with a . indicating it is hidden, so by default Finder won’t show it. You can either open it from Terminal or else set Finder to show hidden files (how to).

The config file is fairly well documented. If it all goes hideously wrong during editing, you can always delete .nah_xcode_uncrustify.cfg from your home folder then re-reun the uncrustifying Behavior. A new default config file will be generated.

UniversalIndentGUI

If tweaking text config files isn’t your thing, you can use a great utility called UniversalIndentGUI to modify the config file. It allows you to play with values and preview the changes on the currently loaded source file.

To use it, simply download the OS X version from the UniversalIndentGUI homepage, chuck it in your Applications folder, and then when you run it, select uncrustify as the code formatter:

You can use the ”Live Indent Preview” check box to toggle between the original file and the settings you’ve selected.

If you want to use the default config from the script as a starting point, you have to tell uncrustify to modify it a bit first. The following command should do the trick:

$ uncrustify -c ~/.nah_xcode_uncrustify.cfg --universalindent > \
    ~/uigui_nah_xcode_uncrustify.ini

That will create or overwrite a file in your home directory called uigui_nah_xcode_uncrustify.ini. Import that into UniversalIndentGUI and fiddle with it as much as you want.

Whether you start from scratch or tweak the default config created by the script, you will have to save it to your home folder as a file called .nah_xcode_uncrustify.cfg. When you do, the app will ask you if you want to save a file starting with . (you do) and if you want to replace the existing .nah_xcode_uncrustify.cfg (which you also want to do).

As with manual editing, if it all goes wrong you can delete .nah_xcode_uncrustify.cfg from your home folder then re-reun the uncrustifying Behavior to recreate the default config.

Script Miscellanea

nah_xcode_uncrustify.rb has peculiarities.

It only tries to format C, C++, Objective-C, Objective-C++ and header files (*.h).

What the script considers to be the main source folder depends on the name of the project. If the project is called Bob, then the main source folder is assumed to be called Bob, and is inside the same folder containing Bob.xcodeproj. This allows you to place third party submodules outside of that folder, preventing the script from reformatting them. This is especially important for git users as modifying git submodule folders can cause issues for other people trying to checkout the code.

The script tries to be clever about the language type of header files. Objective-C, Objective-C++, C and C++ all happily use *.h files as header files. The script will search for a source file with the same name as the header file and use that extension as the language setting for the header. At the moment, it searches the main source folder for the associated source file. If it can’t find one it treats it as an Objective-C header file on the assumption that it’s probably a protocol.

The default formatting for C and C++ files may be a bit shonky and inconsistent compared to Objective-C files. I spend most of my time in Objective-C land these days, so didn’t have many test files handy.

Simple! Setup up your own VPN. Here’s how to set one up on Amazon EC2, suitable for use with most smartphones and laptops.

Pre-requisites

Similar to my Reviewboard setup guide this one assumes that you have an AWS EC2 account, and that you are comfortable with creating instances and ssh‘ing into them.

I’m assuming you are installing this on an Amazon Linux AMI EC2 instance, but it will probably work with other Linux distributions. If you’re lucky, all you will need to do is substitute that distribution’s package manager command in place of yum. For example, apt-get.

The resulting VPN supports PPTP connections which, while not the most secure, are probably the most widely supported. Android, iOS, Linux, Windows 7 and Mac OS X all come with PPTP VPN clients.

What You’ll End Up With

• 1 (one) VPN PPTP daemon (Poptop) running on the server
• n (many) VPN user accounts, as desired
• 1 (one) more secure way to access the internet

Optionally, you will also have a script which allows you to easily add new VPN accounts.

Installing and configuring PPTPD

Install all the stuff for the PPP daemon (PPTP uses this) and some development tools for compiling Poptop. As usual, you don’t type (and don’t copy) the $ symbol at the start of the line, I just use that to indicate the command prompt, but you can include the \ line splitting characters when copying and pasting:

$ sudo yum --assumeyes install \
    ppp \
    ppp-devel \
    make \
    gcc \
    gcc-c++ \
    openssl-devel \
    ntsysv

Fetch and extract Poptop:

$ mkdir ~/pptpd-install
$ cd ~/pptpd-install
$ curl -s http://kent.dl.sourceforge.net/project/poptop/pptpd/pptpd-1.3.4/pptpd-1.3.4.tar.gz | tar -xvz

Configure Poptop to use the /usr directory when it’s installed. I did this to get around a few issues with paths in the default configuration (alternatively I could have edited those, but I’m lazy):

$ cd pptpd-1.3.4
$ ./configure --prefix=/usr --exec-prefix=/usr

Next we want to patch the patchlevel.h file so that wtmp logging works. It’s a bit of a hassle, but I think it’s worth it because you can the use standard wtmp reading commands such as last venger to see a list of when and where VPN user venger connected. Handy if you ever suspect someone has been misusing your account.

This crazy command gets the current pppd version and uses sed to substitute that version in the plugins/patchlevel.h file:

$ PPPD_VERSION=$(pppd -v 2>&1 | grep -E '^.*version.*$' | gawk '{print $3}'); \
    sed -ie 's/\(.*VERSION.*"\)\(.*\)\(".*\)/\1'$PPPD_VERSION'\3/' \
    plugins/patchlevel.h

Now make and install Poptop:

$ sudo make install

Add an init script so that we can set it to start automatically later:

$ sudo cp pptpd.init /etc/init.d/pptpd
$ sudo chmod 755 /etc/init.d/pptpd

Copy the basic configuration file for pptpd and specify the local IP address range to be used for connected clients. NOTE: you cannot have more users connected simultaneously than the range specified here, which covers 100 IP addresses. The range you give it must be from the private IP address block, and must not conflict with other addresses on that machine or the LAN to which it’s connected or Bad Things may happen.

$ sudo cp samples/pptpd.conf /etc/pptpd.conf
$ echo -e "localip 192.168.69.254\nremoteip 192.168.69.1-101" \
    | sudo tee --append /etc/pptpd.conf

Now copy the sample PPP options for PPTP connections and modify it a little to specify a few useful things.

The first echo‘d line sets Google’s public DNS servers as the DNS servers used to resolve web addresses when you are using the VPN connection. If you don’t want to use Google’s public DNS servers, then you could use the public DNS servers provided by OpenDNS (208.67.222.222 and 208.67.220.220), or find your own alternatives.

The second echo‘d line adjusts the MTU and MRU. A side effect of the way VPN wraps data may cause data packets to exceed 1500 octets, causing frequent disconnects for some. Setting this to 1400 should avoid that. It’s likely you can get away with using 1492 but that was causing me some issues with my connection, so 1400 is playing it very safe:

$ sudo cp samples/options.pptpd /etc/ppp/options.pptpd
$ echo -e "\n# Google DNS\nms-dns 8.8.8.8\nms-dns 8.8.4.4\n" \
    | sudo tee --append /etc/ppp/options.pptpd
$ echo -e "\n# Make MTU/MRU a little smaller than default\nmru 1400\nmtu 1400" \
    | sudo tee --append /etc/ppp/options.pptpd

Configuring NAT and Fixing Your EC2 Firewall

That’s it for the basic PPTP configuration, but now you have to modify your iptables rules and kernel settings so that your instance knows to forward data to the correct client when connected via VPN.

First, adjust the iptables rules and save them so it all works after reboot:

$ sudo iptables -t nat -A POSTROUTING -s 192.168.69.0/24 -j MASQUERADE
$ sudo service iptables save

And now make sure your kernel knows that you want to use NAT. The sed command here is modifying your sysctl.conf so that your system remembers to enable NAT on reboot:

$ sudo sysctl net.ipv4.ip_forward=1
$ sudo sed -i -r 's/(net.ipv4.ip_forward)(.*)0$/\1\21/' /etc/sysctl.conf

In order to connect to your EC2 instance from the outside world, you will have to open up the correct port, 1723, in the security group. The easiest way to do this is from the Amazon AWS EC2 web console.

Log in to your AWS account, go to the EC2 tab, select the Security Groups section and then select the security group for the instance you have installed the VPN on:

Now add a custom TCP rule for port 1723 to make it available to everyone. If you want to limit which IP address ranges can connect to your VPN, use the appropriate CIDR source specifier. I want to access it from unknown public IP addresses so I’m setting it to accept connections from all IP address, 0.0.0.0/0:

Also add a custom UDP rule with the same details. I’m not entirely certain that VPN connections support UDP, but what the hell. NOTE: Don’t forget to click Apply Rule Changes near the bottom of the inbound rule pane before leaving the page. I often miss that.

Starting Everything Up

Now lets make sure all the services we just set up are started, and that they restart when the instance is rebooted:

$ sudo chkconfig iptables on
$ sudo chkconfig pptpd on
$ sudo service iptables restart
$ sudo service pptpd stop     # Should fail, but just in case...
$ sudo service pptpd start

Adding Users

All that’s left to do now is to add a VPN user. I prefer to add a VPN user for each device which uses VPN. If the device is ever stolen or lost, having a different user for each allows me to block access for that device by removing the user entry.

To add a user, you must append a user entry to the /etc/ppp/chap-secrets file with the correct format. The format it expects is defined as:

[username] [vpn_service_name] [password] [allowed_ip_addresses]

You can quickly add a user with the following verbose command. Remember to change USERNAME to your desired username. The section starting dd in the echo string generates a random password for the user which will be shown at the end. I recommend treating this as a once only password – just copy or email the password to the device and paste the password into your VPN client setup and tell it to remember the password. If you ever think it’s compromised, just delete the user or generate a new password. Avoid using the same password for multiple users. Don’t forget to eat the email you sent with the password. Eat your vegetables.

echo -e "\nUSERNAME pptpd $(dd if=/dev/urandom count=1 2> /dev/null | sha1sum | cut -c-32) *\n" \
    | sudo tee --append /etc/ppp/chap-secrets

To delete a user, simply remove the line with their name from /etc/ppp/chap-secrets using your favourite text editor running as root. Pro Tip: Real Beings use vim.

Using that command to add each user is a bit of a faff, so I’ve written a script to make adding users easier. It will also check if a user already exists before adding a new one and just display the password instead. Here’s a sample session where I enter the same user twice:

$ sudo ./nah_vpn_add_user.sh venger

  Creating VPN user in '/etc/ppp/chap-secrets'

              username: venger
              password: 5fac76dfc049ea0f6e7b50c0641cc8c8
      VPN service name: pptpd

$ sudo ./nah_vpn_add_user.sh venger

  ERROR: User already seems to exist in '/etc/ppp/chap-secrets'

      username: venger
      password: 5fac76dfc049ea0f6e7b50c0641cc8c8

Here’s the script as a gist on github if you want to use it. As with every script a stranger gives you, and especially since I’m making you sudo this script, examine it to make sure I’m not doing anything evil to your system (I’m not, but I would say that):

You can download it to your machine and make it executable by typing:

$ curl https://raw.github.com/gist/1626638 -o nah_vpn_add_user.sh
$ chmod a+x nah_vpn_add_user.sh

And then add users to your hearts content. Running the script with no parameters will output some help. The script will only add users – deletion is still manual as described above (delete the user’s entry in /etc/ppp/chap-secrets).

Setting Up The Device Client

This guide is already far too long, so here are some links to other guides about setting up your client or clients. The main points to remember when following these guides are:

• Protocol: Only use PPTP
• Server Address: The public address or public IP of the EC2 Instance. This can change each time you boot, so you may want to assign an Elastic IP address to the instance or perhaps use Route 53.
• Username: The username used when you created the user above.
• Password: The generated password displayed when you created the user above.
• Encryption Level: Should work as 128 bit or maximum, but you can try auto.

The guides (I don’t endorse any here and haven’t used any of the VPN services who’s guides I’ve linked here, but it’s handy information):

• iPhone guide on bestvpnservice.com
• Android guide on TechRepublic
• PPTP VPN Client Guides on Witopia
• StrongVPN support guides

Checking the Connection

Once you have your client configured, connect to your new VPN and visit:

• http://whatismyipaddress.com/

If all is well you should be able to see the site and it should say that your ISP is Amazon. Well done! You have a shiny new VPN to play with.

Points of Interest

It’s not just when you are using public hotspots that VPNs are useful. It will prevent, for example, your ISP inspecting what services you use or what websites you visit. Before you start merrily torrenting every legal thing in existence though, remember you’re paying for the bandwidth passing through your EC2 server. Also remember that while your ISP can’t see what addresses you visit, Amazon can.

Additionally, your VPN machine’s public IP address will be what the world sees. So if you set up a VPN machine at one of Amazon’s US datacenters then sites you visit will think you are a visitor from America. Or if you set one up in the EU, it will appear as though you come from Ireland.

Also, if anyone’s crazy enough to pass SOPA style regulations in your country, using a VPN in a datacenter outside your country may help, assuming Amazon, Google and OpenDNS aren’t affected directly by the legislation.

Have fun.

Next time, I’ll be more prepared… Maybe.

In the meantime, here are some lists of things.

Things that worked well this time

• Tablets totally rock. Graphics tablets. I used LD as an excuse to buy myself one. They can be found for just over a tenner (OS X drivers) and it made creating graphics a lot faster. I can’t believe I’ve not tried one before.
• Content generators are really fun to play with (cfxr, sfxr, Autotracker-Bu). I think I may spend some spare time creating a few for different purposes.
• The tight deadline forced me to handle time surprisingly well. Immediacy is a great axe for culling long tasks.
• I drew an astronaut. It didn’t look entirely shit. This makes me happy.
• Whisky helps.

Things to do next time

• Prototype more on paper/other non functional medium.
• Don’t try to optimise anything.
• If a coding problem is taking more than an hour, put a hack in.
• Play with general concepts before the compo just to have things in mind. This probably just extends to the fact I should be doing more playful/experimental coding, with no firm gameplay in mind.
• Drink more whisky.

Game to do list with some things done

• Necessary:
  • Drifting asteroids
  • Wrap around
  • Destroy asteroid
  • Mine remainders
  • Convert graphics to entities so they can collide
  • Asteroid indicator
  • intro
  • win
  • instructions
  • audio in game
• Graphics:
  • Astronaut
  • Asteroids
• Fluff:
  • Smooth wrapping
  • Star trails
  • Asteroid damage
  • Asteroid death
  • Asteroid colouring
• Refactoring:
  • Pool managers don’t need to give themselves to entities - use the names.
  • Pool managers can probably share a base class - or perhaps the SimpleObjectPool can do more work
  • Refactor text class
• Bugs:
  • Asteroids can spawn on you

Tools I used this time

In no particular order, pretty much every tool I touched:

• Sublime Text 2 (http://www.sublimetext.com/)
• Buildr-AS3 / Buildr (https://github.com/devboy/buildr_as3/http://buildr.apache.org/)
• Flashpunk (http://flashpunk.net/)
• FDT (http://fdt.powerflasher.com/)
• FlexSDK (http://opensource.adobe.com/wiki/display/flexsdk/Flex+SDK)
• lame (http://lame.sourceforge.net/)
• Homebrew (http://mxcl.github.com/homebrew/)
• Bash (http://www.gnu.org/s/bash/)
• Vim (http://www.vim.org/)
• Pixelmator (http://www.pixelmator.com/)
• SketchBook Pro (http://usa.autodesk.com/adsk/servlet/pc/index?id=6848332&siteID=123112)
• Bamboo tablet (http://www.wacom.eu/index2.asp?pid=294&spid=1)
• cfxr (http://thirdcog.eu/apps/cfxr)
• git (http://git-scm.com/)
• MacBook Pro 13 inch (http://www.apple.com/macbookpro/specs-13inch.html)
• Lion (http://www.apple.com/macbookpro/osx.html)

Food and Drink sequence:

1. Coffee
2. Scrambled egg and tattie scone
3. Coffee
4. Coffee
5. Chocolate mini roll thing
6. Coffee
7. Tangerine
8. Dry frosties
9. Tiny lindt chocolate things
10. Aubergine bake
11. Red wine
12. Whisky
13. Toasted cheese
14. Coffee
15. Scrambled egg
16. Coffee
17. Darjeeling tea
18. Tablet
19. Banana
20. Stir fry
21. Many freshly baked flapjacks
22. Whisky

Entry: Astronaut Alone

Despite my plan to stay awake after the theme announcement, I decided to get a few hours sleep and instead tasked my subconscious self with coming up with a good idea based around the theme. Much to my disappointment my subconscious decided to sleep too, so now I have to quickly come up with a game idea.

Let’s see what happens while I create a skeleton game and make some tasty breakfast.

Music to get in the mood: Tom Waits, Alice.

OS X is awesome for command line stuff, that’s why real programmers love it. But some of the defaults Apple have used make me sad. Where are all the colours? I demand my ls command be pretty and colourful! Why is Vim so bland? While we’re at it, can’t ping lick my eyeballs more?

Good news: yes, they can! I’ve stuck some tips together so I can remind myself what to do when I inevitably reinstall my system for some pointless reason, and for any new Mac users out there. It is near peak commercial season after all, and I’m sure you’ve been good little boys and girls.

Let’s start with the simple things.

Making ls and grep Colourful

Add these lines to your .bash_profile file which is in your home directory:

1
2
3
4
5

# Tell ls to be colourful
export CLICOLOR=1

# Tell grep to highlight matches
export GREP_OPTIONS='--color=auto'

Now when you use ls, folders and executables will appear in different colours from normal files, and when you use grep to find text in files, the matches will be highlighted.

You can change the colours used by ls via the LSCOLORS environment variable. For example:

1
2
3
4
5
6

# Tell ls to be colourful
export CLICOLOR=1
export LSCOLORS=Exfxcxdxbxegedabagacad

# Tell grep to highlight matches
export GREP_OPTIONS='--color=auto'

Here’s a handy website you can use to define your LSCOLORS scheme: http://geoff.greer.fm/lscolors/. It also generates LS_COLORS definitions, useful if you’re a Linux user. One thing to note, though, is that the colours you will see in your terminal depend on the particular theme you are using. Which brings me to my next tip.

Using A Better Terminal Theme

If you haven’t changed the default terminal theme you must still be gazing in to the snowy wasteland that is the default. This is insane. Programmers are incompatible with white backgrounds. Er, except in blogs. *cough*

Changing the terminal theme is marginally trickier than it should be. Here’s how you do it:

1. Go to Terminal → Preferences…
2. Select the Settings group.
3. Pick something nice that doesn’t sear your retinas.
4. At the bottom of the list box, click Default so that new terminals will open with the selected colour scheme.

Anything other than the default is a good start, but there are better themes out there than those bundled with Lion. At the moment, my colour scheme of choice is Solarized. You can get a Solarized scheme for OS X’s Terminal from here:

• https://github.com/altercation/solarized/tree/master/osx-terminal.app-colors-solarized

If you are running Lion, ignore the README at the site. All you have to do to install the theme is to open the *.terminal file. That should be enough to make it appear in the themes list in the preferences dialog, where you can set it as default.

Solarized is a great general purpose theme and there are settings for many text environments - I use it in Xcode, Sublime Text 2, Eclipse and even Vim.

Which, niftily, brings me on to my next section.

Making Vim Pretty

Much as I’ve rallied against Vim over the years, Vizio360 and Rev. Kachowski have now drugged me sufficiently to admit that it’s pretty damn nice really. If you can handle memorising π to 300 digits, then you should be fine with Vim shortcuts. On the other hand if you’re like me, you may want to use a cheatsheet.

However, we aren’t here to learn, we’re here to colourise. So, in order to make Vim a bit more colourful on OS X, copy the example vimrc file to your home directory:

cp /usr/share/vim/vim73/vimrc_example.vim ~/.vimrc

Now you can enjoy pretty colours in Vim. If you want to add Solarized as your colour theme in Vim, I recommend installing the rather fantastic pathogen.vim in your .vimrc (instructions) and then follow the instructions for “Option 2” in vim-colors-solarized README.

Making Nano Pretty

If Nano is your Terminal text editor weapon of choice, then you can enable syntax colouring by uncommenting the syntax files referenced in /etc/nanorc. First, open it for editing:

sudo nano /etc/nanorc

Move to the bottom of the file and then remove the # character at the beginning of the lines which include other *.nanorc files. For example, change:

1
2

## Nanorc files
#include "/usr/local/share/nano/nanorc.nanorc"

To:

1
2

## Nanorc files
include "/usr/local/share/nano/nanorc.nanorc"

Further Eyeball Licking via Homebrew

For the next tip, I recommend using Homebrew as the method of installation. If you aren’t using Homebrew yet, you probably should be. It’s by far the Most Awesome package manager available for OS X. So go install it:

• https://github.com/mxcl/homebrew/wiki/installation

Installed? Good. Let us continue.

Generic Colouriser

Generic Colouriser is a great utility which can be used for colourising many different types of output and log files. If you installed Homebrew , installing grc is as simple as typing:

brew install grc

NOTE: If you followed the first tip and created a .bash_profile, rather than appending the command to load grc to your .bashrc, you want to append it to your .bash_profile file instead:

echo 'source "`brew --prefix grc`/etc/grc.bashrc"' >> ~/.bash_profile

If you are confused as to why, it’s because the logic Bash uses for loading these files is non-obvious. For a good description of the load sequence, read Execution sequence for .bash_profile, .bashrc, .bash_login, .profile and .bash_logout by Ramesh Natarajan.

After you have added that line to your .bash_profile, either start a new session, or reload the profile:

source ~/.bash_profile

Now when you use certain commands such as traceroute, the output should be colourised:

Or you can call tail and head using grc to colourise log output:

That’s all Folks!

Well, that’s all I have for now. If anyone has any other good ones, stick them in a comment below.

Pre-requisites

This guide assumes that you have an AWS EC2 account set up, and that you are comfortable with creating instances and SSH’ing into them. There are plenty of other guides out there to take you through those basics.

What You’ll End Up With

• 1 (one) EC2 server micro instance running with a 32-bit Amazon Linux AMI
• 2 (two) VCS installed on the server: subversion and git
• 1 (one) Data Volume containing:
  • 1 (one) ReviewBoard site
  • 1 (one) PostgreSQL database
• 1 (one) Glowing feeling of a Job Well Done

The precise security configuration and so forth for the instance is likely to vary depending on what your preferred policies are.

Creating The Instance

Sign in to the EC2 web console and select “Launch Instance” for the region you prefer. I’m using US East because it’s cheap.

The following few screens show the Quick Launch instance wizard thing which seems to have just sprung up on the site, but you should be able to work out what to do in the normal/classic wizard.

The important points are:

• Use a Basic 32-bit Amazon Linux AMI
• Use a micro instance

Give your instance a sane name and create and download a new key pair for it. You can use an existing pair, but I tend to use a new key pair for each image for finer grained access control. Make sure it’s the 32-bit Amazon Linux AMI which you choose.

In the next screen, you may find it useful to add termination protection and check that it’s selected a micro instance.

Next, set up an new security group for it. You can’t change the security group later (although you can add and remove ports in the group), so make sure you create a new one unless you are certain you want to share an existing one. Make sure SSH and HTTP ports are open and accessible from your current public IP address. If in doubt, you can make the ports accessible from any address for the moment by specifying a source of 0.0.0.0/0.

That’s the basic instance set up. Click “Save details” and then you should see the launching screen:

Close it. Now create the volume to use for data. Expand the “Elastic Block Store” menu at the left side if it isn’t already and select Volumes. Click the “Create Volume” button and make it about 1 GiB or so, depending on the size of the repositories you’ll store on it:

Now all that remains to do is to attach it to the instance you just launched. Select the new volume and click “Attach Volume” and attach it to your fresh instance:

That’s the basic setup done. Now on to installing bytes.

Setting Up The Instance and Data Volume

SSH into your server:

$ ssh -i ~/.ec2/tools-reviewboard.pem ec2-user@ec2-107-22-136-39.compute-1.amazonaws.com

       __|  __|_  )
       _|  (     /   Amazon Linux AMI
      ___|\___|___|

See /usr/share/doc/system-release/ for latest release notes.
There are 14 security update(s) out of 18 total update(s) available
[ec2-user@ip-10-116-186-53 ~]$

The first thing you’re likely to notice is that the instance requires some updates already, so we will install those.

NOTE: for the rest of the article, I’ll just show the commands to run without showing the output, except where the output is important or interactive. Also, the $ at the start of a line indicates a command to type - you don’t type the dollar, but type the rest…

$ sudo yum --assumeyes update

That should update the basic image to the latest versions of the pre-installed packages.

Now, before we go any further, lets set up the data volume. You should have already created a new volume and attached it to the ReviewBoard server instance. If this is the first time you’ve used separate data volumes (something you should really get into the habit of using), the thing to remember is that it’s sitting as a raw, unformatted block device initially. In order to use it, it needs to be partitioned, formatted, and then mounted.

First, format it. I’m assuming that your device is /dev/xvdf. If it isn’t, adjust the instructions as appropriate. Run fdisk on the device. It’s interactive so the following few steps include the console output for clarity.

$ sudo fdisk /dev/xvdf

Device contains neither a valid DOS partition table, nor Sun, SGI or OSF disklabel
Building a new DOS disklabel with disk identifier 0xb6d71f5e.
Changes will remain in memory only, until you decide to write them.
After that, of course, the previous content won't be recoverable.

Warning: invalid flag 0x0000 of partition table 4 will be corrected by w(rite)

WARNING: DOS-compatible mode is deprecated. It's strongly recommended to
         switch off the mode (command 'c') and change display units to
         sectors (command 'u').

Command (m for help):

Enter m in order to show a menu.

Command action
   a   toggle a bootable flag
   b   edit bsd disklabel
   c   toggle the dos compatibility flag
   d   delete a partition
   l   list known partition types
   m   print this menu
   n   add a new partition
   o   create a new empty DOS partition table
   p   print the partition table
   q   quit without saving changes
   s   create a new empty Sun disklabel
   t   change a partition's system id
   u   change display/entry units
   v   verify the partition table
   w   write table to disk and exit
   x   extra functionality (experts only)

Command (m for help):

Enter n to create a new partition.

Command action
   e   extended
   p   primary partition (1-4)

Enter p to create a primary partition.

Partition number (1-4):

Enter 1.

First cylinder (1-261, default 1):

Press enter to select the default.

Last cylinder, +cylinders or +size{K,M,G} (1-261, default 261):

Press enter to select the default. The actual value for the default will depend on how large a volume you created with the Amazon web console. This is a 2 GiB volume.

Command (m for help):

Enter w to write the changes to the disk. The partition will be created and you should see:

The partition table has been altered!

Calling ioctl() to re-read partition table.
Syncing disks.

The next step is formatting the partition. Use mkfs to create a new ext4 partition:

$ sudo mkfs -t ext4 /dev/xvdf

Now create an empty folder in /mnt for the partition, and edit /etc/fstab to mount it on boot.

$ sudo mkdir /mnt/rb.data
$ sudo nano /etc/fstab

The entry to add to fstab should look like this:

/dev/xvdf     /mnt/rb.data   ext4    defaults    0   0

If you chose a different folder, filesystem or have it available on a different device, remember to use your values here.

The final task is simply to mount the volume, and then run df to check that it has mounted:

$ sudo mount /mnt/rb.data
$ df -h

Filesystem            Size  Used Avail Use% Mounted on
/dev/xvda1            7.9G  1.1G  6.8G  14% /
tmpfs                 302M     0  302M   0% /dev/shm
/dev/xvdf             2.0G   67M  1.9G   4% /mnt/rb.data

If you don’t see your volume in the Mounted on column, check all the previous steps worked.

Installing Lots Of Stuff

Now to install all we need for ReviewBoard Cut and paste this full block into the command line:

$ sudo yum --assumeyes install \
    ant \
    ant-apache-regexp \
    autoconf \
    gcc \
    gcc-c++ \
    git \
    httpd \
    icu \
    java-1.6.0-openjdk-devel \
    libicu \
    libicu-devel \
    libjpeg \
    libjpeg-devel \
    libpng \
    libpng-devel \
    lucene \
    make \
    memcached \
    mod_wsgi \
    patch \
    postgresql \
    postgresql-devel \
    postgresql-server \
    python-devel \
    svn \
    telnet

Now to install the python prerequisite packages:

$ sudo easy_install \
    python-memcached \
    pycrypto\>=2.4.1 \
    psycopg2 \
    django-storages

Pyconfig will probably spew out lots of warnings, but it should be OK to ignore those.

Next, install ReviewBoard:

$ sudo easy_install ReviewBoard

Now you have a choice – install pylucene so that you can have full text search in ReviewBoard, or skip it and just move on to setting up the database.

Installing Pylucene (optional)

Although you don’t need Pylucene installed, it’s nice to have it because of the search features it adds to ReviewBoard. However, it can be a bit of a bugger to install, so although these instructions work for now, if they’re broken by the time you read this, you may want to skip it.

Brave? Then on-wards…

Create a folder to build and install Pylucene from, download and extract the archive:

$ mkdir pylucene
$ cd pylucene
$ curl apache.mirror.rbftpnetworks.com/lucene/pylucene/pylucene-3.4.0-1-src.tar.gz | tar -xvz

tar may take a while to extract the large archive being fed to it, but once it’s finished, compile jcc:

$ cd pylucene-3.4.0-1/jcc
$ sudo env JCC_JDK=/usr/lib/jvm/java-1.6.0-openjdk NO_SHARED=true python setup.py build
$ sudo env JCC_JDK=/usr/lib/jvm/java-1.6.0-openjdk NO_SHARED=true python setup.py install
$ cd ..

Now to build Pylucene. First you have to edit some values in the Makefile, so open that:

$ nano Makefile

And then paste these lines at the top of the very top of file, before the block comment:

JAVA_HOME=/usr/lib/jvm/java-1.6.0-openjdk
PREFIX_PYTHON=/usr
ANT=ant
PYTHON=$(PREFIX_PYTHON)/bin/python
JCC=$(PYTHON) -m -m jcc.__main__
NUM_FILES=3

Now you should be ready to build it:

$ make

This can take a long time (30 minutes or so), so go get some tea. After it’s complete you can now install it:

$ sudo make install

That’s Pylucene dealt with. On to the database.

Creating the ReviewBoard Database

The database will also reside on the data volume. This setup assumes that you only want one PostgreSQL cluster. I’ve no idea why you’d want more than that, but if you do, you’re advanced enough to figure out how to make the next few steps fit into that configuration yourself.

First, create a folder for the database, and give it to the postgres user:

$ sudo mkdir -p /mnt/rb.data/db/pg
$ sudo chown postgres:postgres /mnt/rb.data/db/pg

And now set that data location in the postgres conf file:

$ echo "PGDATA=/mnt/rb.data/db/pg" | sudo tee /etc/sysconfig/pgsql/postgresql

With that sorted, we can now tell PostgreSQL to create the cluster:

$ sudo service postgresql initdb

Next, we want to change the database authentication method for connections from 127.0.0.1 in order to allow ReviewBoard to connect. To do this, edit /mnt/rb.data/db/pg/pg_hba.conf and change the method used for 127.0.0.1/32 from ident to md5:

$ sudo nano /mnt/rb.data/db/pg/pg_hba.conf

Near the bottom of the file, change the line host all all 127.0.0.1/32 ident to host all all 127.0.0.1/32 md5.

All that’s left is to start it and then create the empty ReviewBoard database:

$ sudo service postgresql start
$ sudo su postgres -c "createdb reviewboard"

Now create a database user for reviewboard. I’m going to be lazy here and create them as a superuser because I can’t be arsed setting up their correct priviledges. Don’t be as stupid as I am:

$ sudo su postgres -c "createuser -sP reviewboarduser"

Be sure to give them a decently strong password.

Now, in case you have to reboot your server, you’ll want to make sure things start on boot. To do this, you can use ntsysv:

$ sudo ntsysv

Use the cursor keys to move, space to select, and tab to move between areas. Make sure you enable httpd, memcached and postgresql.

Just to make sure it’s all running, reboot the instance.

$ sudo shutdown -r now

This will kick you out of your session, but just give it a minute or two and then log back in. The address of your server should still be the same at this point, but if it isn’t, you can find it again from the AWS web console.

After you’ve logged back in, check that the webserver is running to make sure the ntsysv command above worked. The easiest way to do this is by using telnet to request the default page from the local webserver:

$ telnet 127.0.0.1 80
GET /

You should see a screed of HTML returned. If you see a connection refused or timed out, go back to the ntsysv section above and try again. Note that ntsysv doesn’t start the services for you, it just marks them to start on boot, so you have to perform that shutdown step to test it.

Creating A ReviewBoard Site

That’s pretty much the server setup now. All that remains is to create a review board site. There’s a handy interactive script to do this. Create a directory for the site and then run the interactive script:

$ sudo mkdir -p /mnt/rb.data/www
$ sudo rb-site install /mnt/rb.data/www/reviewboard.huzutech.com

The script is fairly informative, but if you need more information, see the ReviewBoard documentation for creating sites:

• http://www.reviewboard.org/docs/manual/1.6/admin/installation/creating-sites/

Basically, the only thing to remember is that you are using a postgresql database, memcached, apache and wsgi.

Give ownership of the web directory to Apache, and add the generated site config to the apache conf folder, then restart apache:

$ sudo chown -R apache:apache /mnt/rb.data/www
$ sudo ln -s /mnt/rb.data/www/reviewboard.huzutech.com/conf/apache-wsgi.conf /etc/httpd/conf.d/XX_reviewboard.huzutech.com.conf
$ sudo service httpd restart

Note that the link name starts with XX_. This is important so that it’s loaded in the correct order.

Finished!

That’s it! You should be able to see your server if you visit the public address in a web browser. There are several post setup things that you probably want to do, such as setting up a proper vhost file, locking user registration and setting up projects and repositories.

If you installed lucene, don’t forget to add the lucene index updating cron job to cron, otherwise you’ll get errors when you try to search and it can’t find the search index files.

Check out the guides on the main ReviewBoard website for more information about all that. Then sit back and learn from all the glorious code reviews you see rolling in.

UPDATE: Sparrow 1.3 has now been released and it includes an updated and significantly enhanced AppScaffold project which makes most of the reasons to use SparrowBones redundant. I recommend you use the official AppScaffold project as a starting point now, rather than SparrowBones.

Sparrow-Framework is pretty awesome for quickly chucking together iOS games. But wouldn’t it be nicer if there was a handy Xcode 4 template to start from?

Your wish is my command! Presenting SparrowBones, a beautiful handcrafted Xcode 4 template:

• https://github.com/mnem/SparrowBones

It’s fairly simple and slightly hacky. Unlike the AppScaffold, which comes with Sparrow-Framework, it supports automatic rotation (because I always hold my iPhone the wrong way) and unit testing (because I’m crazy like that). The README.md file in the project should guide you through the installation.

If you use it, you’ll notice 2 template projects in the SparrowBones section - “Game with Sparrow source copied” and “Game with Sparrow source linked”. The only difference between them is that with the copied source the Sparrow Framework source code is copied into your new project. If you choose linked, the Sparrow Framework source is connected to your new project through your SPARROW_SRC variable in Xcode.

Why 2 templates? Mainly because the Xcode template format is undocumented and I haven’t quite worked out how to include a linked project easily in a template. This means that you have to tweak a few things when you use a linked project unfortunately. But never fear! This post has a handy guide to getting it working a little further down.

Although it’s recommended that you use the template with the linked Sparrow source (because it’s a lot easier to update Sparrow-Framework that way), you may actually want to have a project with the Sparrow source copied. For example, if you are doing some hardcore hacking of the source this is a good option, or if you want to create a self contained project you can archive and mail to people it’s great for that too.

On with the guide!

Setting up linked source SparrowBones projects

Choose the right one:

Fill in some blanks and choose which device family to aim for. IMPORTANT: Uncheck “Use Automatic Reference Counting” (Sparrow doesn’t work with that yet). I also uncheck “Use Storyboard” because I haven’t learned how to use those:

Next, we have to fix that red Sparrow.xcodeproj reference. Select it and press Alt-Cmd-1 to show the inspector:

Then change it to be relative to your linked Sparrow Framework source. NOTE: the link name may be different for you – it depends on what you entered when setting it up (if you haven’t set a link to the source up, do that now before continuing):

If you look back at the Project navigator you should see Sparrow.xcodeproj as an expandable project:

This is important. If it doesn’t have the arrow, you will have to quit Xcode and then re-launch it and open the project. Sometimes Xcode is a bit slow about picking up path changes.

If that all important triangle is next to Sparrow.xcodeproj, you have one more thing to do. Xcode needs to know that it has to build Sparrow.xcodeproj as a dependency of your game target. Here’s how: 1) Select Sparrow.xcodeproj in the project navigator, 2) select your game target in the editor window, 3) go to the Build Phases section, 4) expand the target dependencies and click the plus.

In the window that appears, select the Sparrow target:

Select Add. If my instructions worked, you should now have Sparrow as a dependency:

That’s it! Simple once you know how. You should now be able to run the project in one of the simulator targets and you will some see Exciting Boxes on the screen. Awesome. Well done you!

A Note on Unit Tests

If you want to write unit tests, and I know you do, you will have to add all the Frameworks in the frameworks folder to your <AppName>Tests target, otherwise you will get lots of Mach-O linker errors:

So I’ve been thinking about this, and pending further evidence I’m going to assume that the story about vodka soaked tampons (see KPHO) is rubbish. Every so often it seems to make the rounds (see Snopes). Here’s why I’m an unbeliever.

A tampon will soak up about 15ml-18ml (see About.com) of liquid which is a pathetic dram. Alcohol is not blood, but for this thought experiment it’ll do. I can test it later. Regardless, it’s likely much less than a shot.

In addition tampons are designed to retain liquid rather than release it, so there’s a reasonable chance that it wouldn’t release the booze very quickly.

Now, as far as I can discover, a stomach absorbs about 20% of consumed alcohol (see Brown University), the rest is through your intestine. For the moment I’ll make the assumption that vaginal walls absorb alcohol at a similar rate as the intestine. Although this probably isn’t accurate due to the the quantity of blood vessels, it doesn’t matter because the rumour generally also includes men who, it is whispered, stick it up their bum.

It follows, I think, that if I drink a Polite Dram (about 35ml - 40ml), 80% of that will end up in my intestines, which is 28ml - 32ml. That’s about double what this mythical Tampon Delivery Mechanism would offer. Also, drinking the Polite Dram on an empty stomach (remember kids: eatin’ is cheatin’) will whap that Double Tampon Quantity right into my intestine, an organ which exists to diffuse things into my blood vessels and make embarassing noises during quiet moments.

Therefore I conclude that ingesting a Polite Dram on an empty stomach may be up to twice as efficacious as Tampon Delivery, plus it’s easier to buy in rounds. Have you ever tried getting a tampon in a pub? Those bloody machines never work.

Right, pending volunteers for double blind tests, I’ll get back to my coding with a nice Balvenie Doublewood. In a glass.

Shuffling is just like buses. You sit about being deterministic for years, and then all of a sudden, you need some random shuffling on two platforms at once.

As a follow on from my previous post on shuffling AS3 arrays, here’s the same algorithm implemented as a category addition to NSMutableArray for all your easy array shuffling needs.

To use it, download the method and header files, add them to your project and them simply include the header file wherever you you want to shuffle anNSMutableArray:

1
2
3
4
5
6
7
8
9

 #import "NSMutableArray+Shuffle.h"

- (NSMutableArray*)myAwesomeFunction
{
  NSMutableArray* array = [NSMutableArray arrayWithObjects: @"Fred", @"Bob", @"Alice"];
  [array shuffle];

  return array;
}

Grab it while it’s hot from github:

For some reason, there doesn’t seem to be any sane example of shuffling arrays in ActionScript blogland. I discovered this when I was trying to send a lazy link to someone of an implementation rather than write the code myself. Oh, by sane I mean vaguely efficient, not overusing crazy Math.floor or Array.slice functions.

Shuffling data isn’t a new problem, but people seem to always want to re- invent things. Alas, it’s often re-invented poorly. Here’s a nice vintage shuffling algorithm for you from 1964 (although the idea is based on a method from 1938. History rocks.). Example usage is in the huge header comment:

Feel free to extend the class to support typed Vectors. Sadly, you have to implement each Vector type yourself as AS3 currently has no non-hacky method of implementing template functions.

Upgrading an OS is always fun, especially when you go for a clean install and forget about the 40 million really useful applications you need to make your life comfortable. Then you run into all the subtle changes that break the way you did things before…

I ran into one of those with FDT 4.5 on Lion recently. Suddenly, my FDT Ant build scripts no longer picked up my FLEX_HOME environment variable. After much wailing and gnashing of teeth, it turns out that simply exporting a variable from your .bash_profile isn’t enough for some GUI applications. I’m not certain why yet, but FDT (or Java) is now launched by a service called launchd (man, wiki). To make environment variables available to processes opened by launchd, you must set them using launchctl setenv VAR $VALUE.

So, for example, the relevant part of my .bash_profile looks like this:

Add that to your .bash_profile, or type it into a terminal to test it, relaunch FDT and it should all work. If you want to check what variables are available in your ant file, don’t forget that you can add an <echoproperties/> tag to dump them to stdout.

In light of that, I’ve never been particularly happy with the standard AS3 FlexUnit listener you get when you aren’t running inside FlashBuilder. Trace statements are so last century. Also, they give me flashbacks to embedded C programming, and I have to go and brick a firmware. I’m running out of phones.

So, in place of trace, I present: Green Dots (a.k.a. FlexUnit Visual Listener):

They’re totally contemporary, work with any dress and are a stylish addition to every modern CI system. They even give you some useful error information when you roll the mouse over the test result dot (which you can copy to the clipboard by clicking. Awesome!).

Bonus! It’s simple to use too. Here’s an example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

package
{
    import noiseandheat.flexunit.visuallistener.VisualListener;

    import org.flexunit.internals.TraceListener;
    import org.flexunit.runner.FlexUnitCore;
    import org.fluint.uiImpersonation.VisualTestEnvironmentBuilder;

    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;

    [SWF(backgroundColor="#000000", frameRate="120", width="800", height="600")]
    public class TestRunner extends Sprite
    {
        private var core:FlexUnitCore;
        private var listener:VisualListener;

        public function TestRunner()
        {
            core = new FlexUnitCore();
            VisualTestEnvironmentBuilder.getInstance(this);

            listener = new VisualListener();
            addChild(listener);
            core.addListener(listener);

            // Add a trace listener too if you want some trace output core.addListener(new
            TraceListener(800, 600));

            core.run(NoiseAndHeatSuite);

            addEventListener(Event.ADDED_TO_STAGE, addedToStage);
        }

        protected function addedToStage(event:Event):void
        {
            removeEventListener(Event.ADDED_TO_STAGE, addedToStage);

            stage.align = StageAlign.TOP_LEFT;
            stage.scaleMode = StageScaleMode.NO_SCALE;
        }
    }
}

It’s similar to the normal FlexUnit runner example, but with the addition of the VisualListener and stage tweaks.

Grab it while it’s hot from: https://github.com/mnem/flexunit_visual_listener.