Philip Mcmahon

Sim Hacking

2011-06-22T00:00:00-07:00

Sim Hacking

22 June 2011 – Denver, CO

Summer is here and its epic. Quit the enterprisey IBM product management job to go back to startup-land. These guys are very smart, great to work with, and trying to change the world. I’ve also been knocking out some iPad & Android code at the weekend, so posts to come.

I picked up a used Samsung Captivate so I could get my hands dirty with some Android OS code.

The only snag is that it wanted a standard SIM and all I had to hand (from my iPhone 4)was a micro-sim:

A quandary! Not to be outdone, and in the interests of the hands on imperative I decided to butcher an old SIM-card and turn it into a placeholder for the micro-SIM. In short:

And it works! This pleases me immensely. Android code to come!

The Summer of Horror, Carrion Crown, Legacy of Fire

2011-04-03T00:00:00-07:00

The Summer of Horror, Carrion Crown, Legacy of Fire

3 April 2011 – Denver, CO

It’s rare (ever ?) that I make a non-programming post, but there’s so much roleplaying awesome-sauce going on at the minute that I had to let it out.

Firstly, the upcoming trip to Ireland provided a well-timed opportunity to wrap up a couple of the campaigns I’ve been partaking in. The first was the conclusion of the “Price of Immortality” trilogy I was DMing. Lasting 9 sessions, this mini-campaign took the characters from the sleepy town of Kassen to a final showdown with a Razmir obsessed elven sorceress called Iramine in the impressive and deadly City of Golden Death.

Secondly was the conclusion of the epic and stunningly good Legacy of Fire adventure path, led by a good friend and incredible DM Dave. I cannot speak highly enough about the dedication, skill-set and general awesomeness of Dave, the ensemble of characters he gathered around, and the great story that was spun. Lasting around 2 years, it culminated on Friday evening with an epic battle between the party (2 of whom died) and the epic efreet villan “Javhul” (pictured below). We celebrated the finale with a couple of six packs (of Ranger beer no less) and the stoke has lasted all weekend.

All in all, this campaign was the essence and the justification for my roleplaying hobby. As far as I am concerned, in an economic system designed to encourage (if not mandate) competitiveness, and a social system that fosters selfishness, greed and the enforcement of group-derived values, principles and definitions of normality, there exists no higher calling than that of seeking out compatible companions, led by the grand over-arching vision of a single person, and embarking upon a communal storytelling exercise. An exercise that facilitates the abandonment of all known (societal and self-imposed) restrictions, pre-conceptions rules, and that effectively allows the creation of a utopian (or perhaps even dystopian) alternate existence.

For kicks, here’s a few happy memories from the campaign.

And the final roll that ended the campaign:

After a brief vacation, I’ll be kicking off the summer with 2 horror-related storylines that I’m very excited about. First up is the Carrion Crown adventure path, currently being published with paizo. I intend to run this on a weekly basis, possibly getting through it in about 9 months. With undead, werewolves, flesh-golems and ultimately a cult desperate to bring back the arch-lich Tar-Baphon, it promises to provide some fun horrortainment.

Secondly, I promised some friends I’d run them through a Call of Cthulhu one-shot. I’ve select “Bad Moon Rising” from the “Great Old Ones” sourcebook, which I’m very excited about – it’s a lot more epic that previous CoC one-shots, so we’ll see how it goes.

And that’s about it, celebrating the kids birthday today, so we’re heading out to PF Changs. I’m in the mood for some IPad programming, so expect to see some related posts soon.

Two Quick Gems to Round Out the Week

2011-01-21T00:00:00-08:00

Two Quick Gems to Round Out the Week

21 Jan 2011 – Denver, CO

Good week, lots accomplished. 60 minutes until I knock off for pizza and beer, here’s something I thought up as I started to wind down for the week and knocked up this Friday afternoon. I’ve been thinking about an automated file-storage solution in ruby for a while now. This afternoon I thought “What if I wanted to backup some of my files to an internal (enterprise) file server ?”. The two modules I’m about to detail are the result of that thought process.

The first thing we need to do is gather the details of all the files we need. SQLite3 is probably suitable enough. All we need to do is accept some parameters and build a nice little cache of file information. Source code here (you can tell I was getting hungry by the name). The gem is built here.

To use it is very simple, lets say we want to build a quick cache of all the pdf files in our home directory:

 
  require 'rubygems'
  require 'hungrynoodle'
  h = HungryNoodle.new('/Users/snaggled', '\.pdf')
  h.find_and_insert

We can query that via the following:

   
  h.basenames

Secondly, I picked the internal IBM Cattail
as a file storage destination because I like it – it’s a cool system, its REST based, etc, etc.

A quick gem to facilitate uploading and querying files, and we’re in a position to back up files we care about.

Heres a quick and dirty script to facilitate:

 
  require 'rubygems'
  require 'cattail'
  require 'hungrynoodle'

  if ARGV.length != 4
    p "Usage: cattail <directory, e.g. '.'> 
                      <extension to be stored, e.g 'ppt'> 
                      <cattail login> 
                      <cattail passwd>"
    exit(-1)
  end

  dir = ARGV[0]
  extension = ARGV[1]
  login = ARGV[2]
  passwd = ARGV[3]

  # establish connections 
  hungrynoodle = HungryNoodle.new(
    dir, 
    "\.#{extension}", 
    "#{extension}.db", 
    "#{extension}.txt")
  cattail = Cattail.new(login, passwd)

  hungrynoodle.find_and_insert

  local_files = hungrynoodle.basenames
  remote_files = cattail.list
  diff = local_files - remote_files

  diff.each do |file|
  	file_record = hungrynoodle.file(file)
  	p "Uploading #{file_record[0][3]}"
  	cattail.insert(file_record[0][3])
  end

And that’s it. Back to our earlier example:

 
  ruby cattail.rb /Users/snaggled pdf login passwd

That will grab all the PDFs in our home directory and make sure they are all sent to the backup server. I’ll let that bad boy run and knock off for some pizza and beer, let the weekend begin.

Todays musings in accompaniment to this sweet album:

The Wonderful World of Private iPhone APIs

2011-01-14T00:00:00-08:00

The Wonderful World of Private iPhone APIs

14 Jan 2011 – Denver, CO

Also known as “How to get your app submission quickly rejected from the Apple AppStore”. Christmas was epic – plenty of beer, parties, and the kids had a blast. I also had plenty of time to catch up on a few projects, so there’s lot of material to blog about.

First up, off the top of my head, was the discovery that not all is as it seems with the iPhone SDK. Lets start by making an SSL/HTTPS call from the phone:

 
NSData *data = [NSURLConnection sendSynchronousRequest:urlRequest returningResponse:&response error:&error];

Vanilla stuff. Except, that if you’re SSL certificate is phoney or not valid, the phone’s going to complain bitterly with an “untrusted server certificate” error. Fair enough, but what if we don’t have a real SSL certificate ? What if we’re on some ad-hoc test machine and not production ?

And to the rescue comes a private API. Private as in its there in the SDK but the documentation doesn’t reflect it. Kind of like a little mini-christmas from Apple.

We simply add this to our delegate and we’re good to go. In short:

 
  + (BOOL)allowsAnyHTTPSCertificateForHost:(NSString *)host
  {
  	NSLog(@"allowsAnyHTTPSCertificateForHost");

  	return YES; // Or whatever logic
  }

My understanding is that having a private API in your code will result in your app getting rejected from the AppStore, so remember to take it out before you submit.

One final note of importance – epic album – Gargantuan #minimal/#progressive/#techno.

Autechre + Great Divide Sampler + Objective C == Nirvana

2010-11-15T00:00:00-08:00

Autechre + Great Divide Sampler + Objective C == Nirvana

15 Nov 2010 – Denver, CO

