jBoxer

Why eating sushi is a stressful experience for me

2012-09-02T12:27:00-07:00

I saw a Reddit thread asking if other people eat parts of their meal in proportion to one another so that all the food is gone at the same time.

I definitely do this, and it’s usualy fine, but I have a real problem with sushi/maki. If I’m eating multiple rolls, I always need to come up with a sequence to eat them in that’s as well-distributed as possible.

Of course, this is easy if all my rolls have the same number of pieces. For example, if I get a Spicy Tuna (S) roll and a Philadelphia (P) roll, and they each have 6 pieces, my order will be:

P S P S P S P S P S P S

Easy. (and to note: I eat the Philadelphia before the Spicy Tuna because I like Spicy Tuna more and I want it to be the last taste in my mouth).

Now, let’s say I order a Spider (I, cuz S and P are taken) roll and a Caterpillar (C) roll. A Spider roll usually has 4 pieces, and a Caterpillar roll usually has 8. So, I’ll do this:

C C I C C I C C I C C I

Still easy.

Now, let’s say I pair the Spicy Tuna roll (S, 6 pieces) with the Caterpillar roll (C, 8 pieces). I do this:

C S C S C S C – C S C S C S C

That – in there is meaningless; it’s just to help your eye break it up better. In short, I’m dividing up my eating experience into two halves, each of which start and end with a Caterpillar roll piece, and then alternate between that and the Spicy Tuna.

Trickier.

Enter the chaos-inducing Spicy Scallop roll (Jesus Christ why does all sushi start with the same letters? This is A I guess). At my favorite sushi restaurant, it has 5 pieces. Fuck.

If I’m eating it with a Spicy Tuna (S, 6) roll, it’s not so bad:

S A S A S A S A S A S

If I’m eating it with a Caterpillar (C, 8) roll…

C A C A C – C A C – C A C A C

Now my eating experience has two halves and a short halftime show in the middle. Maybe I’ll eat some ginger during that time as well. Fuck that, straight ginger is nasty.

So yeah, this adds a lot of stress to my sushi-eating experience. But it doesn’t end there. What if I’m extra hungry, and get three rolls; Spicy Tuna (S, 6), Caterpillar (C, 8), and Spicy Scallop (A, 5)? Once I stop hyperventilating, I’ll do it like this:

S C A C S – C A C S A S C A C – S C A C S

For the record, I do understand how fucked up this is, but this brilliant three-course-meal-within-a-one-course-meal means I never eat the same piece twice in a row, and I get the satisfaction of eating a palindrome.

It can get worse than this. Sometimes, I want to get four or five rolls and split them with my girlfriend. Sometimes I know I’m with someone who will want to trade a piece, so I have to factor in a group of 1.

I’ll spare you these horrors, since I think you get the idea. But if you’re ever out eating sushi with me, and I’m sitting there staring at my untouched plate with an intense look on my face while everyone else is half done, now you know why.

Converting to the new RSpec 2.11 expectation syntax

2012-07-09T15:28:00-07:00

RSpec 2.11 was released a few days ago. The biggest change is a brand new expectation syntax by Myron Marston.

Now, instead of writing this:

Old expectation syntax

foo.should eq(bar)
foo.should_not eq(bar)

You can write this

New expectation syntax

expect(foo).to eq(bar)
expect(foo).not_to eq(bar)

Myron’s blog post does a fantastic job explaining why this is better. To summarize:

RSpec does not own every object in the system, so it cannot add the should and should_not methods to every object. This can lead to some really confusing errors. Using expect works around this.
Block expectations already used the expect syntax out of necessity. The inconsistent syntax made it harder to read specs that used both. Using expect for normal expectations unifies the syntax, making these specs much more readable.

What follows is a step-by-step guide to convert all your specs from the old syntax to the new one as quickly as possible.

Change all equality operator matchers

The new expectation syntax does not support foo.should == bar. You need to do expect(foo).to eq(bar). So, go through all your specs and make this change.

You can use this regular expression:

Regular expressions for replacing == with eq()

# Note that these both start with a leading space. Don't forget them, or they won't work.

# Find
/ == (.*)$/

# Replace  
/ eq($1)/

For global find/replace stuff, I prefer to open and editor and click “Replace” over and over. It’s slower, but I don’t have to track down mistakes afterwards, and I get to improve my regex as I go. Feel free to do it however you want, but make sure to check your diff afterwards.

Once you’re done, re-run your specs and make sure everything is still passing. Note that we haven’t yet changed should to expect, so everything should be passing.

Change other unsupported operator matchers

These should be rare enough that you don’t need a regex. If you do, write it and send it to me, and I’ll include it in here and give you credit.

Go through all your specs and make these changes:

Unsupported operator matcher replacements

# Regex matching
"a string".should =~ /a str[iou]ng/ # Old, bad.
"a string".should match(/a str[iou]ng/) # New, good.

# Matching array contents while ignoring order
[1, 2, 3].should =~ [2, 3, 1] # Old, bad.
[1, 2, 3].should match_array([2, 3, 1]) # New, good.

# Comparison matchers (do this with ALL matchers: <, <=, >, >=)
foo.should < 10 # Old, very bad. You should never have been using this.
foo.should be < 10 # New, good

Re-run your specs and make sure everything is still passing.

Disallow “should” from your specs

Open your spec/spec_helper.rb file and add the following lines to your configuration block:

spec/spec_helper.rb

RSpec.configure do |config|
# .. other stuff

  # Add all three of these lines:
  config.expect_with :rspec do |c|
    c.syntax = :expect
  end

# .. other stuff
end

This will stop RSpec from adding should to all objects. Make sure you add all three lines; I didn’t realize it was within a block at first, and got errors.

If you run your specs now, pretty much everything should fail.

Replace should and should_not with expect

