This was a personal project where I brought together some knowledge of OpenGL, from my days at digital agencies in London, on to modern devices such as the iPhone 4S and the iPad 2. This app is very graphically intensive and involves plotting a large number of particles using a meta-ball technique. The main aim of this app was to show that a seemingly complex app could be designed, built and deployed in under 2 months by constraining scope and focusing on user experience.

The app has just been released and is available on the iTunes App Store.

So, I use GitHub as my main source code repository, but I set up a second repository on the server I want to deploy to, normally in my home directory. First create an empty Git repo:

$ git init --bar ~/git/my-repo.git

To trigger a deployment on a push, we define a post-receive hook in this new repository. Hooks allow the you took invoke behaviour on a variety of git events, in this case we are interested in when the repository has successfully received a push.

$ vi ~/git/my-repo.git/hooks/post-receive

This is just an example, but the contents of the post-receive hook might look like this for a rack/passenger based web application:

#!/bin/bash

cd /var/ww/my-site
unset GIT_DIR
GIT_WORK_TREE=/var/ww/my-site git pull
GIT_WORK_TREE=/var/ww/my-site git reset --hard
GIT_WORK_TREE=/var/ww/my-site git submodule update -i
bundle install
touch tmp/restart.txt

Of course, this file can contain whatever you want, just make sure you set the executable bit on the file:

$ chmod +x ~/git/my-repo.git/hooks/post-receive

All that remains is to push your local repository to the new git repo on your server:

$ git remote add prod ray@my-server.com:~/git/my-repo.git
$ git push prod master

This is just a simple example, but because you are executing a script on the server, you can basically perform any functionality you like. I don’t know whether this would be a good idea in a large-scale production environment, but the key here is to make the deployments as simple and easy as possible to encourage smaller and more regular changes. Backing it with git enables a basic form of rollback, but anything that is not controlled by git, i.e. database schema state, will still need to be managed separately.

The source is available on github, but it is available to install from ruby forge by using the command:

$ gem install xcoder

A simple use-case would be to find the only project in a directory, update the project’s build number and then invoke a build:

# Find the first project in the current directory
project = Xcode.find_projects.first

# Find the target called "TargetName"
target = project.target(:TargetName)

# Find the configuration called "Debug"
config = config.config(:Debug)

# Update the build number
config.info_plist do |info|
    info.version = ENV['BUILD_NUMBER']
    info.save
end

# Clean the build for this target's configuration 
config.clean

# Build the target using this configuration
config.build

# Create an IPA for this target's configuration signed using the provided identity and embed the provided profile
config.package :sign => 'iPhone Distribution: Developer Name, :profile => 'Provisioning/ProfileToEmbed.mobileprovision'

It’s early days yet, but I plan on adding support for OCUnit => JUnit output mapping (like the xcode-hudson-plugin) as well as loading provisioning profiles from the file system and generally manipulating the project file. Please send issues/feature requests to the Xcoder page on github

In order to encapsulate the observation, a new instance of an object that implements the callback method signature is created for each observation and passed back to the caller. It is expected that this object is retained by the caller until the caller wants the observation to end. I’m not totally convinced that this is the best pattern, but it is at least concise and uses the existing language semantics. So, on to a simple example:

As you can see, this is very terse and means that all the code to react to changing properties can be encapsulated in the one place. The returned value is being set to a retained property so that the binding does not get dealloc’d. This observation will remain in effect until you release the returned object by setting the property to nil (as in the example) or, indeed, set the property to any other binding.

I would be very interested in feedback about whether this works for you.

The plugin is mature enough to support building, versioning, IPA packaging and basic testing view OCUnit.

Download

You can download a pre-built binary of the latest snapshot build (0.1-SNAPSHOT) using the latest code from github. Look below for source code and build instructions.

Issue Tracking

Please report any issues and feature requests via GitHub’s issue tracker.

Features

Versioning

This builder can invoke agvtoool to dynamically update the CFBundleVersion with the current build number using a configurable pattern. For example, you could specify a pattern of “1.1.{BUILD_NUMBER}” which, for build #456, would result in the current version (CFBundleVersion) being set to 1.1.456

Building

The target (optional), configuration (e.g. Debug, Release) and SDK (optional) can be specified in the per-project config along with whether to perform a clean before the build phase.

Packaging

The builder can be used to package the .app into a .ipa. Since a .app is actually a directory, it can be awkward to work with and, especially, distribute. We can simplify this by packaging the .app into a single .ipa file, which is just a zip file with a well-known internal structure