Honestly, it was. It was like the early 90s all over again – I might as well have had Poland by Tangerine Dream on the stereo and been hacking away at some Amiga 68k assembler, whilst connecting to a Razor 1911 BBS on my trusty 14.4k US Robotics HST modem (which cost me a fortune back then). I have to say I miss those days. Nonetheless, I managed to get pretty close to that feeling on Saturday night with some iPhone coding, a few of these bad boys:

And this on the stereo:

No sine-waves or fun demo comps this time, instead it was some daft Objective-C issue that took me to endorphin-land. All I wanted was to be able to check/uncheck a ‘Same As Billing’ field in a registration form, and have the form modified accordingly. Hardly rocket-science, right ? Think AJAX inserting some additional fields into an HTML div. I basically wanted the same thing on the iPhone.

In short, we just want things to look like this when the checkbox is marked:

And this when its not:

Pretty standard UITableView stuff, we need to:

1. Add ourselves as a UITableView delegate

 
@interface RegisterViewController : UIViewController <UITableViewDelegate>,

2. Implement didSelectRowAtIndexPath

 
- (void)tableView:(UITableView *)view didSelectRowAtIndexPath:(NSIndexPath*)newIndexPath

3. Insert & Delete the required sections/rows accordingly

 
[view insertSections:[NSIndexSet indexSetWithIndex:5] 
  withRowAnimation:UITableViewRowAnimationFade];

Everything worked just peachy, except when I’d try to ‘re-check’ what I’d just unchecked. At that point, it would appear that only a subset of the rows I wanted inserted, would actually appear. In fact, just the last one:

I spent several hours banging my head against the desk (i.e. drinking more beer), to eventually figure out that it was becomeFirstResponder. I was inadvertently setting each field I created to be the first responder, and it appeared to be working fine, except when I tried to dynamically insert sections/rows and it got very confused.

Some additional care taken when setting becomeFirstResponder, and its all good, got a nice buzz going and it was time to watch this documentary.

Which was epic :)

Finished the Breckenridge Brewery Sampler Pack and Running on Ruby 1.9.2 + Rails 3

2010-11-04T00:00:00-07:00

Finished the Breckenridge Brewery Sampler Pack and Running on Ruby 1.9.2 + Rails 3

4 Nov 2010 – Denver, CO

Todays broadcast brought to you by the always epic album:

Took me a while to get round to this. I’ve meet meaning to upgrade the hackintosh to Snow Leopard, so I’ve been putting off most other upgrades until I get round to it. Anyway, this evening I could wait no longer and took the Ruby 1.9.2 plunge as well as installing the Rails 3.0.1 gems.

What can I say ? Along the way I discovered something I absolutely love. Ruby Version Manager is literally the dogs bollocks. It freaking awesome. No more ‘sudo gem install’. I now have 1.8.6, 1.8.7 and 1.9.2 rubies, all with their own gemsets, instantly switchable in 1 command line. Go check it out, I dare you not to love it.

What else ? One thing I did notice is that RSpec has changed considerably. None of the previous 1.3 specs worked in a couple of the plugins I played with. To that end, I’ve checked in patches for feedzilla and sax-machine. You can either clone those repositories and build your own gems locally, or wait until the changes are pulled into the man repos, which are here and here respectively.

Indexing Pathfinder Society Modules in Rails

2010-11-01T00:00:00-07:00

Indexing Pathfinder Society Modules in Rails

1 Nov 2010 – Denver, CO

I play a lot of Pathfinder, which is actually an incarnation of Dungeons & Dragons. I love paizo and think the quality of the stuff they produce is outstanding. Anyway, I was having a little trouble navigating the list of modules/scenarios available, so a spare saturday afternoon knocked up a site called libris arcanis.

This is perfect for Rails. Its a quick rake task to fetch the data, with active record abstracting all the heavy lifting. All we need to do is stick a controller in front of it and some pretty CSS (which a grabbed from LFR Compendium so kudos to those guys for letting me use it).

I haven’t had a chance to add things to github yet, but in short, this is why I love rails. All in, this was about 4-8 hours effort an a saturday afternoon, fueled by:

C’est tout! Getting sprinklers blown out for the winter, must run!

Fun with MapReduce and Hadoop (Calculating Stock Market Statistics in a Parallel Fashion)

2010-10-29T00:00:00-07:00

Fun with MapReduce and Hadoop (Calculating Stock Market Statistics in a Parallel Fashion)

19 Oct 2010 – Denver, CO

Epic summer. Lots of camping, bbq, boating and drinking great Colorado microbrews. Really can’t complain. Fall coming in means my mind is wandering to some more abstract problems, and one of the things on my list was to look at MapReduce. The new Autechre album seems fitting background music to this type of endeavor.

This isn’t the place for an in-depth tutorial of MapReduce (of which there are many excellent ones – I recommend this paper from google and the following video from Cloudera.)

The short of it is that MapReduce is a paradigm that abstracts a lot of the complications that we typically face when attempting process large amounts of data in a parallel fashion. And by complications, I mean primarily scheduling, reliability, infrastructure and distribution. In effect, you end up programming to a particular abstraction or Design Pattern and not worrying about the rest of it. Of course, there are certain requirements necessary to make the best of this paradigm – in short its well suited to processing non-interactive lists of data with little or no data-dependency. Sounds like fun ? On to an example!

Introducing Apache Hadoop/MapReduce

Hadoop MapReduce is Apaches open source framework for supporting this paradigm. Once installed, we’ll need a project to test out its capabilities. Lets write a task to compute the frequency of stock market changes. For example, given a particular stock, we’d like to know how often in the past several years its changed by 1%, 2%, 3% etc (kind of like a a Fourier Transform, or transforming some temporal domain data into the frequency domain). This is typical of the type of processing the MapReduce framework should be good at.

I’ve added to code for this example to github but the core of it is that we’re going to need a couple of things to get started. The first ones a dataset. Yahoo Finance can provide what we need through the following webservices call:

 
	wget http://ichart.finance.yahoo.com/table.csv?s=BP

I’ve chosen BP as a stock because they are fresh in my mind given I bought in at $42 (on the way down) and its taken some time to get back into the black. Our input data should thus look like this:

 
2010-10-15,40.92,41.11,40.40,40.62,9023100,40.62
2010-10-14,41.15,41.37,40.96,41.02,6750300,41.02
2010-10-13,41.40,41.75,41.25,41.41,6950200,41.41
2010-10-12,40.74,41.53,40.55,41.26,8343100,41.26

So we have out input, the next thing we need to write is a Map function and a Reduce function.

Map Function

Primarily we are writing a stream processor here that atomically performs what needs to happen on one line of data. Thats perfect for us, we’re going to simply take the opening price, the closing price, calculate the percent change and spit it out. As follows:

 
// Date,Open,High,Low,Close,Volume,Adj Close
String[] tokens = value.toString().split(",");  
float open = Float.valueOf(tokens[1]);
float close = Float.valueOf(tokens[4]);
float change = ((close - open)/open) * 100;   
word.set(new DecimalFormat("0.##").format((double) change) + "%");
context.write(word, one);

What thats going to give is us a stream of (name, value) pairs with the name being the percentage change for the day and the value being the integer ‘1’. Thats ok, thats all we need from our mapping function. This function can be distributed over X number of machines, each one performing its streaming function in parallel and independent of the others.

Reduce Function

Next up is the ‘Reduce’ function (hence the name of the paradigm). What’s going to take place here is that a reduce function is going to take the (name, value) outputs from all the mappers and process that data accordingly (often ‘reducing’ it). In our case we are simply going to count the number of times a particular percentage change happens. In essence we are going to change this:

 
1.2% 1
1.3% 1
1.2% 1

into:

 
1.2% 2
1.3% 1

