smartbomb - Home

Rails Camp Three

2008-06-25T12:42:00Z

RailsCamp 3 just finished, and it was another fantastic weekend of hacking with mates.

what a kerfuffle!

You’ve probably heard by now that Ben (the organiser of RailsCamp) and Kaz’s munchkin Liam came six weeks early. We’d been talking about babies coming early just the night before, since my son Toby was five weeks early. It was an eerie shock to hear that nearly the same thing had happened to Ben & Kaz! Liam is doing well, but is still in hospital for a little while.

The upshot of this twist was that Glenn Davy and I ended up running the camp. It was a pleasure as most of the heavy lifting had already been done by Ben. Thanks so much to Glenn and Ben for making the camp awesome, and to everyone else for being so easy-going over the weekend.

codings

Lack of internet is a key feature of the RailsCamp fun. To offset this, Lincoln Stoll set up a server chock full of VPS’s for hosting our apps. On top of that it served DNS and hosted gitorious. At camp it was at http://git.railscamp.net, and now we’re back its still at http://git.railscamp.net. (Some of these apps will no doubt go across to github in time).

A bumper crop of code came home from the camp this year:

Gitjour refactor

http://git.railscamp.net/projects/gitjour

A group of guys made their dissatisfaction with the current gitjour implementation manifest by refactoring it, waay into early saturday morning.

Gitnotify

Broadcast a growl notification each time you commit to git.

Gitman

http://git.railscamp.net/projects/gitman

Manage your git sharing, simply. By Mike Bailey

Swords

http://git.railscamp.net/projects/swords

A great start on a thesaurus based crossword generator. It has ascii and web interfaces.

Duke

http://git.railscamp.net/projects/duke

The return of the network jukebox. Gaming the duke voting system provided plenty of fun for all.

Myles Byrne and I were duke’s latest developers (everyone works on duke, some time). I failed to provide events for Myles, and I’m sorry.

bit-tags

http://git.railscamp.net/projects/bit-tags

Taggable snippets by the Brisbane boys.

iShare

http://git.railscamp.net/projects/ishare

An app for letting know what you’d like to hear or talk about at railscamp!

twonklist

http://git.railscamp.net/projects/twonklist

An anti-social networking application.

Twetter

http://git.railscamp.net/projects/twetter

A local twitter. Linc pointed twitter.com at twetter so that everyone’s Twitterific just worked. Matta writes about it here

Max dropped in and wrote up a Flex based client, too.

starjour

http://github.com/lachie/starjour/tree/master

I did some work on refactoring starjour. Still not really sure where this app is going, but it was good to see is list full of *jour services.

If I’ve forgotten any projects, let me know.

jq

I gave a talk on jQuery, which was a bit of a shamozzle as my version of firebug wasn’t playing with firefox 3. Preparation? Next time I suppose. Thanks to Hugh Evans for having a working ffx and some elegant jq code to show off.

feedback

If you have some feedback on the camp, please let me know: lachie (at) this domain.

One thing I’d like to see is some more emphasis on family at RailsCamp. Brodaigh brought her daughter Crystal to this one and Lone and I brought Toby to the first one. It adds a mellowing element to the camps that I really enjoy. And, I want a chance to beat Crystal at Set.

saving the day

When people started leaving on Monday morning, we hit a problem: someone had inadvertently taken Phil Oye’s bag.

After we’d finished tidying up and had hit McDonalds, I got a Twitter direct message on my phone from Dr Nic “what’s your ph num? we have someone’s black bag @ airport.”

I was able to put Phil in contact with Greg Fairbrother and it all ended happily ever after.

Twitter FTW

Summer 08 ? Winter 09 ?

So who’s going to step up next? Railscamp happens where ever someone organises it. It may be a structure-less weekend, but its still non-trivial to set one up If you think you’d like to give it a go, let me know and I’ll put you in touch with people who’ve done it before. lachie (at) this domain.

The guys from Brisbane are keen to put on a camp, probably in Winter 2009.

Who wants to organise an event for Summer 2008/9 ?

my first redbubble shirt

2008-05-22T03:49:00Z

A couple of years ago, I designed and hand-printed three t-shirts.

It was a lot of effort, mainly due to having to hand-cut the stencils out of overhead projector slides. The quality was never quite up to snuff. And the paint was smelly and extremely messy. Despite all that, it was a blast.