Unit Testing

This plugin will listen to the xcodebuild output when running OCUnit tests and write out JUnit-format test reports that Hudson can understand. Hudson will then use these to publish test failure reports and graphs.

Gotchas & Limitations

• Obviously, the build machine has to be an OSX machine with XCode developer tools installed
• Certificates, Identities and Provisions must be installed on the build machine separately
• When code-signing, a prompt may appear on the build machine asking whether to allow keychain access. This will block the build until it is dismissed. Just select ‘Always Allow’ the first time and it shouldn’t need to ask again.
• If you connect via ssh to the OSX slave, you will need to execute ‘security unlock-keychain’ once you connect to allow the build tools access to the keychain. The alternative is to use the JNLP slave agent
• Derek Stutsman reports that “If your project has the base SDK set to iPhone simulator, the build will crash with a nullreference exception”

Building

The source code is hosted on GitHub and made available under the GPLv2 license.

This is a maven project that uses the hudson maven plugin. You will first need to add the following to your ~/.m2/settings.xml:

 
 

org.jvnet.hudson.tools 
   
 

To clone the repository and build the .hpi, follow these steps:

 
# Clone the repository
$ git clone git://github.com/rayh/xcode-hudson-plugin.git

# Go into the cloned repository
$ cd xcode-hudson-plugin

# Build the project
$ mvn install

The xcode.hpi will be in the target/ directory.

Installing

I am awaiting commit access to the hudson repository on java.net so that I can use the official hudson to build the plugin as well as hosting the plugin in the official repository. Until then, you will have to install it by manually uploading the xcode.hpi to hudson. Simply go to ‘Manage Hudson’ > ‘Manage Plugins’ > ‘Advanced’ > ‘Upload Plugin’ and select the xcode.hpi that you either built or downloaded and then select ‘Upload’.

Usage

Setting up a build step

Add the XCode build step to a free-style project and set the target (e.g. MyApp), configuration (e.g. Release) and check the build IPA and update version number options. This will give you a single, versioned .ipa file. You can also select to clean the project before a build; while this will make sure that the project is starting from a clean state, it will make large projects take a lot longer.

Setting up a unit test step

Add the XCode build step and this time specify your unit test target (e.g. MyAppTests), configuration (e.g. Debug) and the SDK (e.g. Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator4.1.sdk/). Leave all the checkboxes unselected. The SDK needs to be supplied here as the unit tests will only be run when building under the simulator’s SDK.