This is the most tedious part. Luckily, I came up with a regex that works for both should and should_not. Here it is:

Regular expressions for replacing should/should_not with expect

# Find
/^(\s+)(.*(?=.should)).should(_)?(not)? (.*)$/

# Replace
/$1expect($2).$4$3to $5/

One caveat: this will not work for expectations that aren’t on their own line. Example (using Capybara)

Working and non-working examples for regex

# Regex WON'T find/replace properly
within('#header') { page.should have_content('About') }

# Regex WILL find/replace properly
within '#header' do
  page.should have_content('About')
end

The first example won’t work, because the expectation comes after within(‘#header’) {. The second will work, because the expectation is on its own line.

So, like I said above, don’t just do one “Replace All”; click the “Replace” button in your editor over and over, so you can spot these broken cases and fix them manually.

I tried for awhile to fix these broken cases, but I’m pretty sure it’s not possible via regex. If someone can prove me wrong, I’d love to update this guide and give you credit.

After doing this in all your specs, re-run them. Everything should pass. If not, comment, and I can try to help you figure out what’s up.

Changing a Rails 3 project name

2012-03-15T12:00:00-07:00

I’ve had to change Rails 3 project names a few times now. It’s too bad there’s no rake command for it. Here’s the next best thing: a step-by-step guide.

For the sake of this example, let’s say I’m changing my name name from “Teach” to “Learn”.

Update your app’s module name

In /config/application.rb, change the name of the module:

/config/application.rb

module Learn # Used to be `module Teach`
  class Application < Rails::Application
    # …
  end
end

Update references to your app’s module name

Your app’s module name should appear in /config.ru:

/config.ru

# This file is used by Rack-based servers to start the application.

require ::File.expand_path('../config/environment',  __FILE__)
run Learn::Application # Used to be `run Teach::Application`

And in /Rakefile:

/Rakefile

#!/usr/bin/env rake
# Add your own tasks in files placed in lib/tasks ending in .rake,
# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.

require File.expand_path('../config/application', __FILE__)

Learn::Application.load_tasks # Used to be `Teach::Application.load_tasks`

Your app’s module name should also appear in a bunch of files under the /config directory. It should appear in /config/environments.rb.

/config/environments.rb

# Initialize the rails application
Learn::Application.initialize! # Used to be `Teach::Application.initialize!`

It should also appear in all the environment-specific configurations in /config/environments/*.rb (which should be development.rb, production.rb, test.rb, and any other environments you have configured). Change them all:

/config/environments/*.rb

Learn::Application.configure do # Used to be `Teach::Application.configure do`
  # Settings specified here will take precedence over those in config/application.rb
  # …
end

And in your initializers (under /config/initializers/). At the very least, /config/initializers/secret_token.rb and /config/initializers/session_store.rb should have it:

/config/initializers/secret_token.rb

# Your secret key for verifying the integrity of signed cookies.
# If you change this key, all old signed cookies will become invalid!
# Make sure the secret is at least 30 characters and all random,
# no regular words or you'll be exposed to dictionary attacks.
Learn::Application.config.secret_token = 'garbagestring'
# Used to start with `Teach::Application`

/config/initializers/session_store.rb

Learn::Application.config.session_store :cookie_store, key: '_learn_session'

# Use the database for sessions instead of the cookie-based default,
# which shouldn't be used to store highly confidential information
# (create the session table with "rails generate session_migration")
# Learn::Application.config.session_store :active_record_store

# For the sake of cleanliness, I changed it from `Teach::Application` in both the actual
# line of code and the comment. Also, `:key` used to be '_teach_session'.

And in your /config/routes.rb file:

/config/routes.rb

Learn::Application.routes.draw do # Used to be Teach::Application.routes.draw
  # Routes in here
end

Finally, for consistency’s sake, if the names of your databases include your app name, you should update those in /config/database.yml

/config/database.yml

development:
  adapter: mysql2
  encoding: utf8
  reconnect: true
  database: learn_development # Used to be teach_development
  username: root
  password:

test:
  adapter: mysql2
  encoding: utf8
  reconnect: true
  database: learn_test # Used to be teach_test
  username: root
  password:

production:
  adapter: mysql2
  encoding: utf8
  reconnect: true
  database: learn_production # Used to be teach_production
  username: root
  password:

Search your app and lib folders

grep through your /app and /lib folders to find any mentions of your project name and change them. This might be a little tedious if you have a name that conflicts with a bunch of Ruby/Rails stuff (like “def” or something stupid like that), but you only have to do it once.

Done!

That’s it! Now you have a renamed Rails 3 app.

Note: I did this on Rails 3.2.1. It’s possible some things will be different on other versions.

BostInnovation’s Seth Priebatsch Article is Childish Garbage

2011-11-16T13:04:00-08:00

Disclaimer: I was SCVNGR’s lead iOS developer for almost two years. I started a new job at GitHub last month. This is neither a critique nor a defense of the actions or words of Seth Priebatsch or SCVNGR.

Today, BostInnovation published an article called Seth Priebatsch Thinks Everyone at BostInno is Painfully Stupid… Really?. In it, they publish an internal SCVNGR email in which Seth insults them, then spend the rest of the article defending themselves from his insults and offering him advice on how to have fun and run a company.

Like most media outlets, I have mixed feelings about BostInnovation. The article in question, however, is childish garbage.

The are some points to be made here that anyone who is techy enough to read BostInnovation knows. There’s no way to prove this email is real. There’s no way to prove that the “leaker” didn’t tweak it. But those aren’t the important part.

The important part is, this was an internal email. Were it not for BostInnovation, under 100 people would’ve read it, all of whom work for SCVNGR. This email was no threat to BostInnovation’s readership. This is reminiscent of elementary school kids intercepting a passed note and reading it out loud to all their friends.

If the focus of this article was “Seth is lying to the media and investors,” that would be a different story (and would require significantly more evidence). I would still be a bit off-put by the publishing of an internal email in a private company, but at least that would be news worth reading. Instead, the focus is “CEO of company thinks we’re dumb, so here’s why he’s weird and mean.” If I were an advertiser on BostInnovation, I would be pretty upset with this.

Bash’s PS1 Syntax: The Inspiration for Brainfuck?

2011-11-06T19:24:00-08:00

I just spent way too much time struggling to get my Bash PS1 variable working right. Originally, it looked like this (parse_git_branch is a Bash function I have defined elsewhere):

Old PS1

PS1="\w\e[35m\$(parse_git_branch)\e[m > "

Now, it looks like this:

New PS1

PS1="\w\[\e[35m\]\$(parse_git_branch)\[\e[m\] > "

The difference? I wasn’t escaping my color codes correctly, which was causing Terminal to wrap long commands onto the beginning of the same line.

Let me break down Bash’s color code syntax, because it makes me so angry. A minimal Bash color code looks like this:

Minimal Bash color code

\e[1;30m

\e[ means “here comes a color code” I guess.

1 means “make it bold”. If you don’t want bold, leave it out.

; means “I’m finished telling you that this is bold”. If you don’t want bold, or if you want default-colored text (explained below), leave it out.

30 means “dark gray”. Here’s an exhaustive list of valid numbers (no number means default color):

30 = dark gray
31 = red
32 = green
33 = yellow
34 = blue
35 = purple
36 = turquoise
37 = light gray

0-29 don’t do anything (at least in Terminal.app on OS X 10.7.2). No idea why they start at 30.

m means “my color code is over”.

If you match that format, all subsequent characters will be that color (until you define another color code).

But that’s not all! This sequence is escaped incorrectly. If you have it in your PS1, Terminal will look correct on startup, but if you type a long command that wraps past the first line, Terminal will wrap it back to the beginning of the line you’re on and start overwriting characters.

I bet you think the fix is to match the open square bracket with a closed one, right? If so, give yourself a half pat on the back, then punch yourself in the face. Here’s how to escape it correctly.

How to escape a Bash color code

\e[1;30m     # Wrong
\[\e[1:30m\] # Right

You need to close match the open bracket (with an escaped close bracket), but also add another open (escaped) bracket to the front, also with no closer.

Anyone wanna educate me on the reason for all this madness? Right now, it just feels like some dude thought regular expression and strftime syntax were too verbose.

Using acts_as_list in a polymorphic scope

2011-10-09T15:52:00-07:00

If you’re using acts_as_list in a polymorphic scope, you need to define the scope a little bit differently to make everything work right.

Here’s the non-polymorphic example from acts_as_list’s README:

acts_as_list in a normal (non-polymorphic) scope

class TodoItem < ActiveRecord::Base
  belongs_to :todo_list
  acts_as_list scope: :todo_list # Note the single-item scope
end

We pass :todo_list as the scope (which acts_as_list converts to the todo_list_id column).

Now, let’s say we’re making a polymorphic Picture model (like in the Polymorphic Associations section of the Ruby on Rails Guides), and we want pictures to be sortable and reorderable. Here’s the right way to do it:

acts_as_list in a polymorphic scope (the RIGHT way)

class Picture < ActiveRecord::Base
  belongs_to :imageable, polymorphic: true
  acts_as_list scope: [:imageable_id, :imageable_type]
end

Note how, in the Picture model, the scope we pass to acts_as_list is an array of the two columns that make up the polymorphic association. If we were to follow our template from TodoItem and do it this way:

acts_as_list in a polymorphic scope (the WRONG way)

class Picture < ActiveRecord::Base
  belongs_to :imageable, polymorphic: true
  acts_as_list scope: :imageable
end

Everything would run correctly, but imageables with the same ID and different types would have some problems. Specifically, determining which pictures are first and last:

Bugs caused by using acts_as_list in a polymorphic scope the WRONG way

class Picture < ActiveRecord::Base
  belongs_to :imageable, polymorphic: true
  acts_as_list scope: :imageable
end

class Employee < ActiveRecord::Base
  has_many :pictures, as: :imageable
end

class Product < ActiveRecord::Base
  has_many :pictures, as: :imageable
end

employee1 = Employee.create      # employee1 is an Employee with id=1
employee2 = Employee.create      # employee2 is an Employee with id=2
product1 = Product.create        # product1 is a Product with id=1

employee1.pictures.create        # Create a new picture on employee 1
employee2.pictures.create        # Create a new picture on employee 2
product1.pictures.create         # Create a new picture on product 1

puts employee1.pictures[0].last? # false, unexpected
puts employee2.pictures[0].last? # true
puts product1.pictures[0].last?  # true

Since each imageable has only one Picture, last? (an acts_as_list method that checks if the item is the last one in scope) should return true for all three. But, the first line says false. Since we’re only telling acts_as_list to scope on :imageable (which it converts to imageable_id), it has no way of telling between the Employee with an id of 1 and the Product with an id of 1. So, it thinks that Employee 1’s picture belongs to the same record as Product 1’s picture, and thus, thinks that only Product 1’s picture is last?.

If you tell acts_as_list the full story, it won’t get confused:

Correct results from using acts_as_list in a polymorphic scope the RIGHT way

class Picture < ActiveRecord::Base
  belongs_to :imageable, polymorphic: true
  acts_as_list scope: [:imageable_id, :imageable_type]
end

class Employee < ActiveRecord::Base
  has_many :pictures, as: :imageable
end

class Product < ActiveRecord::Base
  has_many :pictures, as: :imageable
end

employee1 = Employee.create      # employee1 is an Employee with id=1
employee2 = Employee.create      # employee2 is an Employee with id=2
product1 = Product.create        # product1 is a Product with id=1

employee1.pictures.create        # Create a new picture on employee 1
employee2.pictures.create        # Create a new picture on employee 2
product1.pictures.create         # Create a new picture on product 1

puts employee1.pictures[0].last? # true
puts employee2.pictures[0].last? # true
puts product1.pictures[0].last?  # true

Now that acts_as_list knows to look at both the imageable_id and the imageable_type, it can tell the difference between Employee 1 and Product 1, and returns true for all three last?s, as expected.

My pre-ARC Objective-C memory management conventions

2011-10-03T12:06:00-07:00

iOS 5 is coming soon, and introduces ARC. ARC will make Objective-C memory management significantly simpler. But, it will be a long time before iOS 5 is ubiquitous, and I’m not sold on the subset of ARC that will be available for iOS 4. So, in the meantime, I thought people might benefit from seeing the conventions I use to keep Objective-C memory management simple. Most iOS developers probably already follow something close to this, but it doesn’t hurt to have it written out.

If you follow these five simple rules, you should pretty much never get a memory leak or a crash from over-releasing.

1. Always declare @properties for your object instance variables

If you’re putting an instance variable on a class and it’s an object, declare a property for it.

Declaring properties

@interface MyObject : NSObject

@property (nonatomic, retain) NSDate* someDate;
@property (nonatomic, retain) AVPlayerLayer* someLayer;
@property (nonatomic, retain) NSMutableArray* someMutableArray;
@property (nonatomic, copy) NSString* someString;
@property (nonatomic, copy) NSArray* someImmutableArray;
@property (nonatomic, assign) id<MyObjectDelegate> delegate;

@end

By default, you should always declare your object properties as retain.

If you’re declaring a property for an object that’s expected to be immutable, but has a mutable subclass (for example, if you’re declaring an NSArray property, which has the NSMutableArray subclass), declare it as copy instead of retain.

If you’re declaring a property for an object that is guaranteed to be retained elsewhere (for example, a delegate, or something that you’re also storing in an array and just need a convenient shortcut to), you can declare it assign. Be very careful with this though. If you’re unsure, just do retain or copy.

You’ll also need to @synthesize all these properties in your @implementation:

Synthesizing properties

@implementation MyObject

@synthesize someDate;
@synthesize someLayer;
@synthesize someMutableArray
@synthesize someString;
@synthesize someImmutableArray;
@synthesize delegate;

// …

@end

Finally, you’ll need to release all of the retain and copy properties (but not the assign properties) in your dealloc. This is the only place in your code where you should refer to your properties without self. (which means you’re actually accessing the instance variables rather than the properties).

Releasing properties

@implementation MyObject

// …

- (void)dealloc {
  [someDate release]; // Note that we're using someDate, not self.someDate
  [someLayer release];
  [someMutableArray release];
  [someString release];
  [someImmutableArray release];
  // Note that we aren't releasing delegate
}

2. Always use `self` when accessing a property

If you don’t use self, you will be accessing the underlying instance variable directly, rather than going through the @synthesized getter/setter.

self.someImmutableArray = [NSArray array];             // Correct!
NSLog(@"printing array: %@", self.someImmutableArray); // Correct!
someImmutableArray = [NSArray array];                  // WRONG
NSLog(@"printing array: %@", someImmutableArray);      // WRONG

If you skip the @synthesized getter/setter, you skip the memory management rules you defined in your @property, which will lead to problems. The only exception to this is mentioned in rule 1: in your dealloc method, when releasing the object.

3. Make sure all newly-created objects are autoreleased

There is a bit of disagreement on the community on this one, but I have yet to hear a compelling argument for all but the most extreme cases, so we’ll go with the side that makes life easier. Whenever you create a new object, make sure it is autoreleased.

The convention for this is as follows: all methods that return objects return autoreleased objects, unless the method name starts with init or copy. For example:

self.someNumber = [NSNumber numberWithInteger:5];       // autoreleased
self.someNumber = [[NSNumber alloc] initWithInteger:5]; // not autoreleased

If you create an object with a method that starts with init or copy, make sure you explicitly tell it to autorelease:

self.someNumber = [[[NSNumber alloc] initWithInteger:5] autorelease]; // autoreleased

This will save you a lot of headaches. Any objects that you don’t want to keep will be released automatically. Any objects that you do want to keep should be assigned to a property, and since the property is retain or copy (as mentioned in rule 1), they will be retained and kept automatically.

4. Never call `retain` on anything

The method retain is not called once in all the lines of Objective-C code in my current code base. If you find yourself needing to explicitly retain an object, create a retain or copy property for it instead (as mentioned in rule 1) and assign it to that property.

5. Never call `release` on anything (except in `dealloc`)

If you’re following rule 4, there should never be a time when you explicitly need to release an object, except in your class’s dealloc method (as mentioned in rule 1).

If you follow all these rules, you should never have to think about memory management. If you deviate from any of them, you could end up in weird tough-to-debug situations, so try your hardest not to. If you find yourself in a situation where you think you absolutely need to deviate, write a comment on this post explaining your situation, and I’ll see if I can help.

Moving to Octopress

2011-09-09T15:47:00-07:00

I’m now moving all my stuff from Media Temple and Tumblr to here. All posts before this one are reposts.

My tips for an awesome WWDC

2011-06-14T20:57:00-07:00

I’ve seen a bunch of people who just got back from WWDC posting advice on how to have the best time possible. I figured I should do the same thing. Here are my tips.

Don’t get in the keynote line early

Even if you want to sit near the front, you don’t need to get in line until around 8:30am. It’s really easy to just run and push past all the submissive nerds and get an awesome seat.

Live-blog the keynote

People who aren’t at the keynote would much rather read you repeating Steve Jobs’ announcements sentence-by-sentence on Twitter than watch a live feed with pictures. Also, other people in the audience who are following you will love reliving the moment when they look through their tweets later on.

Complain about the food

You paid a lot of money for tickets, which entitles you to demand customized gourmet meals. Food should be the main concern at any tech conference, and if you aren’t absolutely overjoyed by what you’re putting in your mouth, you aren’t getting your money’s worth.

Don’t silence your phone before a session begins

I know they ask you to before every session (and you should roll your eyes and say “do they have to say this every time?” when they do), but they’re really just forced to say that by law. In reality, all the speakers helped make these devices, and it’ll make them proud to see you using them. In fact, feel free to quietly answer your phone right in the middle of a talk. No one will notice.

Code during sessions

There are very few places in the world where you will have the opportunity to write code. A conference that you paid $1600 to attend is one of these places, and you should take advantage of that. Besides, you can just watch the session videos later.

Don’t go to any parties afterwards

You’re probably better at programming than the other attendees. Meeting them is pointless, and won’t be fun (and all the parties charge lots of money for alcohol, especially at Apple’s beer bash). Also, your hotel room is another one of the aforementioned few places in the world where you can code, so you should stay there and do that instead.

These tips will guarantee you a quality WWDC 2012. Also, don’t read any other WWDC tip posts, they’re probably trying to troll you.

The misguided priorities of Twitter

2011-05-18T20:54:00-07:00

Today, Twitter announced (with some awesome spin) that they would hamstring the direct message capabilities of all 3rd-party Twitter apps.

It’s been clear for awhile that one of Twitter’s monetization strategies is to force everyone to use their mobile apps over those of third-parties. This will let them show promoted trending topics in the newly-neutered Dickbar to all mobile users. I understand that Twitter needs to find a way to make money, but this direction strikes me as extremely misguided.

I believe this lock-in strategy will never create enough revenue to cover a non-trivial portion of their operating costs (never mind the $10 billion they turned down from Google). In the meantime, it will alienate the developers who were once the lifeblood of the Twitter ecosystem. Without these developers, the 3rd party apps that Twitter does want (cool aggregations, visualizations, etc.) will not be built, and new developer-fueled uses of the service will not be able to thrive.

It seems to me that the folks making business decisions at Twitter are severely underestimating the importance of certain parts of the community, and/or severely overestimating the potential revenue from their own mobile apps.

How to reset/revert a single file with Git

2010-07-08T20:41:00-07:00

I’m making this post more for my own reference than to help anyone else, but feel free to comment if you have questions or anything.

If you’ve made a commit with git (let’s call it “commit A”), and you want to make another commit (let’s call it “commit B”) that, among other things, reverts the changes made to a single file (let’s call it file1.rb) in commit A, use the following command:

git reset commit-a – path/to/file1.rb

That’ll create two sets of changes: a copy of the changes you made in commit A, and the inverse of the changes you made in commit A. The inverse is staged, while the copy is unstaged. Nine times out of ten, you’ll want to commit the staged changes (which, as they’re the inverse of the changes in commit A, will result in a revert of file1) and discard the unstaged ones.

My Doorbell Is Better Than Your "Please Rob Me"

2010-02-18T20:38:00-08:00

“Hey man, I know you really like Foursquare, but you should check out this new site called Please Rob Me. Foursquare is actually really dangerous, cuz now it’s easy for robbers to know when you’re not at your house!”

I’m a Foursquare user, and I’ve heard variations of this from over a dozen of my friends in the past 24 hours. For the record, I think “Please Rob Me” is a really funny and creative idea, and I love that they made it. However, anyone who is legitimately giving privacy/security advice over this is being ridiculous.

First of all, most people are out of the house from 9am to 5pm. Robbers know this, and Foursquare checkins don’t change it.

Second, there’s absolutely zero indication of whether or not anyone else is home, or how soon you’ll be getting back. These are much more crucial pieces of knowledge than “a single person was not in his house at this time”.

Last, and most important, a superior technology has existed for decades: the doorbell. Run around a neighborhood ringing doorbells of houses that look like they might be vacated, and break into the ones that no one answers.

“Oh but people don’t answer their doorbell every time, so a robber might break into an occupied house!”

Right. Just like people don’t have to actually be at a place to check into it on Foursquare, and like how checking in on Foursquare doesn’t mean no one else is home. There are potential false positives with both methods (and if there weren’t, people would be getting robbed a lot more). The point is, breaking in based on doorbell-ringing is much less dangerous than doing it based on Foursquare checkins, as it’s reasonably likely that no one is home if no one answers the doorbell

In reality, privacy via anonymity has always been a pretty shaky concept. Yes, checking into Foursquare does give robbers one more tool to make their job easier, but in the face of much better tools (like the doorbell), it’s negligible. If you chose to be a Foursquare user in the first place, Please Rob Me should have no impact on your decision.

The importance of attr_accessible in Ruby on Rails

2010-01-28T20:27:00-08:00

I’m sure this has been written about ad nauseum, but I spent some time yesterday explaining it to someone who didn’t understand, and now I feel like writing it up a bit more formally.

What is attr_accessible?

In Ruby on Rails, attr_accessible allows you to specify which attributes of a model can be altered via mass-assignment (most notably by update_attributes(attrs) and new(attrs)). Any attribute names you pass as parameters will be alterable via mass-assignment, and all others won’t be.

How does mass-assignment work normally?

By default, mass-assignment methods accept a hash of attribute values, each keyed by their associated attribute’s name. If I ran the following code:

User.new({ :name => 'Harry Potter', :email => 'hp@hogwarts.com' })

A new instance of the User model would be created, and the name and email attributes would be set accordingly. It can also be used to alter related models. For example:

User.new({
  :name => 'Albus Dumbledore',
  :is_teacher => true,
  :course_ids => [1, 2, 3] })

In addition to creating a user with the appropriate attributes, this will update the specified courses to be owned by this user(assuming a user has_many courses in our app).

How can this be abused?

Very easily. What if someone did this:

User.new({ :name => 'Draco Malfoy', :is_teacher => true })

This Draco Malfoy fellow may not actually be a teacher, but the system is none the wiser. Of course, the developer would never code this; in a real Rails app, the code is going to look like this:

User.new(params[:user])

The elements in params[:user] are taken from the POST/GET/PUT data passed along when the action was run. They’re thrown blindly into the mass-assignment, and any attributes whose names match the keys will be set.

“So what’s the big deal? Just don’t include an ‘is_teacher’ field in the web form, and the param won’t be there.” This is true for innocent users, but the malicious ones (and Draco Malfoy is definitely a malicious one) have an easy way around this. A web form is just a way to make it easy for users to pass data to your app. There are other ways. For example, if I wanted to register for the app via the command line instead of a browser, I could do it like this:

curl -d "user[name]=Harry Potter&user[email]=hp@hp.com" \
    http://myapp.com/users/

This sends a request to http://myapp.com/users/ and passes data in the exact format it would’ve appeared if I’d filled out a web form that asked for a name and email address. However, I could also do this:

curl -d \
    "user[name]=Draco Malfoy&user[email]=m@hp.com&user[is_teacher]=1" \
    http://myapp.com/users/

Since is_teacher is an attribute name in my User model, and mass-assignment methods blindly accept whatever attributes they see, Draco Malfoy has just set himself a teacher.

Even worse, I could use this to grab courses that may not be mine.

curl -d \
    "user[name]=Draco Malfoy&user[course_ids]=1&user[course_ids]=2" \
    http://myapp.com/users/

Draco Malfoy has now taken courses 1 and 2 away from whoever they originally belonged to (Dumbledore, if my memory serves me) and given them to himself.

How can we prevent this?

There are a few obvious but clumsy ways. We could skip mass assignment, setting each individual attribute in our controller, but this will introduce a lot of duplicate and unnecessary code. We could explicitly pull unwanted parameters out:

params.delete(:is_teacher)
params.delete(:course_ids)

This also introduces a lot of duplicate code. If we ever add new columns that we want to restrict, or decide we want to unrestrict a column, we’re going to have to go through the create and update actions, and any others that perform mass assignment.

We could factor these out into some sort of sanitize_params method on each model. This is a better solution, but you still have to call it in every action that alters the data. It’s definitely not as good as the built-in one: attr_accessible. We can add this to the top of the User model:

attr_accessible :name, :email

This white-lists name and email; these two attributes will be accepted from a mass-assignment method, while all others will be ignored. This is by far the safest way to do it; only attributes you’ve explicitly allowed (which hopefully means you’ve thought carefully about them) can be set by mass-assignment. This way, if some intern comes along and adds a bunch of dangerous columns or relations (payment_accepted or horcruxes, for example), no one has to think about updating the sanitize methods.

What does this not do?

I saw one person say “Why would I put anything in attr_accessible? Why would I want any of my attributes to be hackable?”

Make no mistake: attr_accessible is no substitution for proper access control. If all users have write access to all other users, attr_accessible will let one user change another’s name attribute if it’s specified. Regular authentication and access control must be used to prevent users from writing to model instances that they shouldn’t be able to write to. Once this is done correctly, attr_accessible can be used to prevent a malicious user from altering data of her own that she shouldn’t be able to alter.

To be more clear, it could be considered “hacking” if a user were able to change everyone’s name to “Voldemort”. attr_accessible can’t prevent this; you need to do proper authentication with something like Authlogic. Once you’ve set your controllers up to prevent a user from even attempting to change another user’s data, you’ve prevented this “hack”.

If the user tries to change his own name to “Voldemort”, that’s totally fine. We don’t care if he does it via the web app, curl, or anything else; users are allowed to change their own name. Including :name in attr_accessible isn’t making it “hackable”, because it’s an attribute that users should be able to change.

If the user tries to change his is_teacher attribute from false to true, that’s also considered “hacking”. We don’t want to let users do this, so we exclude :is_teacher from attr_accessible to prevent it.

Are attributes excluded from attr_accessible immutable?

No. They can still be altered, just not via mass-assignment. If I exclude is_teacher from attr_accessible, and I go:

hagrid = User.first(:conditions => { :name => 'Rubeus Hagrid' })
hagrid.is_teacher = true
hagrid.save

That will work just fine. The difference is, it forces you to set the attribute explicitly, so there’s no potential of accidentally setting an attribute unexpectedly passed to mass-assignment. This way, I can allow my non-dangerous attributes to be set via mass-assignment with attr_accessible, then explicitly provide or deny control over dangerous attributes in other actions.

Prototype analog to jQuery’s $(document).ready

2010-01-23T20:25:00-08:00

I have a lot of experience with jQuery, but less with Prototype. Recently, I needed to add some event handlers to some elements in a Ruby on Rails app I’m building. I searched for how to do the equivalent of jQuery’s $(document).ready() function in Prototype so that I could add the handlers after the document loaded, but most of the guides I found were out of date (I’m running Prototype 1.6.0.3, and I don’t know which version these guides were for, but they all made my Javascript console angry).

Eventually, I was able to piece it together after digging through the depths of the Prototype API documentation. It’s actually very simple:

document.observe('dom:loaded', function(){
  // do yo thang…
});

Wrap whatever you’re doing with that, and it won’t be run until the document is loaded.

Installing Ruby on Rails 2.3+ plugins From Github

2010-01-13T20:21:00-08:00

I’ve been banging my head against this wall for quite awhile now, and I just finally figured out the answer. Like I’ve done in other posts, I’ll just post what worked for me, and hopefully it’ll help other people.

I’m running Ruby 1.9 and Ruby on Rails 2.3.3 on Snow Leopard. I’ve been trying to install plugins (specifically, Authlogic and Carmen) for a couple days now using the following two commands (as taken from the main github pages):

script/plugin install git://github.com/binarylogic/authlogic.git
script/plugin install git://github.com/jim/carmen.git

In return, I received the following errors:

Plugin not found: ["git://github.com/binarylogic/authlogic.git"]
Plugin not found: ["git://github.com/jim/carmen.git"]

After a lot of poking around, it turns out you need to make two changes in order for this to work on Rails 2.3 or higher: change the git:// at the beginning of each URL to http://, and add a trailing slash to the end of each URL. So instead, run these:

script/plugin install http://github.com/binarylogic/authlogic.git/
script/plugin install http://github.com/jim/carmen.git/

They both worked perfectly for me, so hopefully they’ll work for you. If not, leave a comment and I’ll try to help.

Installing Erlang on Snow Leopard

2010-01-01T20:14:00-08:00

Here’s another in my series of “Installing X on Snow Leopard”. These aren’t official, well-tested guides; they’re just documentations of my attempts to compile and install various things on my personal computer. My last one (Installing MySQL on Snow Leopard) is my most popular post to date (aside from a couple that have been on Reddit). Erlang is less popular than MySQL, but hopefully this will still help a few people.

Downloading and unpacking

Go to http://erlang.org/download.html and download the Source for the newest version (when I was writing this, that was R13B03. After downloading, extract it to somewhere that’s convenient to get to with the Terminal.

Configure

Open the Terminal and cd into the directory you extracted Erlang to (mine was /Users/jake/src/otp_src_R13B03. Then run the following command:

./configure \
    –prefix=/usr/local/ \
    –enable-smp-support \
    –enable-threads \
    –enable-darwin-64bit

Note: You will probably get three errors. Read about them in the Configuration Errors section coming up.

The first three configure options are the defaults according to the README. However, I’ve had experiences where supposed defaults aren’t really the defaults when compiled on OS X, so I don’t like to take chances. –enable-darwin-64bit enables experimental support for the 64bit x86 Darwin binaries. This may not be necessary, but in general, 64-bit stuff has fewer problems on Snow Leopard, so I figured this was a good idea.

Configuration Errors

I got the following configuration errors:

jinterface    : No Java compiler found
wx            : Can not combine 64bits erlang with wxWidgets on
                MacOSX, wx will not be useable
documentation : fop is missing. The documentation can not be built.

These aren’t a problem. If you get any errors besides these, you’re in trouble. Leave a comment, and I’ll see if I can help.

Making and installing

These two commands shouldn’t give you any trouble:

make

And then, after make is done:

sudo make install

If you get any errors at either of these stages, leave a comment and I’ll try to help.

Making sure it works

Note: This canonical test is gratefully borrowed from erlang.org.

Put the following into a text file:

-module(test).
-export([fac/1]).

fac(0) -> 1;
fac(N) -> N * fac(N-1).

Save it as test.erl in a directory that’s easy to get to with the Terminal. Then, from the Terminal, cd into that directory and type erl (which, if everything worked right, should start the Erlang command-line interpreter). From the interpreter, run the following commands:

1> c(test).
{ok,test}
2> test:fac(20).
2432902008176640000
3> test:fac(40).
815915283247897734345611269596115894272000000000

Note: Lines starting with N> (where N is a number) are lines you should type (but just type the stuff coming after N>). The other lines represent output.

c(test). compiles test.erl (assuming it’s in the directory you cd‘ed into). test:fac(20). and test:fac(40). runs your factorial function.

So, that’s what worked for me. If anyone has any problems along the way, leave a comment and I’ll try to help.

Snide remarks against women in technology

2009-12-16T20:11:00-08:00

It’s this culture of attacking women that has especially got to stop. Whenever I post a video of a female technologist there invariably are snide remarks about body parts and other things that simply wouldn’t happen if the interviewee were a man.

Blogger Robert Scoble, responding to threats against tech author Kathy Sierra

The Knuth-Morris-Pratt Algorithm in my own words

2009-12-13T20:00:00-08:00

For the past few days, I’ve been reading various explanations of the Knuth-Morris-Pratt string searching algorithms. For some reason, none of the explanations were doing it for me. I kept banging my head against a brick wall once I started reading “the prefix of the suffix of the prefix of the…”.

Finally, after reading the same paragraph of CLRS over and over for about 30 minutes, I decided to sit down, do a bunch of examples, and diagram them out. I now understand the algorithm, and can explain it. For those who think like me, here it is in my own words. As a side note, I’m not going to explain why it’s more efficient than na”ive string matching; that’s explained perfectly well in a multitude of places. I’m going to explain exactly how it works, as my brain understands it.

The Partial Match Table

The key to KMP, of course, is the partial match table. The main obstacle between me and understanding KMP was the fact that I didn’t quite fully grasp what the values in the partial match table really meant. I will now try to explain them in the simplest words possible.

Here’s the partial match table for the pattern “abababca”:

char:  | a | b | a | b | a | b | c | a |
index: | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 
value: | 0 | 0 | 1 | 2 | 3 | 4 | 0 | 1 |

If I have an eight-character pattern (let’s say “abababca” for the duration of this example), my partial match table will have eight cells. If I’m looking at the eighth and last cell in the table, I’m interested in the entire pattern (“abababca”). If I’m looking at the seventh cell in the table, I’m only interested in the first seven characters in the pattern (“abababc”); the eighth one (“a”) is irrelevant, and can go fall off a building or something. If I’m looking at the sixth cell of the in the table… you get the idea. Notice that I haven’t talked about what each cell means yet, but just what it’s referring to.

Now, in order to talk about the meaning, we need to know about proper prefixes and proper suffixes.

Proper prefix: All the characters in a string, with one or more cut off the end. “S”, “Sn”, “Sna”, and “Snap” are all the proper prefixes of “Snape”.

Proper suffix: All the characters in a string, with one or more cut off the beginning. “agrid”, “grid”, “rid”, “id”, and “d” are all proper suffixes of “Hagrid”.

With this in mind, I can now give the one-sentence meaning of the values in the partial match table:

The length of the longest proper prefix in the (sub)pattern that matches a proper suffix in the same (sub)pattern.

Let’s examine what I mean by that. Say we’re looking in the third cell. As you’ll remember from above, this means we’re only interested in the first three characters (“aba”). In “aba”, there are two proper prefixes (“a” and “ab”) and two proper suffixes (“a” and “ba”). The proper prefix “ab” does not match either of the two proper suffixes. However, the proper prefix “a” matches the proper suffix “a”. Thus, the length of the longest proper prefix that matches a proper suffix, in this case, is 1.

Let’s try it for cell four. Here, we’re interested in the first four characters (“abab”). We have three proper prefixes (“a”, “ab”, and “aba”) and three proper suffixes (“b”, “ab”, and “bab”). This time, “ab” is in both, and is two characters long, so cell four gets value 2.

Just because it’s an interesting example, let’s also try it for cell five, which concerns “ababa”. We have four proper prefixes (“a”, “ab”, “aba”, and “abab”) and four proper suffixes (“a”, “ba”, “aba”, and “baba”). Now, we have two matches: “a” and “aba” are both proper prefixes and proper suffixes. Since “aba” is longer than “a”, it wins, and cell five gets value 3.

Let’s skip ahead to cell seven (the second-to-last cell), which is concerned with the pattern “abababc”. Even without enumerating all the proper prefixes and suffixes, it should be obvious that there aren’t going to be any matches; all the suffixes will end with the letter “c”, and none of the prefixes will. Since there are no matches, cell seven gets 0.

Finally, let’s look at cell eight, which is concerned with the entire pattern (“abababca”). Since they both start and end with “a”, we know the value will be at least 1. However, that’s where it ends; at lengths two and up, all the suffixes contain a c, while only the last prefix (“abababc”) does. This seven-character prefix does not match the seven-character suffix (“bababca”), so cell eight gets 1.

How to use the Partial Match Table

We can use the values in the partial match table to skip ahead (rather than redoing unnecessary old comparisons) when we find partial matches. The formula works like this:

If a partial match of length partial_match_length is found and table[partial_match_length] > 1, we may skip ahead partial_match_length - table[partial_match_length - 1] characters.

Let’s say we’re matching the pattern “abababca” against the text “bacbababaabcbab”. Here’s our partial match table again for easy reference:

char:  | a | b | a | b | a | b | c | a |
index: | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 
value: | 0 | 0 | 1 | 2 | 3 | 4 | 0 | 1 |

The first time we get a partial match is here:

bacbababaabcbab
 |
 abababca

This is a partial_match_length of 1. The value at table[partial_match_length - 1] (or table[0]) is 0, so we don’t get to skip ahead any. The next partial match we get is here:

bacbababaabcbab
    |||||
    abababca

This is a partial_match_length of 5. The value at table[partial_match_length - 1] (or table[4]) is 3. That means we get to skip ahead partial_match_length - table[partial_match_length - 1] (or 5 - table[4] or 5 - 3 or 2) characters:

// x denotes a skip

bacbababaabcbab
    xx|||
      abababca

This is a partial_match_length of 3. The value at table[partial_match_length - 1] (or table[2]) is 1. That means we get to skip ahead partial_match_length - table[partial_match_length - 1] (or 3 - table[2] or 3 - 1 or 2) characters:

// x denotes a skip

bacbababaabcbab
      xx|
        abababca

At this point, our pattern is longer than the remaining characters in the text, so we know there’s no match.

Conclusion

So there you have it. Like I promised before, it’s no exhaustive explanation or formal proof of KMP; it’s a walk through my brain, with the parts I found confusing spelled out in extreme detail. If you have any questions or notice something I messed up, please leave a comment; maybe we’ll all learn something.

A method with no unit tests is a broken method

2009-11-17T20:00:00-08:00

If you write software, you need to write unit tests. If you’ve written a method/function, and you haven’t written a unit test for it, it’s safe to assume that it’s broken (even if it compiles and your other tests pass).

I’m not necessarily advocating full-fledged test-driven development. I’m just saying, if you release code into “the wild,” and there are methods you haven’t unit tested, your customers will almost certainly run into multiple bugs in each one of them.

That’s an atomic point. Separate from that, I’d like to mention that this isn’t always a bad thing. For a startup that wants to iterate as quickly as possible (and is writing non-life-critical software), writing the code with no unit tests, releasing it, and reproducing each customer-discovered bug with a unit test before fixing it is a totally reasonable model. These startups just shouldn’t operate under the illusion that their software “works”. In the hours after they make one of these releases, they should feel blessed if a single customer is able to register or log in.

Convert an int array to a comma-separated string with C

2009-11-16T19:55:00-08:00

I’m much less experienced in C than I am in higher-level languages. At Cisco, we use C, and I sometimes run into something that would be easy to do in Java or Python, but very difficult to do in C. Now is one of those times.

I have a dynamically-allocated array of unsigned integers which I need to convert to a comma-separated string for logging. While the integers are not likely to be very large, they could conceptually be anywhere from 0 to 4,294,967,295. In Python, that’s one short line.

my_str = ','.join([str(num) for num in my_list])

How elegantly can people do this in C? I came up with a way, but it’s gross. If anyone knows a nice way to do it, please enlighten me.