So now that I have a bit of time off, I find myself wanting to do some designs again… This time I’m eschewing the heady chemical aroma of fabric paint and using Redbubble, a long tail publishing business based in Melbourne. They’ll print cards, prints and shirts from your artwork.

They charge a reasonable base price, over which you can mark up whatever profit you desire. Selling costs nothing, so at the very least you can get your own designs printed for only $21. Niice.

On top of that, the site is really nicely designed and runs on Rails. Our #roro friends Xavier Shay and Justin French work there.

so anyway:

buy my tshirt!

Here

If you don’t get it, have a clue: http://twitter.com

white blood cells

2008-04-19T23:59:00Z

We have such overwhelming abundance as a society; that we continue to squander it brings me close to despair. Acting only as a diluted 2020 herd is abdicating our responsibility.

We’re the top of the pile; the assumption of personal responsibility stands as the only mechanism left to us to achieve the things we need to.

The education system will never tailor itself to your kids. You will need to shoulder the burden of education yourself.

The bulk of society will likely never grasp technology as fully as we do. Its up to us to promulgate and fulfill its promise.

We’re not helpless motes in the plasma of society. We’re the white blood cells.

Merb tips

2008-02-19T06:55:00Z

So there’s only one at the moment, but i really wanted to write this down:

0.5.x make the development logger log DEBUG messages…

Put this in Merb.root/config/environments/development.yml

:log_level: DEBUG

0.9.x freezing gems

The way of installing the latest merb release is

$ cd to/your/app
$ gem install merb -i gems --source=http://merbivore.com

Unfortunately, this command won’t install merb’s dependencies as it won’t be able to look inside the normal gems repository on rubyforge.

This should do the trick though

$ cd to/your/app
$ gem install merb -i gems --source=http://merbivore.com --source=http://gems.rubyforge.org

Yay!

(Note that this is only a problem while the merb gems aren’t pushed to rubyforge).

quicksilver javascript

2008-02-11T10:32:00Z

point one

Quicksilver

point two

I want to act without doing in web apps.

point three

qs_score.js

For example

I love me some source

2008-02-01T12:42:00Z

I don’t know if its because I’m nosy, or because I’m a control freak, or perhaps both, but I really do like to read the source code. It occurs to me that this is probably why I feel so at home in the open source world.

As much as I like something like Cocoa, it pains me not to be able to trace problems all the way down the stack. Even java solved this problem by shipping with its own source.

Proclivities aside, I really like source, and am always looking for ways to make it easier to get at. cd /usr/lib/ruby/gems/1.8/gems gets old quick.

I started with this little cough gem from Dr Nic. Integrating it with my shell, I could now type

$ gems activerecord

and up pops the activerecord gem in Textmate. So some new releases of activerecord came out, and suddenly my naive script is giving me the old version. Without looking too far into it I added gem requirement support so that I could type

$ gems activerecord '>=2'

and get a recent activerecord in Textmate. As good as this is, I was really after something with less typing and smarter pants. Well tonight I cracked it and I thought I’d open the source:

#!/usr/bin/env ruby

require ENV['TM_SUPPORT_PATH']+"/lib/ui" 
require 'rubygems'

gems = Gem.source_index.latest_specs.collect {|spec| spec.full_name}.sort