There’s not much to the code:

 
int sum = 0;
for (IntWritable val : values) {
	sum += val.get();
}
context.write(key, new IntWritable(sum));

Thats about it, we write 2 functions and theres some setup involved (which I’ve embedded into the ant build.xml in the repository).

Our Output

 
-0.01%  2
-0.02%  13
-0.03%  12
-0.04%  10
-0.05%  14
-0.06%  17
-0.07%  19
-0.08%  12
-0.09%  12
-0.1%   19
-0.11%  18
-0.12%  18
-0.13%  20
-0.14%  27
-0.15%  43

That was actually pretty painless. I’ve been thinking about Arthur C. Clarkes Nine Billion Names of God short Science Fiction story and think MapReduce (actually probably more-so the Map part, less the Reduce part) may be a good platform to do some experimentation on regarding that story.

The source for this example can be found here. It should be placed in a subdir of the hadoop installation, i.e. jobs/hadoop-foobar.

Summer of Hawkwind (aka Running your rails tests using an in-memory database)

2010-04-28T00:00:00-07:00

Summer of Hawkwind (aka Running your rails tests using an in-memory database)

28 Apr 2010 – Denver, CO

2 weeks paternity leave from work means a couple of things. Firstly, it means I’ve been listening to a lot of music, and it seems the most fitting for Spring/Summer 2010 is some awesome space-rock. Order of the day seems to be Hawkwind.

Might get a mountain bike ride in on Friday. Mountain-biking + acid-rock == flashbacks whilst hurtling downhill at 30 mph.

Running Rails tests using an in-memory database

The second thing being off work enables is the cleaning up of old projects and things on the to-do list. One thing thats been bugging for a while is the length of time it takes to run my rails test cases (running MySQL):

 
	~/git/cs(master) $ rake test
	.........................
	Finished in 264.208584 seconds.

	25 tests, 2697 assertions, 0 failures, 0 errors

Over 4 minutes, thats a long time when you’ve changed one line of code. A challenge! Onwards and upwards, heres how to get your rails test to run using sqlite3.

1. Install the sqlite gem

 
sudo gem install sqlite3-ruby

This may or may not go smoothly. Native extension compilation problems could lead to macports on OSX, or the equivalent apt-get on Ubuntu.

2. Modify database.xml

 
	test: 
	   adapter: sqlite3 
	   database: ":memory:"

Speaks for itself. Keep the old one around in case you want to run comparison speed-tests.

3. Install the ‘in_memory_fix’ plugin

I grabbed it from the following svn repo:

 
./script/plugin install http://topfunky.net/svn/plugins/memory_test_fix

But there are also a bunch of git forks floating around.

What does it do ? Well, the short of it is that because the db is in memory, it needs to be re-created each time, which is what the plugin does. You can find more info over here.

4. Differences between MySQL and Sqlite3

At last, some meat. You can take what you have and try to run your rake tests. There’s are chance you could be good to go. In my case, there were a couple of syntactic differences between the two databases that needed resolving:

RAND vs RANDOM

First up was that the sqlite3 random function is called ‘RANDOM()’ whilst the MySQL one is called ‘RAND()’. This cause an active_record lookup like the following one to fail:

 
@bar = Foo.find(:all, :order => 'RAND()')

Couple of ways to fix this. Easiest from my point of view was simply to create the ‘RANDOM’ function in MySQL. Sounds like a migration:

 
	class CreateRandomFunction < ActiveRecord::Migration
	  def self.up            
	    adapter = User.connection.
			instance_variable_get("@config")
			[:adapter]      
	    if adapter == 'mysql'
	      execute "create function random() returns integer return rand();"
	    end
	  end

	  def self.down  
	    adapter = User.connection.
			instance_variable_get("@config")
			[:adapter]      
	    if adapter == 'mysql'
	      execute "drop function if exists random;"
	    end
	  end
	end

Doesn’t this apply to test-cases ?

Err, I suspect that should be enough, but my test cases were failing because around the time that fixtures were loaded, the function got blown away again. I ended up with this in my test_helper.rb:

 
adapter = Rails.configuration.
	database_configuration
	[Rails.configuration.environment]
	["adapter"]
if adapter == "mysql" && ENV["RAILS_ENV"] == 'test' 
  ActiveRecord::Base.connection.execute("drop function if exists random;");
  ActiveRecord::Base.connection.execute("create function random() returns integer return rand();");
end

Fixtures and “1” vs “t”

Almost out of the woods, but not yet. If you’re using fixtures, and you’ve auto-magically generated them (as I have), you might see the following entry for Booleans:

  
boolean_variable_in_mysql: "1"

This is all and well in MySQL, but sqlite3 doesn’t like it. It stores its bools as the char “t” or “f” and you may need to convert them. true or false should work fine, i.e.

  
boolean_variable_in_mysql: true

And thats it. My tests running in memory. Time to turn the space-rock up.

Monkey Patching in Ruby

2010-04-21T00:00:00-07:00

Monkey Patching in Ruby

21 Apr 2010 – Denver, CO

Todays post comes courtesy of what is possibly the greatest programming music ever invented:

Monkey Patching

More than just a cool name. No, really, its also called Duck-Punching:

Well, I was just totally sold by Adam, the idea being that if it walks like a duck and talks like a duck, it’s a duck, right? So if this duck is not giving you the noise that you want, you’ve got to just punch that duck until it returns what you expect.

This is not something I encountered much (ever) in Java, but I think thats indicative of the dynamic nature of the Ruby language (Python too for that matter). The reality is that the history of the name itself is somewhat more interesting that the concept. To quote wikipedia:

Since the word guerrilla and gorilla are near-homophones, people started using the incorrect term gorilla patch instead of guerrilla patch. When a developer then created a guerrilla patch they tried very hard to avoid any battles that may ensue due to the patch and the term monkey patch was coined to make the patch sound less forceful.

So, what are we talking about ? Well, to make a long story short, all we are talking about is the concept of dynamically modifying a class or object at runtime. Lets think about this a little. Sample Ruby class:

 
	class Foo
		def bar
			"bar"
		end
	end

	f = Foo.new
	f.bar	
	=> "bar"

All is well and good until we discover that the “bar” method is wrong and shouldn’t be returning “bar”. What are our options ? Well, traditionally we’d probably sub-class Foo and fix the problem:

 
	class Foo2 < Foo
		def bar
			"the correct bar"
		end
	end

	f = Foo2.new
	f.bar	
	=> "the correct bar"

The advantage of this approach is of course that we know we haven’t broken anything. Any of the existing calls to Foo.bar should still work. However, what about the situation where Foo is already distributed, its out there in the wild, maybe its impossible or not practical for us to subclass it. Maybe its an issue in a piece of code we really don’t care about (maybe we didn’t write it), we just need it fixed.

This is where the absolute beauty of a dynamic language like ruby comes in. Its possible for to dynamically change the Foo class, without modifying any of its source code (on disk). Here’s what we can do in Ruby that we can’t do in a bunch of other languages:

 
	class Foo
		def bar
			"bar"
		end
	end

	class Foo
		def bar
			"the correct bar"
		end
	end

	f = Foo.new
	puts f.bar

Yeppers, you read that correctly. Ruby has the concept of Open Classes meaning by re-declaring a class, we can effectively add or modify methods.

Up next: Caching geocode lookups from google.

Chrome Bug - sends 'undefined' when no data is passed to XMLHttpRequest

2010-04-11T00:00:00-07:00

Chrome Bug – sends ‘undefined’ when no data is passed to XMLHttpRequest

11 Apr 2010 – Denver, CO

Spent the week trying to juggle work, our 2 year old twins, my parents visiting from Ireland, and repeatedly driving to and from the hospital to spend time with our premature twins that were born on Easter Sunday. Its been a mad, but fun week. I have a secret weapon which has kept me going:

Turbo! Babies will be home soon and parents are leaving in couple weeks, so life we be returning back to normal. In the meantime, here’s a Google AJAX Chrome bug I experienced this weekend.

Chrome XMLHttpRequest Issue

Its perfectly valid to perform an HTTP POST and send no data, such as the following line of jQuery code:

 
	$.ajax({
	  type: 'POST',
	  url: url,     
	  dataType: 'json'
	});

This should result in no data being sent in the POST but instead, Chrome sends an ‘undefined’ which is incorrect. This is easily fixed by forcing the client-side Javascript to send something:

 
	$.ajax({
	  type: 'POST',
	  data: "",  
	  url: url,     
	  dataType: 'json'
	});

You can find bug reports on the issue here and here.

Understanding Cross-Domain Javascript - JSONP and IFrames

2010-04-08T00:00:00-07:00

Understanding Cross-Domain Javascript – JSONP and IFrames

08 Apr 2010 – Denver, CO

Been an awesome couple of weeks. I am the proud new father of twins (our second set). Still on a high from the whole experience. Think I’ll celebrate by documenting some of the cross-domain issues I explored last weekend.

But before I begin, the last couple of weeks have been dominated by this work of epic proportions:

41 tracks of Afx awesomeness. Thats not my vinyl in the picture above, I wish it was.

The Cross Domain Problem

Its classic Philly to make the mistake of assuming things are actually easier than they are (I’m a perpetual optimist). So, when over the weekend I wanted to write a piece of Javascript to connect to a remote server, pull back some content and display it, I of course assumed that things boiled down to a quick jQuery call. Not to be. Lets make a sample ajax call using jQuery:

 
$(document).ready(function(){
	var url = "http://twitter.com/status/user_timeline/snaggled.json";
	$.getJSON(url, function(data) {
		// firebug
		console.info(data);
	});
});