Check the “Publish JUnit test result report” option in the project config and set the value “**/test-reports/**.xml” under “Test report XMLs”. This will tell Hudson to pick up the JUnit-format test reports.

Acknowledgements

The xcodebuild/OCUnit output parsing was inspired and based upon Christian Hedin’s ocunit2junit.rb script.

Jarrod McIntyre provided support for overriding the marketing version number

I have also built a iPhone radio app that integrates the same service and gives users access to the live AAC+ stream as well as the programme guide. It is available from on the iTunes App Store

[From their website] For 25 years, PBS-FM has been a beacon of independent, freeform, passionate, real and unpretentious radio. PBS is a champion of specialist and under-represented music and is proudly non-corporate, anti-fashion and wanker-free.

www.pbsfm.org.au

I followed the post’s suggestions and updated my availability date and suddenly the app was marked as “Pending Contract”. However, all my apps are currently freebies and so there are no contracts in place, nor should there be. I filled out as much of them as I could (bar registering for GST), but to no avail.

I seem to be at the whim of Apple’s famously distant customer service right now.

Update: I eventually solved this by releasing a new version of the app, the process seemed to fix the existing app as it immediately reappeared in the app store while the new version was awaiting approval. Go figure!

• Use of Quartz and CoreGraphics to provide a intuatively interactive and highly dynamic image gallery. Utilizing pinch, drag and rotation gestures to manupulate images and basic physics to add momentum.
• Extensive testing, bug-hunting and memory-leak plugging in order to allow the app to run constantly for 12+ hours on over 50 devices for every day of the motor show
• Implemented a continuous integration system using Hudson, xcodebuild and various shell scripts to provide continuous build feedback and versioned artifacts.
• Implemented an Agile process to manage and make visible the outstanding tasks. I also started to measure velocity to better estimate upcoming work.

I also found a very slick library called three.js which I used to create the header animation on rayh.com.au. It provides a basic set of 3d concepts such as points, lines, renderer, camera, etc which can use to draw and animate basic 3d scenes. There is no special loop function, you just use setInterval to trigger your animation to update every once in a while.

Biting the bullet, I decided that I needed some sort of server-side scripting. By day, I mainly use Java and sometimes Ruby. So my choices seemed to be Java, Ruby or PHP. Many moons ago, I was a PHP developer and I bailed out of that technology in favour Java. For me, PHP just sucks in far too many areas for me to adopt it for a one-off tiny website, but the reasons why is another story. Java seems way to heavyweight and verbose for my needs and so Ruby seemed like the natural choice.

Previously I had used Rails for projects, but it’s full-stack solution was still too much for my needs as my site has no database access. This led me to look at Sinatra, a super lightweight and declarative approach to a web application. I simply converted my existing html file to a .erb and told Sinatra:

require 'rubygems'
require 'sinatra'

get '/' do 
  erb :index
end

This code is pretty much all that is needed to get up and running. It tells Sinatra that when a user accesses the root of the site using GET, serve the index.erb file from the views/ directory. This approach allowed me to just add the features I needed to perform the simple set of requirements I had rather than trying to convince Rails to do less.

When it came to deploying the app, I used Passenger (AKA mod_rails) with apache which was an absolute breeze. I highly recommend this approach if you need something more powerful than simple javascript & html without resorting to full-stack web application frameworks or ugly php scripts embedded in html.

yellowpages.com.au

For example, imagine you have a series of filters, all of which may, or may not, add constraints or expressions to your query. Each filter will need to append it’s own SQL to the end of any previously generated SQL and may even need to introspect the existing SQL to determine if its doubling up on statements or resolve potential conflicts.

With Criteria this becomes simpler. For example:

criteria = Criteria.new
criteria.and do |c|
  c.or User.role.eq(:admin)
  c.or User.active.eq(false)
  c.or User.createdAt.gt(10.hours.ago)
end
criteria.and do |c|
  c.or User.role.eq(:editor)
  c.or User.active.eq(true)
  c.or do |c2|
    c2.and User.createdAt.gt(20.days.ago)
    c2.and User.createdAt.lt(10.hours.ago)
  end
end
users = User.find(:all, criteria)

We could, at any point, introspect the state of criteria by calling:

criteria.ands.each do |c|
  put "AND #{c}"
end
criteria.ors.each do |c|
  put "OR #{c}"
end

And, finally, we can remove arbitrary bits of criteria:

criteria.ands.delete_at 2

I hope to have a release out very soon, but for the time being some more examples and API docs are on the Criteria project page on RubyForge

trigger on (new Button) { button.putClientProperty("Quaqua.Button.style", "placard"); }

The above code allows me to inform the underlying Quaqua LookAndFeel that I wish to use the placard button style. If I wanted to use this selectively, I would have to subclass Button.fx, provide an additional attribute (say style) and then apply the property if the attribute is set.

Obviously, you need to know the internal name for the Swing component you are trying to access, this API documentation is pretty helpful for that.

[From their website] Smesh pulls it all together. Not just mainstream sources but blogs, both established and brand spanking new ones. Because if there’s any brand-spanking going on where your clients are concerned, you want to know about it and Smesh wants to find it.

smeshup.com

First, download and unzip the Ecipse + J2EE package from http://www.eclipse.org/downloads/. You do not need to ‘install’ Eclipse as such, just put the uncompressed directory somewhere logical (/Applications on a Mac, for example).

1. Launch Eclipse
2. Select: Help -> Software Update -> Final and Install.
3. Select Search for new features to install
4. Check the Europa Discovery Service
5. Select Add Remote Site

1. Type in name: Aptana (For javascript support)
2. Type in url: http://update.aptana.com/install/3.2/
3. Select OK

Phew, so after all that, you should have an Eclipse IDE set up to support PHP, Ruby, Rails, Javascript, Java, Hibernate and Subversion. You can, of course, select many other tools from the Europa discovery site for other development tools, graphical editing and the like.

It would be nice to have a small js library that allowed you to dynamically instantiate and destroy embedded, hidden applets.

Basically, you can annotate your classes with url’s describing the RDF namespace of the class or property. You can then use SPARQL to query/retrieve the beans, and serialize them to/from XML. Serialization can be acheived through the Sesame framework.

Elmo User Guide

Additionally, there is another project, JRDF, that builds upon Sesame and Jena. I have yet to use it, but sounds like in encompasses the best of all worlds.