TextMate::UI.request_item(:title => 'open a gem', :items => gems) do |selected_gem|
    gem_path = Gem.source_index.specification(selected_gem).full_gem_path
    %x{open -a TextMate #{gem_path}}
end

Honestly, that’s it! Bung that in a command using Textmate’s Bundle Editor and assign it a key (I gave it cmd-shift-G, as I don’t regularly search backwards).

Double click on one and you’re golden… neat.

de-bulk your gem threshold

2008-01-27T02:33:00Z

At Jelly Sydney last Friday, I went to see if my merb gems were up to date. You know:

$ gem list --remote

*** REMOTE GEMS ***

Updating metadata for 114 gems from http://gems.rubyforge.org
...

Each dot was taking aages, and there were to be one hundred and fourteen of the blighters!

In a nutshell

The rubygem server seemed to be having issues serving up incremental metadata. Until the rubygems server got back on its feet, I set my bulk threshold to a lower value:

echo :bulk_threshold: 1 >> ~/.gemrc

I won’t leave it there, because it could impact the overall rubygem system’s performance (well maybe if everyone decided to do this all the time).

Detailure

There were about seven peoples on the NerfPalace Wifi by this stage, so it was only natural to ask:

Lachie: “Hey Tim, is the network slow?”

Tim: “Nah aah, girlfriend. You slow. Or yo gems are slow, biatch.”

Well! It turns out that Tim had noticed the same thing and had started digging into the very source code of gems in search of an answer.

Teh Pwobwem

In order not to overtax the rubygem servers’ bandwidth, gem first finds out how many of its cached metadata are out of date. If the number is greater than an arbitrary threshold, it performs a bulk update in which all the metadata is updated at once.

If the number is below the threshold, each metadatum is fetched and updated individually (incrementally you might say).

By default, this number is 1000. Say each update was taking a second and there were 999 gems to update, this process would take more than a quarter of an hour. Presumably the average case is much better than this, but on Friday, each increment of the update was taking forever.

The complete source_cache is currently ~850k gzipped. Although in aggregate this could cost the rubygems people a fair bit of bandwidth, it would never take 15 minutes on today’s broadband.

What we needed was some way of forcing the bulk update, which at the time was much faster than the alternative. The mechanism for this is not very clear, so we got by by hacking the code.

HOWTO

Thankfully, there is a better way or changing the threhold! Although its not well documented or, well, documented at all, you can set the bulk_threshold variable in the .gemrc file kept in your home directory. Its YAML, y’know:

:bulk_threshold: 1

See that colon out the front of the bulk_threshold key? Its because its a symbol once it gets inside the ruby.

As I mentioned above, its probably not good manners to leave your threshold at 1, since the authors have built the system in a certain way (even if its not always optimal) and we’re not paying the rubygem bandwidth fees. Just think, it’d be terrible for The Authors to chuck a Zed and shut rubygems down!

Hooray for Rubygems!

RORO Sydney Talk - DRYing up your views

2007-09-30T06:55:00Z

Last RORO Sydney meetup I did a talk on DRYing up your views.

I was very pleased with how it went – this really does get easier with practice! The first couple of slides were dropped, but you didn’t miss much of note :)

We’re really starting to refine the workflow for recording talks and I’m planning a write up of our experiences so far.

Big thanks to Tim Lucas for putting this months’ ‘casts together.

Logeye - a rails log gui

2007-09-16T04:40:00Z

The Rails log is a very valuable resource. It contains a lot of information and its relatively easy to read.

However, I find that It doesn’t take long to get pretty sick of scrolling around, visually decoding, not to mention that the ansi covered SQL is a pain.

Logeye is my itch-scratcher to make it better and more useful. You point it at either your RAILS_ROOT or directly at a log file, and watch the requests flow past as you develop your app.

Download

Logeye 0.3.6

Features and problems

In the open dialog you select RAILS_ROOT, not the log file itself.
Double click a log entry to open the corresponding controller file in your editor (set in preferences)
You can set window alpha, and make the windows float above other apps (set in preferences)
The zoom + does something useful.

Upcoming Features

filtering, searching
~~smarter opening.~~
refined log details view with visual distinction for each kind of line.
easy copying of SQL.
easy opening of files referred to in backtraces.
backtrace filtering.

update 1 2007/08/19

Released Logeye 0.3

changes:

refined look
ability to open log files directly
parsing of intra-request fluff

update 2 2007/08/19

Released Logeye 0.3.5

changes:

now opens nested controllers
it remembers which logs it was tailing last time you had it open and reopens them
more looks

Logeye 0.3.6 is a minor bugfix

Hornsby

2007-08-29T04:49:00Z

A while back I gave a talk at the Sydney Rails Group about Hornsby, my plugin for example based modeling. I always meant to release it, but as it got a work out it never really gave me the satisfaction I craved.

Recently, there was an Err post about layering a DSL over fixture scenarios. The idea of an expressive DSL for setting up test or spec data was super, but I had trouble getting it to work with RSpec. Oh and fixtures? Why cling to these much maligned giblets of yaml?

So here’s Hornsby, reborn: A Scenario Builder without the fixture pain.

Scenarios look like:

scenario :apple do
  @apple = Fruit.create! :species => 'apple'
end

scenario :orange do
  @orange = Fruit.create! :species => 'orange'
end

scenario :fruitbowl => [:apple,:orange] do
  @fruitbowl = FruitBowl.create! :fruit => [@apple,@orange]
end

scenario :kitchen => :fruitbowl do
  @kitchen = Kitchen.create! :fruitbowl => @fruitbowl
end

By default, these are loaded from RAILS_ROOT/spec/hornsby_scenarios.rb