Pretty straightforward stuff. What we’d like to see in our console window is some nicely formatted JSON, along the lines of:

 
[{"created_at":"Tue Apr 06 19:29:57 +0000",
"contributors":null,
"in_reply_to_status_id":null,
"in_reply_to_user_id":null,
"geo":null,
"place":null,
"in_reply_to_screen_name":null,
"source":"<a href=\"http://www.tweetdeck.com/\",
...

Of course I’d completely forgotten the (same origin) Cross Domain Security restrictions that apply when it comes to Javascript. In short:

We cannot make an AJAX (XMLHttpRequest) to a different domain than the one which served the page we are currently accessing.

This is the reason our AJAX call is failing above, in fact, in FireBugs console we see this:

 
Access to restricted URI denied" code: "1012
[Break on this error] xhr.open(type, s.url, s.async);

Of course there are a wealth of valid reasons for same origin policy, but it does nix our idea of dropping in a line or two of Javascript and pulling back some information. So what are our options ?

IFrames

Its like the late 90s all over again. This doesn’t feel like a particularly elegant solution. Nonetheless, it does work and deserves attention.

An IFrame is an entire HTML document embedded in our page. We dynamically create one of these bad boys, setting its source to a url on our server. Then, from that page we can invoke any AJAX we want, because we have already established the “same origin”. An example!

 
var url = "http://mydomain.com/js/iframe";           
var myframe = $("<iframe/>").attr("src", url).attr("width", "0px").attr("height", "0px").attr("id", "my_iframe");    
$("#container").append(myframe);

Here we’re pulling a page from the remote server we wish to communicate with. Nothing too fancy involved. Lets look inside the page we’re pulling back:

 
<script type="text/javascript">init();</script>

All we’re actually doing is calling a JS function. Lets look inside the Javascript:

 
function init()
{
	$(document).ready(function(){
		var url = "http://mydomain.com/api/v1/snaggled.json";
		$.getJSON(url, function(data) {
			// firebug
			console.info(data);
		});
	});
}

Aha! Now we’re making the AJAX call. You’ll note that we’re allowed to make AJAX calls to this domain because we’ve already established the ‘origin’. This can be taken a lot further and there’s no shortage of information on this (as well as some security restrictions, such as no iframe to iframe communication). This is one of the better blogs I’ve read on the subject. Here also.

JSONP

The second solution appears to be made of win. JSON with Padding is basically a workaround where:

1) We pass a function name to the server as a param in our Cross-Domain call:

 
$(document).ready(function(){
	var url = "http://twitter.com/status/
	user_timeline/snaggled.json
	?callback=JSONPcallbackFunction";
	$.getJSON(url, function(data) {
		// firebug
		console.info(data);
	});
});

2) The server dosen’t just return the requested data as normal, but instead wraps the requested data in a Javascript function using the callback we provided, so that the response looks like this:

 
JSONPcallbackFunction([{
	"in_reply_to_user_id":null,
	"created_at":"Tue Apr 06 19:29:57 +0000 2010",
	"contributors":null,"geo":null
	...

What this actually does, rather than returning just data is return a piece of Javascript that gets executed. This works beautifully. Its not really AJAX though. I’m pretty sure its not using XMLHttpRequest and is nothing more than dynamic script element loading. I’ve also had some problems getting it to work with POST and PUT requests, which I believe is symptomatic of the previous statement. Nonetheless, it does work for certain situations, and is elegant.

Up next: Google Chrome/JQuery Bug!

Maven - I've just discovered Transitive Dependency Management

2010-03-10T00:00:00-08:00

Maven – I’ve just discovered Transitive Dependency Management

10 Mar 2010 – Denver, CO

Maven

Wow. I have to admit to being a little late to the party on this one. Several years ago, my days as a full-time Java developer where filled with ant (if you were lucky) and make (if you weren’t).

Before I continue, this evenings late night festivities are brought to you by this (ultimate) form of nourishment:

And this fantastic album:

Anyhoo, this evening, I planned on spending a couple hours playing with hibernate (I wanted to check out its ORM capabilities, especially compared to Rails ActiveModel (which I love)). 5 minutes into the tutorial and I was in jar-hell and for the millionth time starting thinking “where do I download that that mysql-connector-java” (its here for those of you that care) as I started to think about hooking hibernate up-to mysql.

But not this time. Introducing maven. The best description of that I can think of is ant coupled with something like yum or apt-get or macports or whatever. Its kind of like a RubyGems for jar files.

Here’s a sample POM file, from the hibernate tutorial:

      
<modelVersion>4.0.0</modelVersion> 
<groupId>org.hibernate.tutorials</groupId> 
<artifactId>hibernate-tutorial</artifactId> 
<version>1.0.0-SNAPSHOT</version> 
<name>First Hibernate Tutorial</name>   
<build> 
	<finalName>${artifactId}</finalName>   
</build> 
<dependencies> 
	<dependency> 
		<groupId>org.hibernate</groupId> 
		<artifactId>hibernate-core</artifactId>    
		<version>3.3.2.GA</version>
	</dependency> 
	<dependency> 
		<groupId>javax.servlet</groupId> 
		<artifactId>servlet-api</artifactId> 
		<version>2.5</version>
	</dependency>         
	<dependency> 
		<groupId>mysql</groupId> 
		<artifactId>mysql-connector-java</artifactId> 
		<version>5.1.9</version>
	</dependency>         
	<dependency> 
		<groupId>org.slf4j</groupId> 
		<artifactId>slf4j-simple</artifactId> 
		<version>1.5.11</version>
	</dependency> 
	<dependency> 
		<groupId>javassist</groupId> 
		<artifactId>javassist</artifactId> 
		<version>3.8.0.GA</version>
	</dependency> 
</dependencies> 
</project>

The bit we care about are the dependencies. Lets kick off a build:

 
	~/java/tutorial $ mvn compile
	[INFO] Scanning for projects...
	[INFO] ------------------------------------------------------------------------
	[INFO] Building First Hibernate Tutorial
	[INFO]    task-segment: [compile]
	[INFO] ------------------------------------------------------------------------
	Downloading: .../maven-plugins-12.pom
	Downloading: .../maven-parent-9.pom
	Downloading: .../apache-4.pom
	Downloading: .../maven-plugins-8.pom
	Downloading: .../maven-parent-5.pom   
	...

And look at that bad boy go! Good lord, it actually fetched 40 jars, stored them locally in my repository, and used them in the build. Dependencies and everything. Glorious. I have to admit to being more impressed this evening with maven than hibernate (which is actually fine, I’m just a little spoilt with ActiveModel).

The source for the hibernate tutorial is here for safekeeping.

Tomorrow I need to burn 44 gigs of VMWare instances onto DVDs and post them to a data-center in Florida. Wonder how long it will take. I figure its easier than trying to FTP them.

Objective-C for Java (and Ruby) Developers - Part 2

2010-02-28T00:00:00-08:00

Objective-C for Java (and Ruby) Developers – Part 2

28 Feb 2010 – Denver, CO

Meta-data

No discussion about a language would be complete without covering the ability to navigate around its meta and find information about its classes and methods.

Lets start with Ruby, which, as is usually the case, everything is sweet:

 
	class Philly < String
	  def initialize
	    @var = ""
	  end
	  def custom_method 
	    "Philly"
	  end
	end

	philly = Philly.new

	p philly.class
	p philly.methods
	p philly.instance_variables
	p philly.kind_of?(String)

Takes a couple more lines of code in Java, but still life is good:

 
	import java.util.*;
	import java.lang.reflect.*;
	import java.io.*;

	public class Philly extends StringWriter
	{		
		public String var;
		public void custom_method()
		{
		}

		public static void main(String[] args) 
			throws InterruptedException
		{
			Object p = new Philly();
			Class c = p.getClass();
			System.out.println(c.getName());

			Method[] m = c.getMethods();
			Iterator it = Arrays.asList(m).iterator();
			while (it.hasNext())
			{
				System.out.println(it.next());
			}

			Field[] f = c.getFields();
			it = Arrays.asList(f).iterator();
			while (it.hasNext())
			{
				System.out.println(it.next());
			}

			System.out.println(StringWriter.class.
				isAssignableFrom(c));
		}
	}

Note that the String class is Final in Java so we couldn’t over-ride it. I just over-rode StringWriter to get the message across, you get the general point.

Which takes us finally to Objective-C, where things are longer still, but not too bad. Note that we do have to worry about freeing up any memory that was allocated in our calls.

 
#import <Foundation/Foundation.h>
#import <objc/runtime.h>

@interface Philly : NSString
{
	int var;
}

-(void) custom_method;

@end

@implementation Philly

-(void) custom_method 
{
}

@end

int main (int argc, const char * argv[]) 
{
    NSAutoreleasePool * pool = 
		[[NSAutoreleasePool alloc] init];

	Philly *p = [[Philly alloc] init];
    
	// the class
	NSLog(@"%@", [p class]);

	// methods
	unsigned int count = 0;
	Method *methods = class_copyMethodList(
		[p class], &count);
	for (int i = 0; i < count; i++)
	{	
		SEL selector = method_getName(methods[i]); 
		NSLog(@"%s", selector);
	}	
	
	// instance variables
	Ivar *vars = class_copyIvarList(
		[p class], &count);
	for (int i = 0; i < count; i++)
	{	
		NSLog(@"%s", ivar_getName(vars[i]));
	}
	
	// kindof/superclass
	NSLog(@"%@", [[p class] isSubclassOfClass: 
	 [NSString class]] ? @"true" : @"false");
	
	free(methods);
	free(vars);
	[p release];
    [pool drain];
    return 0;
}

Now this is a little interesting, because the interesting calls in this example (e.g. class_copyMethodList) calls come from the Mac OS X implementation of the Objective-C runtime platform, so things may look differently for Linux or a GNU-compiler based platform. You can read more about it here.

Protocols

A protocol is, at its simplest, very similar to a Java Interface. It enables us to define a list of methods that have to be implemented. If a Class decides to ‘conform’ to that protocol, it must implement the listed methods. In short:

 
@protocol MyProtocol

-(void) protocol_method;

@end

@interface Philly <MyProtocol>
{
	int var;
}

-(void) custom_method;

@end

@implementation Philly

-(void) custom_method 
{
}

-(void) protocol_method
{
}

@end

Early flight to Dallas tomorrow morning. Spending the week (hopefully) getting my Java on!

Objective-C for Java (and Ruby) Developers - Part 1

2010-02-25T00:00:00-08:00

Objective-C for Java (and Ruby) Developers – Part 1

25 Feb 2010 – Denver, CO

Brought to you this morning by my current favorite method of caffeination:

Classes, Variables & Methods

Classes are divided into 2 parts:

 
	@interface // definitions go here
	
	...
	
	@implementation // goes here

Methods are defined using the syntax:

 
	-(void) add: (int) a and: (int) b;

With the – at the start meaning an instance-level variable, and a + meaning a class level definition. Giving variables names in each method definition can feel a little strange. Heres a couple more examples:

 
	-(void) setNumerator: (int) n overDenominator: (int) d;
	-(void) addEntryWithName: (*NSString) name andEmail: (*NSString) email andPhone: (*NSString) phone;

The names can also be ignored if you wish.

 
	-(void) add: (int) a: (int) b;

Methods are invoked via the syntax:

 
	[receiver message];

Variables can be accessed using the ‘dot operator’:

 
	myInstance.myVar;

And can be quickly defined using the @synthesize operator, which is somewhat equivalent to Rubys attr_accessible:

 
	@synthesis myVar;

To bring it all together:

 
	#import <Foundation/Foundation.h>

	@interface Fraction : NSObject 
	{
		@public
			int public_variable;
	}

	@property int numerator, denominator;

	-(void) setNumerator: (int) n andDenominator: (int) d;
	-(void) setA: (int) a;

	@end

	@implementation Fraction

	@synthesize numerator, denominator;

	-(void) setNumerator: (int) n andDenominator: (int) d
	{
		numerator = n;
		denominator = d;
	}

	-(void) setA: (int) a
	{
		public_variable = a;
	}

	@end


	int main (int argc, const char * argv[]) {
	    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

		Fraction *f = [[Fraction alloc] init];
		[f setNumerator: 1 andDenominator: 2];
		NSLog(@"numerator: %i, denominator: %i", [f numerator], [f denominator]);

		[f setA: 3];
		NSLog(@"via attribute accessor: %i", f->public_variable);

	    [pool drain];
	    return 0;
	}

The ‘id’ Data Type and Static Typing

In Java if we didn’t feel like being explicit about a type, we could always just define a super-class as the reference, for example:

 
	public class Philly
	{
		public static void main(String[] args) throws InterruptedException
		{
			Object p = new Philly();
			System.out.println(p.getClass());
		}
	}

Of course gives us the output Philly.

In Objective-C we get this weird little ‘id data type’ that can basically do the same thing. My, you are a weird little man, aren’t you ?

 
id g = [[Fraction alloc] init];
NSLog(@"numerator: %i, denominator: %i", [g numerator], [g denominator]);

Note that we didn’t even have to declare g as a pointer there.

Up next: Meta-data, Categories & Protocols.

Sinatra + Hpricot + jQuery == Dukkha

2010-02-24T00:00:00-08:00

Sinatra + Hpricot + jQuery == Dukkha

24 Feb 2010 – Denver, CO

I realized over the weekend that I needed some form of ‘startpage’. I have a bunch of access-points, switches, servers and applications, each with its own access url, and I wanted a simple, configurable page, with a link to each server/app, that I could set my homepage to. I quick google led me to this site: symbaloo. I loved the cool grid-layout but wasn’t interested in relying upon an external site, so I decided to spend Sunday afternoon knocking something similar up.

Besides, I have been dying to play with the awesome Sinatra, which looked perfect. Coupled with hpricot for XML parsing, and jQuery for all-round awesomeness, we have everything we need to build something like this in a couple hours.

Configuration

Lets start by defining the configurable variables of a ‘cell’ (one of the table elements), it looks a little like this:

 
	<cell>
		<coords><x>5</x><y>1</y></coords>
		<image>router.gif</image>
		<text>dsl router</text>
		<color>#ffffff</color>
		<background>blue.gif</background>    
		<url>http://192.168.1.1</url>
	</cell>

Which should give us everything we need.

Hpricot

Life couldn’t be any easier when we’re parsing XML in ruby, so I took the liberty of firstly creating a Cell class to hold what we need:

 
	class Cell
	  @@attrs = [:x, :y, :image, :text, :color, :background, :url, :tooltip]
	  @@attrs.each {|a| attr_accessor a }

	  def initialize(cell)
	    @@attrs.each do |a|
	      self.send("#{a}=", (cell/a).inner_html)
	    end    
	    [:x, :y].each {|a| self.send("#{a}=", self.send(a).to_i)}
	  end
	end

Along with a quick XML parsing routine:

     
	def load_config(xml_config)
	  config = File.read(xml_config)
	  doc = Hpricot.parse(config)

	  # cells = multi-d array using width & height
	  width = (doc/:cells/:width).inner_html.to_i
	  height = (doc/:cells/:height).inner_html.to_i
	  cells = Array.new(height)
	  height.times { |h| cells[h] = Array.new(width) }

	  (doc/:cells/:cell).each do |cell_html|
	    cell = Cell.new(cell_html)
	    cells[cell.y][cell.x] = cell
	  end
	  cells  
	end

And we have our table config’d and loaded.

Sinatra

Next up, is the fantastic Sinatra. By no stretch of the imagination did I make use of its best features here, in fact all I’m really doing is using it as a glorified web-server, but the project did give me an opportunity to play around with some of its cooler features and I have a project in mind already for next weekend.

All we’re really going to do here is load the XML into our multi-dimensional array and delegate the display to the view (as it should be):

     
get '/' do
  @cells = load_config
  erb :index
end

Finally, all of the Javascript resides in the view, which I won’t replicate here, but lets just say that jQuery makes life easier than it should be and I’d recommend it to anybody. I used Prototype pretty extensively for a while (because it shipped with Rails), but over the last year or so, jQuery has become my Javascript framework of choice.

The Result

And thats about it, 1 XML file, 1 Ruby file and 1 View and 1 CSS file later, we end up with something that looks like this:

You will notice I’ve replicated the symbaloo layout and used some of their icons. Credit where credit’s due, their site looks great and I encourage you to head over there and check it out.

A name, and Internet Explorer

Which leaves us with a name to choose. I settled upon Dukkha because I am reading about Buddhism and was extremely impressed to find it defined the fundamental disquiet we experience as beings, trapped between the assumption of an eternal self (atman) and the denial of such a self (anatman).

Speaking of “having a poor axle hole,”, thats pretty much how I felt when I discovered Internet Explorer didn’t want to play nicely with my XHTML and CSS. If Microsoft browsers are your thing, I graciously invite you to fork off in github and make it look pretty.

The project is available on github to fork and/or download.

Pointers - We Meet Again

2010-02-19T00:00:00-08:00

Pointers – We Meet Again

18 Feb 2010 – Denver, CO

After switching to Java, Python and eventually Ruby, I honestly, honestly thought I’d never see another pointer again in my life. I’m still traumatized by the 4000 lines of X/Motif code I wrote as part of my undergraduate thesis many years ago. Nonetheless, it appears that he who wants to code on the IPhone must take a refresher, so here it is.

Pointers

Variable, meet pointer, who is nothing more than a memory address with your address in it.

 
	#import <Foundation/Foundation.h>

	int main (int argc, const char * argv[]) {
	    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

	    int count = 1;
		int *ptr;

		// ptr is equal to the address of count
		ptr = &count;
		NSLog(@"c = %i, p = %i", count, *ptr);

		// contents of ptr is equal to the contents of count
		count = 2;
		*ptr = count;
		NSLog(@"c = %i, p = %i", count, *ptr);

		// ptr is actually a memory address
		NSLog(@"p == %i", ptr);

	    [pool drain];
	    return 0;
	}

Gives us:

07:07:26.919 Pointers[1958:903] c = 1, p = 1
07:07:26.922 Pointers[1958:903] c = 2, p = 2
07:07:26.923 Pointers[1958:903] p == 1606414028

Structs

Pointer, meet struct. You two shall become very familiar. In fact, theres even some funky shorthand you can use together.

	int main (int argc, const char * argv[]) {
	    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

		struct date 
		{
			int month;
			int day;
			int year;
		};

		struct date today;
		struct date *ptr;

		today.month = 2;
		today.day = 19;
		today.year = 2010;

		// ptr points to today
		ptr = &today;

		// ptr is actually a memory address
		NSLog(@"t == %i", ptr);

		// we can still access the elements of thr struct
		NSLog(@"t == %i", (*ptr).month);

		// but we also get this cool shorthand
		NSLog(@"t == %i", ptr->year);	

	    [pool drain];
	    return 0;
	}

The product of your union (fnar, fnar):

07:16:58.706 Pointers[2360:903] t = 1606413984
07:16:58.709 Pointers[2360:903] t = 2
07:16:58.709 Pointers[2360:903] t = 2010

Methods and Functions

We have two options here – passing the address of a variable (&) is the same as declaring and passing a pointer.

	#import <Foundation/Foundation.h>

	// we're accepting pointers here
	void exchange(int *p1, int *p2)
	{
		int temp;

		temp = *p1;
		*p1 = *p2;
		*p2 = temp;
	}

	int main (int argc, const char * argv[]) {
	    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

		int x = 1, y = 2;

		// before exchange
		NSLog(@"x, y == %i, %i", x, y);

		// we can pass in the address of x, y
		exchange(&x, &y);
		NSLog(@"x, y == %i, %i", x, y);

		// or we can declare a pointer and pass that in instead
		int *p1, *p2;
		p1 = &x;
		p2 = &y;

		exchange(p1, p2);
		NSLog(@"x, y == %i, %i", *p1, *p2);

	    [pool drain];
	    return 0;
	}

Mon cheri:

07:44:36.137 Pointers[2892:903] x, y == 1, 2
07:44:36.141 Pointers[2892:903] x, y == 2, 1
07:44:36.141 Pointers[2892:903] x, y == 1, 2

Arrays

And this, at last, is where the fun begins.

	#import <Foundation/Foundation.h>

	int main (int argc, const char * argv[]) {
	    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

		int *ptr;
		int myArray[] = {1, 2, 3};

		// we can point at the start of the array like this
		ptr = &myArray[0];
		NSLog(@"ptr == %i", *ptr);

		// or use the shorter version, the compiler treats the 
		// occurence of an array name with subscript as pointer
		// to first element of the array
		ptr = myArray;
		NSLog(@"ptr == %i", *ptr);

		// then we can access directly
		ptr[1] = 5;
		NSLog(@"ptr == %i", myArray[1]);

		// or this way. they key point here is that the compiler
		// will look after the size of the inc/decrement depending
		// on what the array objects are
		*(ptr + 1) = 6;
		NSLog(@"ptr == %i", myArray[1]);

		// or increment/decrement
		*(++ptr) = 7;
		NSLog(@"ptr == %i", myArray[1]);

	    [pool drain];
	    return 0;
	}

Gives us:

08:10:13.356 Pointers[3588:903] ptr == 1
08:10:13.359 Pointers[3588:903] ptr == 1
08:10:13.359 Pointers[3588:903] ptr == 5
08:10:13.360 Pointers[3588:903] ptr == 6
08:10:13.360 Pointers[3588:903] ptr == 7

Functions

Finally, its worth noting that you can declare a pointer to a function.

	#import <Foundation/Foundation.h>

	void myfunc(int *a, int *b)
	{
		int temp;
		temp = *a;
		*a = *b;
		*b = temp;
	}

	int main (int argc, const char * argv[]) {
	    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

		int a = 1, b = 2;

		// before function
		NSLog(@"a, b == %i, %i", a, b);

		// vanilla
		myfunc(&a, &b);
		NSLog(@"a, b == %i, %i", a, b);

		// we can declare a pointer to a function
		// note the parentheses around the function name
		void (*ptr) (int *a, int *b);
		ptr = myfunc;

		// using the ptr
		ptr(&a, &b);
		NSLog(@"a, b == %i, %i", a, b);

	    [pool drain];
	    return 0;
	}

Point to my function baby.

08:12:16.534 Pointers[3608:903] a, b == 1, 2
08:12:16.536 Pointers[3608:903] a, b == 2, 1
08:12:16.537 Pointers[3608:903] a, b == 1, 2

New Layout and Style

2010-02-18T00:00:00-08:00

New Layout and Style

18 Feb 2010 – Denver, CO

First post of the new year, and a shiny new look to boot. Been spending my early morning (thank you Dunkin Donuts coffee) reading this:

First reviews and notes to hopefully start this weekend.

Blocks and Procs in Ruby

2009-05-14T00:00:00-07:00

Blocks and Procs in Ruby

14 May 2009 – Denver, CO

So, in addition to a minor re-org (took the last post of the front page and decided to just show a list of posts), I continued reading this awesome article. Here’s the distilled version.

Procs

A Proc, at its simplest, is a block of code that has been bound to a local variable, also known in various forms (some of these more accurate than other) as “function objects”, “functors” and “closures”. They act like any other “first-class” objects, can be passed around, stored in data-structures.

 
>> def foo(a, b)
>> a.call(b)
>> end
=> nil
>>  a = Proc.new {|param| puts "'a' being executed on param #{param}"}
=> #<Proc:0x00587a14@(irb):4>
>> b = "hello"
=> "hello"
>> foo(a, b)
'a' being executed on param hello
=> nil

In the above example, we’ve created a proc “a” which accepts params “param”. When we pass both to foo, it simply calls “a” and passes “b” in.

We have a choice when creating procs – between “Proc.new” and “lamdba”.

 
?> x = lambda {|y| puts y}
=> #<Proc:0x0057a24c@(irb):16>
>> x.call("hello")
hello
=> nil

In short, they differ slightly in how the return from methods (Proc.new created Procs will return immediately, lambda will not) and the fact that lambda does parameter checking and Proc.new does not.

Methods

Methods are blocks of code, bound to an object, that have access to its instance variables. The interesting thing about a method here is that you can define ‘top-level’ methods, which is implicitly bound to the Object class.

 
>> def s; puts "s"; end
=> nil
>> p Object.methods
["inspect", "private_class_method", "const_missing", "clone", 
"method", "public_methods", "public_instance_methods", ...
=> nil
>>

And we can also dynamically call the method using send (we can pass either a String or the Symbol for the method name).

 
?> o = Object.new
=> #<Object:0x5e9cf0>
>> o.send(:s)
s
=> nil
>>

Blocks

A Block is a (lets called it ‘uninstantiated’) proc. Its the block of code for example in the braces after the lambda command.

 
>> x = lambda {"puts i am a proc"}
=> #<Proc:0x005f0924@(irb):1>
>> def f(func)
>> func.call
>> end
=> nil
>> f(x)
=> "puts i am a proc"
?> def g
>> yield
>> end
=> nil
>> g {"i am a block, implicitly turned into a proc when passed to method"}
=> "i am a block, implicitly turned into a proc when passed to method"

On a final note, I’ve been using this sidebar which is truly awesome.

Method Params in Ruby

2009-04-29T00:00:00-07:00

Method Params in Ruby

29 Apr 2009 – Denver, CO

Couple of things: firstly, I was a little fed-up trying to keep the format of code when I pasted it into this blog, and Gist and Pastie felt like overkill (although I do like those services, especially Pastie). From my github RSS feed there seemed to be a lot of activity on Jekyll so I was browsing the README and chanced upon the fact that it supports Pygment which was just what I needed. One quick python easy_install and I was up and running. Sweet!

So, I spent some time this evening looking at methods & params in Ruby (actually: here). Heres the short and sweet:

Hashes

Passing a Hash to a method will result in those parameters being rolled up into a single Hash Variable.

 
>> def accept(var)
>> var.inspect
>> end
=> nil
>> accept('a')
=> "\"a\""
>> accept('a' => 1)
=> "{\"a\"=>1}"
>> accept('a'=>1,'b'=>2)
=> "{\"a\"=>1, \"b\"=>2}"

Asterisk

An asterisk (the ‘splat’ operator) can be used on last parameter of a method to pass additional params. Additional params are collected into an array in the last parameter.

 
>> def accept2(a, b, *c)
>> c.inspect
>> end
=> nil
>> accept2(1, 2, 3, 4, 5)
=> "[3, 4, 5]"

And the reverse is true, an array parameter can be prefixed by asterisk to be expanded as its passed to the method.

 
>> a = [1, 2, 3]
=> [1, 2, 3]
>> accept2(*a)
=> "[3]"

Ampersand

Much like asterisk, except you are telling the method that a code block will be passed in. A proc object will be created and assigned to the param name.

 
>> def accept3(&code)
>> code.call
>> end
=> nil
>> accept3 {puts "philly"}
philly
=> nil

Too Many Open Files in Rails - Temp Files in Mongrel

2009-03-16T00:00:00-07:00

Too Many Open Files in Rails – Temp Files in Mongrel

16 Mar 2009 – Denver, CO

I’ve had a whole bunch of pain the last couple of days with mongrel dumping tmp files on me and filling up my ulimit quota causing Rails to fall over.

It started when I started posting a bunch of multi-part files to Rails and letting attachment_fu do the dirty-work, but I quickly hit upon this:

 
Processing DocumentsController#create to xml ...
...

MissingSourceFile (no such file to load -- .../git/eiger/app/models/document.rb):
	.../lib/active_support/dependencies.rb:382:in `load_without_new_constant_marking'
	.../lib/active_support/dependencies.rb:382:in `load_file'
	.../lib/active_support/dependencies.rb:521:in `new_constants_in'

A quick check meant:

 
:eiger philipmcmahon$ ulimit -n
256

and

 
:~ philipmcmahon$ lsof /dev/disk0s2 | grep mongrel |  wc -l
245

philip-mcmahons-macbook-pro:~ philipmcmahon$ lsof /dev/disk0s2 | grep mongrel
ruby      25400 philipmcmahon    6u   REG   14,2    712224 13096890 
/private/var/folders/+Z/+ZLlmYL1FlmQ5osVVIedbU+++TI/-Tmp-/mongrel25400-0
ruby      25400 philipmcmahon    7u   REG   14,2    348977 13102715 
/private/var/folders/+Z/+ZLlmYL1FlmQ5osVVIedbU+++TI/-Tmp-/mongrel25400-0
ruby      25400 philipmcmahon    8u   REG   14,2    626096 13096931 
/private/var/folders/+Z/+ZLlmYL1FlmQ5osVVIedbU+++TI/-Tmp-/mongrel25400-0
ruby      25400 philipmcmahon    9u   REG   14,2   1350716 13097079 
/private/var/folders/+Z/+ZLlmYL1FlmQ5osVVIedbU+++TI/-Tmp-/mongrel25400-0
ruby      25400 philipmcmahon   10u   REG   14,2    203294 13096875 
/private/var/folders/+Z/+ZLlmYL1FlmQ5osVVIedbU+++TI/-Tmp-/mongrel25400-0
ruby      25400 philipmcmahon   11u   REG   14,2   2699790 13097300 
/private/var/folders/+Z/+ZLlmYL1FlmQ5osVVIedbU+++TI/-Tmp-/mongrel25400-0
ruby      25400 philipmcmahon   12u   REG   14,2    178210 13096959 
/private/var/folders/+Z/+ZLlmYL1FlmQ5osVVIedbU+++TI/-Tmp-/mongrel25400-0
ruby      25400 philipmcmahon   13u   REG   14,2    217603 13097577 
/private/var/folders/+Z/+ZLlmYL1FlmQ5osVVIedbU+++TI/-Tmp-/mongrel25400-0
ruby      25400 philipmcmahon   14u   REG   14,2   1348152 13097069 
/private/var/folders/+Z/+ZLlmYL1FlmQ5osVVIedbU+++TI/-Tmp-/mongrel25400-0
ruby      25400 philipmcmahon   15u   REG   14,2    203292 13096968 
/private/var/folders/+Z/+ZLlmYL1FlmQ5osVVIedbU+++TI/-Tmp-/mongrel25400-0

Holy shit!

I have no idea what those file-pointers are, but I do know that they are caused by the file part of multi-part form upload data. For a while I thought it was related to creating Tempfile classes, but after it while it became clear that it was mongrel doing whatever.

To cut a long story short, I switched to webrick and the problem went away.

Singleton classes or Eigenclasses

2009-01-28T00:00:00-08:00

Singleton classes or Eigenclasses

28 Jan 2009 – Las Vegas, NV

Vegas for the week at a conference. In the Java world, ‘Singleton’ (at least to me) usually referred to the design pattern which allowed you to ensure that there would always only be a maximum of one object instance of a particular class. It was usually implemented by making the constructor private and providing an access method that returned a single (usually static) instance of an singular object. It might looked something like this:

 

public class SingletonExample {

	/**
	 * Private class variable
	 */
	private static SingletonExample singleton;
	
	/**
	 * This is the only method available to access the class variable.
	 * @return the singleton instance
	 */
	public static SingletonExample onlyInstance() {
		if (singleton == null)
			singleton = new SingletonExample();
		return singleton;
	}
	
	/**
	 * The Ctr should be private
	 */
	private SingletonExample() {
	}
}

Things appear to be slightly different in the Ruby world. A singleton or eigenclass in the Ruby world refers to a particular instance of an object, and ruby allows us to override the methods and behaviors of a particular object (note – not class).

 
	?> class A
	>> end
	=> nil
	>> 
	?> a = A.new
	=> #<A:0x5ef664>
	>> b = A.new
	=> #<A:0x5ee1d8>
	>> 
	?> class << a
	>> def to_s; "Instance method"; end
	>> end
	=> nil
	>> 
	?> a
	=> Instance method
	>> b
	=> #<A:0x5ee1d8>

For more checkout: whytheluckystiff.

Multiple Inheritance in Ruby

2009-01-25T00:00:00-08:00

Multiple Inheritance in Ruby

16 Jan 2009 – Miami, FL

I’m in Miami for a couple of days on business and spent the plane journey reading up on Ruby Mixins and how it gets around the multiple inheritance problem.

Coming from a Java background, where there was no multiple inheritance (technically there isn’t any in Ruby either), the solution to this one was pretty interesting to me. Ruby uses the concept of a Mixin which is really just a module. A module can’t be instantiated and is just a set of functionality.

 
	?> module Mixin
	>> def mixin_method
	>> "Mixin method"
	>> end
	>> end
	=> nil
	>> 
	?> class A
	>> include Mixin
	>> end
	=> A
	>> 
	?> a = A.new
	>> a.mixin_method
	=> "Mixin method"

Where it gets interesting (and the reason Java never supported multiple inheritance) is what to do if we have conflicting methods in our superclasses (“Diamond Problem” anyone ?). Technically, Ruby does not support multiple inheritance, but you can mixin multiple modules into other classes or modules. How does Ruby deal with the diamond problem ? Well it basically uses the last method to be included. You can see below, that the returned method is based on the last one to be introduced to the lookup chain.

 
	?> module MixinA
	>> def hello
	>> "hello from A"
	>> end
	>> end
	=> nil
	>> 
	?> module MixinB
	>> def hello
	>> "hello from B"
	>> end
	>> end
	=> nil
	>> 
	?> class C
	>> include MixinA
	>> include MixinB
	>> end
	=> C
	>> 
	?> c = C.new
	=> #<C:0x5e6550>
	>> c.hello
	=> "hello from B"
	>> 
	?> class D
	>> include MixinB
	>> include MixinA
	>> end
	=> D
	>> 
	?> d = D.new
	=> #<D:0x5e0ca4>
	>> d.hello
	=> "hello from A"

And thats it. You can also include a module in another module, just like normal inheritance. Module is actually a super-class of Class, but classes cannot be mixed-in to other classes, only Modules can.

 
	>> module MixinA
	>> def hello
	>> "hello"
	>> end
	>> end
	=> nil
	>> 
	?> module MixinB
	>> include MixinA
	>> def hello2
	>> "hello2"
	>> end
	>> end
	=> nil
	>> 
	?> class C
	>> include MixinB
	>> end
	=> C
	>> 
	?> c = C.new
	=> #<C:0x5e7608>
	>> c.hello
	=> "hello"
	>> c.hello2
	=> "hello2"

For a more complete introduction, of course you can simply `ri Module`.

Using the GitHub API to Display your Repositories

2008-12-29T00:00:00-08:00

Using the GitHub API to Display your Repositories

29 Dec 2008 – Draperstown, Northern Ireland

I wanted to display a list of my repositories on my homepage. Spent a while fluffing about with the jQuery.getJSON call, but in the end found it preferable to use the callback parameter combined with jQuery.getScript.

Heres the code, which will populate a div with the id ‘repos’:

We are up and running

2008-12-29T00:00:00-08:00

We are up and running

29 Dec 2008 – Draperstown, Northern Ireland

Bringing the blog up was pretty painless, and full kudos must go to mojombo for both the sweet jekyll idea and tool, and even css style (yes, I was that lazy). I love the ability to blog via a git commit, very cool and minimal overhead. The Textile format is pretty new to me (I know – where have I been ?) but I’m really enjoying it.

With regard to the whole git vs svn thing, I didn’t really have any problems with svn, although the merging process could be a little annoying. I’ve been using these guys for a while without complaint, so I’d recommend them if you are taking the svn path. If the git and github thing works out I may end end moving away from those guys. So far I like the distributed repo aspect of git – the fact I can commit to a local repo and its almost instant, and then push to a remote when I am ready, is great.

I’ve been planning some big changes to geosack.com (very interested in location based services at the minute), so it may be the first victim to be migrated to github. Last remaining item on the list is to find & install a git bundle for Textmate.

Switching to Git (and GitHub)

2008-12-28T00:00:00-08:00

Switching to Git (and GitHub)

28 Dec 2008 – Moy, Northern Ireland

Decided to finally make the move from svn to git for all my projects, and in the process am considering a move to GitHub, so we’ll see how this goes. Mikey Finn is sitting here playing COD World at War, so I’m doing this to a soundtrack of explosions and death.

Will probably spend a couple hours playing with Jekyll and if things look good, will start the migration of Geosack.