...and you use them in specs like:

describe Fruit, "@apple" do
  before do
    hornsby_scenario :apple
  end

  it "should be an apple" do
    @apple.species.should == 'apple'
  end
end

describe FruitBowl, "with and apple and an orange" do
  before do
    hornsby_scenario :fruitbowl
  end

  it "should have 2 fruits" do
    @fruitbowl.should have(2).fruit
  end
end

Setup

Install the plugin:


./script/plugin install http://rails-oceania.googlecode.com/svn/lachiecox/hornsby

Or piston:


piston import http://rails-oceania.googlecode.com/svn/lachiecox/hornsby vendor/plugins/hornsby

Add the following to spec_helper.rb

# by default this loads scenarios from RAILS_ROOT/spec/hornsby_scenarios.rb
Hornsby.load

Spec::Runner.configure do |config|
  ...

  config.include(HornsbySpecHelper)
end

Advanced Usage

Its just ruby, right? So go nuts:

1.upto(9) do |i|
  scenario("user_#{i}") do
    user = User.create! :name => "user#{i}" 
    instance_variable_set("@user_#{i}",user)
  end
end

Rake

If you’d like simply to load your scenarios into a database, use the rake task like so:


$ rake hornsby:scenario RAILS_ENV=test SCENARIO=fruitbowl

TODO

Make transactional for speed.
Add scenario namespaces for better organisation.
Detect scenario cycles.

Credits

Lachie Cox

The code is based on Err’s code found in this post

License

MIT, see LICENCE

Hax Day at Lachie's

2007-08-27T13:07:00Z

On the 18th of August I hosted a RoRo Hax day. 13 people turned up bright and early (for a Saturday) and got hacking on diverse Rails and Ruby stuff.

Lone baked up a storm all day, fueling some great work.

seesaw

As you’ve probably heard already, Matt and Max built a sweet little gem called seesaw. It allows zero-downtime, zero-request loss restarting of mongrel clusters. They put their heads together and wrought it before our eyes. I don’t think they noticed anything but the code all day :)


gem install seesaw

javascripter

Pat knocked up a javascript version of his “Styler” plugin. It allows you to include controller- or action-specific javascript in your views. Very useful stuff, as it can add another dimension to your javascripting, and the polish you apply to them.

numbr5

numbr5 got some love from Martin and Harry. They added

command	action
`?ri [term]`	look up term with `ri`, n5 will send a pm to you with the results.
`?bs [someone]`	ahem, bitchslap `someone`, you know, when you need to.

Duke

Our perennial favourite web based dukebox “duke” was dusted off by Nick and Dylan, and taught to sing. Well almost. They tried to get it using net/raop but the new airport expresses weren’t really bedded down. Then icecast was attempted. Next Hax day, eh boys?

odds and ends

I made a few tweaks to roro faces, while other guys just soaked up the knowledge, vibe and brownies.

afterword

Some guys stayed around for lovely curry made by Lone.

We’re hoping to have many more Hax Days over the coming months, and I think they’ll become a catalyst for more and more cool, useful stuff.

Patrick Crowley at roro Sydney

2007-08-12T05:26:00Z

Well whaddaya know? The second roro Sydney July presentation video has dropped. This time it’s Patrick Crowley from SD Ruby, San Diego talking about his two latest plugins, Headliner and Styler

airbed: making camping restful.

2007-08-11T12:39:00Z

“Phat models & skinny controllers” is the new catch-phrase of RESTful rails. Of course, in the name of small corèdness, there’s no default implementation of the aforementioned skinny controller, their monotonous commonality notwithstanding.

Camping’s controllers are willfully simpler than rails.

Luke Redpath’s restful_exposure provides a flexible implementation for skinny controllers. The implementation however, gives me the chills. I feel that its willfully complex.

Airbed is my response to these problems, for camping.

First of all, Airbed performs a task similar to Rails’ RESTful routes. That is, requests made with HTTP verbs (GET, POST, PUT and DELETE) are mapped onto the CRUDdy actions: list, show, create, update, delete, plus those two also-rans new and edit (sort of).

The CRUDdy actions all have default implementations, using naming conventions to make it fly. To make overriding the defaults generally unnecessary, options can be passed, and various hooks are called during processing.

PUT and DELETE are not commonly supported by browsers: they’re faked in more or less the same way that Rails does, by adding a _verb parameter to requests.

a simple example

The doco is coming along as the behaviour’s being refined, but for now a simplified example is most eloquent. The full example is in airbed at examples/faces.rb

Camping.goes :Faces

module Faces
  module Models
    class Person < Base; end
  end

  module Controllers
    include Airbed::Resources

    class Index < R '/'
      def get
        redirect People
      end
    end

    class People < Resource Models::Person
      def after_modification(instance)
        redirect(People)
      end
    end
  end
end

View names are also inferred from naming conventions:

module Faces
  module Views
    # TODO make this work by including Airbed::Views
    def form(options={})
      verb = method = options[:method] || :post
      options[:method] = :post unless [:get,:post].include? method.to_sym

      tag!(:form, options) {
        input(:type => 'hidden', :name => '_verb', :value => verb)
        yield
      }
    end

    def _button(text,href,method=:post)
      form(:action => href, :method => method) {
        input :type => 'submit', :value => text
      }
    end

    def list_people
      h1 'ppl!'
      ul {
        @people.each {|person|
          li { a person.name, :href => R(People,person) }
          _button('x',R(People,person),:delete)
        }
      }

      form( :action => R(People), :method => 'post') {
        input :name => 'person[name]'
        input :type => 'submit', :value => '+'
      }
    end

    def show_person
      h1 @person.name

      form(:action => R(People,@person), :method => :put) {
        input :name => 'person[name]', :value => @person.name
        input :type => 'submit', :value => 'save'
      }
      a(:href => R(People)) {"← people"}
    end
  end
end

gimme

Install with

sudo gem install airbed

or fetch head from

svn co http://rails-oceania.rubyforge.org/svn/airbed/trunk/

The code is pretty new and shiny, so feedback in eminently welcome. Write some specs if you feel the inclination.

Ruby OO for C developers - part 1 Basic Modeling in OO

2007-08-06T12:12:00Z

Here’s a post about getting down and dirty with an example of modeling something in both C and Ruby.

In C, Object Orientation can be used (somewhat clumsily) as a pattern for modeling and implementing your problem domain. The power of real object oriented languages like Ruby is that this pattern is integrated seamlessly into the language itself.

I’m not planning on detailing Ruby syntax itself, but hope that you’ll pick it up in the course of the discussion.

For a complete overview of OO concepts, refer to Object-oriented programming at Wikipedia.

This is the first of a series of articles covering Ruby OO techniques for C developers:

Basic Modeling in OO
Inheritance
Encapsulation
Polymorphism

Anyway. Let’s model!

Baby steps

We’re going to model TV channels.

Our TV channels are viewed using a sophisticated set top box device. From a technical perspective, the box needs a few pieces of information about channels in order to tune to them and show them to the viewer.

the name of the channel.
the channel number.
some data to pass to the underlying hardware to tune to the channel.

Viewers can tune to a channel by choosing it from a graphical menu.

C

structure

In C-land, we give form to blobs of memory using structs. A struct defines the shape of a Channel when its allocated in memory.

typedef struct {
  char *name;
  int number
  int tuning_info[3];
} Channel;

allocation

To make a real channel from the struct, we allocate it some memory and initialise its information.

Channel *channel_v = (Channel *)malloc(sizeof(Channel));

channel_v->name = "Channel V";
channel_v->number = 801;
channel_v->tuning_info[0] = 4096;
channel_v->tuning_info[1] = 0;
channel_v->tuning_info[2] = 123;

channel_v is now pointing to an instance of the Channel struct.

Note that channel_v is only known to be shaped like a Channel struct at compile time. Once the code is running, the program has no knowledge of this shape.

Using the information stored in an instance is easy:

printf("Channel: %s\n", channel_v->name);
// output: Channel: Channel V

verbs

Now we have our data sorted out, let’s define some functions that do something with instances of the Channel struct.

void channel_tune(Channel *channel) {
  viewer_notify("Tuning to channel %s", channel->name);
  box_tune_to(channel->tuning_info[0], channel->tuning_info[1], channel->tuning_info[2]);
}

To perform the action “Tune to channel V” :

channel_tune(channel_v);

struct verbs

Here’s a function for reading a database file and creating a list of Channel instances:

Channel **channel_load_from_file(char *filename) {
  ...
}

This function doesn’t take a Channel instance to work on. Instead, it returns a list of Channel instances. You could view this function as working with knowledge of the Channel struct in order to produce its Channel instances.

Now lets build the same thing in Ruby…

Ruby

structure

In Ruby-land, classes define the shape of data. In object oriented circles, the shape is called the interface, because the data itself is not directly accessible (later on, we’ll learn that this concept is called encapsulation).

class Channel
  def name
    @name
  end

  def name=(name)
    @name = name
  end

  def number
    @number
  end

  def number=(num)
    @number = num
  end

  def tuning_info
    @tuning_info
  end

  def tuning_info=(tuning_info)
    @tuning_info = tuning_info
  end
end

Yuk, that’s a heap of code to do not much at all. It does expose a pile of Ruby concepts to dig through.

First of all, functions associated with a class are known as methods. They are like functions which automatically work on instances of the class, or the class itself.

The methods defined above are called instance methods, as they only work on instances of Channel.

These methods are called accessors—getters and setters—because all they do is get and set the data inside an instance.

You may have heard that one of Ruby’s principles is “don’t repeat yourself” (or DRY). Luckily, we can rewrite all this repetitive code much more succinctly:

class Channel
  attr_accessor :name, :number, :tuning_info
end

allocation

Channel objects are allocated (or instantiated) using the new method of the Channel class.

channel_v = Channel.new

channel_v.name        = "Channel V" 
channel_v.number      = 801
channel_v.tuning_info = [4096,0,123]

At this point the channel_v variable holds a Channel object. It retains complete knowledge of its structure and place in the hierarchy:

channel_v.class # => Channel
channel_v.instance_variables # => ["@number", "@name", "@tuning_info"]

This rich reflection information is very useful in many advanced techniques, collectively known as metaprogramming.

verbs

Guess what we use to get things done with Objects and Classes? Yes, right, methods.

class Channel
  attr_accessor :name, :number, :tuning_info

  def tune
    Viewer.notify("Tuning to channel #{@name}")
    Box.tune_to(self.tuning_info)
  end
end

To tune to Channel V, we call the tune method on the channel_v instance:

channel_v.tune

an aside on variables

Since we’ve seen a little bit of Ruby code by now, you might have noticed some odd things about the variables. Ruby has a few different kinds of variables and uses a couple of sigils to differentiate their type.

local variables

Local variables are only visible within the current scope, and any subscopes. They are written as variable (i.e. lower case with underscores)

Note that while and for loops don’t introduce new scope in Ruby! Blocks do.

instance variables

Instance variables are variables associated with an instance of a class. They’re visible anywhere within the instance, but not from the outside. They’re somewhat analogous to struct members, except for the encapsulation aspect (don’t worry, we’ll talk about it…).

They are written @variable (i.e. like a local variable preceded by an ‘at’).

others

Constants are visible within the current module scope and are written as Constant or CONSTANT

Globals are visible anywhere within the current ruby interpreter, and are written as $global

self

Did you notice the use of the word self in the example above? self is a special built in variable which refers to the instance for which the method is defined (In this case it wasn’t strictly required, however sometimes its necessary for disambiguation or to take advantage of encapsulation).

class verbs

Methods which act on the class rather than instances of the class are called class methods (or singleton methods). In the method Channel#tune above, Viewer.notify and Box.tune_to are singleton methods.

Let’s define a class method for Channel which reads records from a text file and returns a list of Channel objects.

class Channel
  def self.load_from_file(file)
    ...
  end
end

The class method is called directly on the class:

channels = Channel.load_from_file("channels.txt")

Bye till next time

Up to this point there’s not much difference between the structure of the C and Ruby versions.

In the next post, I’ll take OO modeling to the next logical step of inheritance. The true utility of OO will become much clearer.

I hope you’ve found the journey interesting so far—feedback is always welcome.

RORO on the boil

2007-08-02T13:32:00Z

There’s a great vibe in Oceania at the moment, especially if you’re a rails developer.

Inaugural intrameetup drinkies

Sydney folk gathered on the roof of the Glenmore Hotel, drank beer and shot the breeze. We pondered what the future holds with passionate developers looking for work often from risk averse businesses.

the first video from Sydney Rails July Meetup

Matt Allen talked about the site he works for, http://iseekgolf.com. Its a good example of a fairly large Rails site.

Tim recorded the screencast, while Jason was sound man. I post produced it, with wicked tuneage from Ben. The biggest thing I learned is that editing this stuff sucks without the right tools. Also, the right tools don’t exist yet.

My cocoa hat is coming off the shelf tomorrow.

The roro site reskin happened (!)

http://rubyonrails.com.au

Thanks to everyone who put in the elbow grease, it looks tops.