philcrissman.com

Fun With The Major Scale

2010-08-11T00:00:00-07:00

Got to chatting with Nate (@fowlduck) about musical notation last night. He was pointing out that bits of the notation seem arbitrary and probably archaic, likening it to legacy code of a sort. For example, why no whole tone between B and C, E and F? This post is NOT meant to be a defense of music notation, a “setting straight” of anything, or even a definitive description of musical theory (at which I’m a rank amateur). It just got me thinking about the major scale and the circle of fourths & fifths, which led to some playing around on the command line, which led to this. Enjoy.

The thing that makes it seem so strange is, at least in part, the major scale. The octave consists of twelve semi-tones, in which the major scale is set in this pattern: whole tone, whole tone, semitone, whole tone, whole tone, whole tone, whole tone, semi-tone. Like so:

  1   2   3   4   5   6   7   8   9   10  11  12  13
| C |   | D |   | E | F |   | G |   | A |   | B | C | ... (etc)

The next root note (13th semi-tone, above) is only a semi-tone off from the last note of the scale. And so on. The semi-tone before or after any given note is a flat or a sharp respectively, giving rise to the B# == C, Cb == B, E# == F, Fb == E identities. So, let’s just accept the scale as a given; that this pattern of whole tones and semi-tones sounds pleasing to the ear.

So why is it C that has all natural notes (no sharps or flats)? Good question. That part, to me at least, does seem arbitrary, but effectively it doesn’t matter. Given the above system, the major scale in one key and one key only will have no sharps or flats. But still, why structure the notes this way? It still doesn’t necessarily seem to make sense.

There are a few reasons. For one, we want to be able to express every scale by naming off the notes, and we’d like each note to be a different letter. So we need 7 letters.

Where it gets really interesting is the circle of fourths and fifths.

So, if you go around clockwise, you’re counting by fifths (G is the fifth note of the C major scale, D is the fifth note of the G major scale, etc) and if you go around counter-clockwise you’re counting by fourths (F is the fourth note of C, Bb is the fourth note of F, etc). If you go around clockwise, each scale has one additional sharped note until you get to 180 degrees around, then it has n-1 flat notes, and loses one flat each fifth till you get back to C (no sharps or flats); vis versa the other direction. This is actually really cool; each scale, in addition to being unique in that, well, it has a different root note, is unique in that it is the only scale to have its specific number of sharps or flats. If a scale has 3 sharps, it’s A. Period. There isn’t another choice. Neat!

So for fun, we can explore the circle of fifths in the command line. First lets set it up:


> circle = (0..11).map{|n| n*7%12 }
 => [0, 7, 2, 9, 4, 11, 6, 1, 8, 3, 10, 5]

Well. That doesn’t mean a whole lot. How can we map it to notes? Let’s just construct a reference array really quick. (I’m making it an instance variable so I can use it in a method later; this was all done in irb.)


> @notes = ["C", "C#/Db", "D", "D#/Eb", "E", "E#/F", "F#/Gb", "G", "G#/Ab", "A", "A#/Bb", "B/Cb"]
 => ["C", "C#/Db", "D", "D#/Eb", "E", "E#/F", "F#/Gb", "G", "G#/Ab", "A", "A#/Bb", "B/Cb"]

So, to read our circle, we’d do:


> circle.map{|n| @notes[n]}
 => ["C", "G", "D", "A", "E", "B/Cb", "F#/Gb", "C#/Db", "G#/Ab", "D#/Eb", "A#/Bb", "E#/F"]

Hooray. The circle of fifths. Now, so what? Well, let’s make a little method to construct a major scale from the @notes variable. We’ll take a root note as an argument, so we can construct any major scale we like.


> def major(root=0)
?>  offset = (0..11).map{|n| @notes[(n+root)%12]}
?>  [offset[0], offset[2], offset[4], offset[5], offset[7], offset[9], offset[11]].join(" ")
?>  end
 => nil

So, just calling major with no arguments should give us the C major scale; calling with, say, 5 should give us F major (5 in this case is the index of F in @notes; but you were already following that, I know):


> major
 => "C D E E#/F G A B/Cb" 
> major(5)
 => "E#/F G A A#/Bb C D E"

So we said that the circle of fifths added a sharp each increment, and then flipped to flats and removed on each increment. Let’s watch it happen:


>> circle.each{|n| puts major(n) }
C D E F G A B
G A B C D E F#/Gb
D E F#/Gb G A B C#/Db
A B C#/Db D E F#/Gb G#/Ab
E F#/Gb G#/Ab A B C#/Db D#/Eb
B C#/Db D#/Eb E F#/Gb G#/Ab A#/Bb
F#/Gb G#/Ab A#/Bb B C#/Db D#/Eb F
C#/Db D#/Eb F F#/Gb G#/Ab A#/Bb C
G#/Ab A#/Bb C C#/Db D#/Eb F G
D#/Eb F G G#/Ab A#/Bb C D
A#/Bb C D D#/Eb F G A
F G A A#/Bb C D E

Not as neat as it could look since I put the #/b both in the original notes array; the note you’d read would be the one with a consecutive letter after the previous note. So in G, the note following E is F#. In Eb, the note following G is Ab… and so on. The same note letter only appears once in any given scale. A sharp or flat is added or removed each increment you go around the circle.

I don’t have any startling conclusions to close this off with. Just that music is pretty cool, and that a few of the things that seem arbitrary just have to be that way — assuming we’re going to base the system around 12 equally tempered semitones (see Equal Temperment, or even Bach’s Well-Tempered Clavier (evidently there’s some dispute over whether or not Bach’s intended tuning was equal or, uh, “well” tempered; I was not aware of this!)) and a 7 note major scale — neither of which are absolutely necessary, of course, and there are other ways to do it. See Mathematics of musical scales and tuning systems for more.

Happy musicking.

Push it somewhere else

2010-08-06T00:00:00-07:00

For all the folks in #rubyonrails, and beyond.

graffiti on a train

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

Pic taken along the trail on the way from Minneapolis to Hopkins.

There Will Be No Newsletter

2010-08-03T00:00:00-07:00

So, a few weeks ago I saw letter.ly and I thought, hey, there’s an idea, so I created an account and thought to myself, what could I send out a newsletter about? I know, how about time management? I have to manage my own time, I get stuff done. That’s useful, right? And so I wrote a couple posts, debated on actually getting started. Yesterday I went ahead and pulled the trigger, send out the first one and also publicized it on twitter (to no real response, which is more or less as I expected).

I started to reconsider almost right away. While I like writing, I’m not certain I want to make a job of it. And while I like time management, and I think I’m decent at it, it doesn’t really drive me to fits of enthusiasm as a topic. I’d probably be better off taking my top few time management ideas and making blog posts out of them than I would attempting to come up with something new every single week.

The for-profit newsletter does seem like a good idea, but I think I’m going to stick with one channel of writing, for now. The blog has a couple ads on it, which I don’t apologize for (nor do I really care if you block ads; your prerogative), so I guess if whatever I write gets immense attention (not likely, but it’s happened a few times), some reward will trickle back.

Now, an e-book of some sort does seem like a better idea, and I have several ideas (one of which might well have to do with time management) that I might try to eventually work on in that direction. But a newsletter; I don’t really think I want to pour my efforts into that, right now. I think they’re better placed elsewhere.

So if you saw yesterday’s tweet about the experiment, and followed the link over to letter.ly, yeah. That’s the backstory, and that’s why if you look for it now, you’ll see it has a message saying it’s ceased. (UX note: could not find a way to actually delete a newsletter. Seems like that would be a handy function.)

RVM

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

I gave a short presentation on RVM on Monday at RUM.

The slides can be found at rubymn-rvm.heroku.com.

Enjoy!

Faith

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

I know, I know, the faux motivational poster is an old and tired meme. Sorry.

I Write Like

2010-07-27T00:00:00-07:00

I’ve seen the I write like links show up on facebook and twitter a few times, so I decided I’d take a look. Not content to simply feed it one sample, I fed it the text from several of the posts from the archive. Here were the results:

I Hold Strong Opinions About The Placement Of Curly Braces
=> I write like: H.P. Lovecraft. Really? Wait… what?
No, We’re Not The Stupid Ones
In Which I Am No Longer A Very Good Bachelor
Oracle To Acquire Oracle
=> I write like: Cory Doctorow. Huh. You think? Well, okay. Thanks!
The Emperor’s New Web
=> I write like: Jonathan Swift. [blushing] No, no… you’re too kind.

Not sure how they are analyzing the text and reaching their conclusions, but there’s at least a little bit of smarts in there; that last one, the one which was compared to Swift, is indeed a satire, though I’m not going to claim it’s in the calibre of Swift’s satire, but still; their algorithm picked something out of it which prompted the comparison. Not bad.

So, evidently, according to their analyses, I write most often like Cory Doctorow. I’ve only read Down And Out In The Magic Kingdom, and several of his blog posts/essays, but enough to consider it a compliment, though I’m not certain it’s deserved. Regardless, there we have it.

How Not To Write Sorting Algorithms in Ruby

2010-07-18T00:00:00-07:00

The second chapter of Introduction To Algorithms by Cormen, Leiserson, et al., describes the algorithms for Insertion Sort and Merge Sort in pseudocode, and compares their relative efficiency (or lack thereof). I decided to write them out in Ruby and run some simple benchmarks, just for fun.

Insertion Sort

There are a variety of ways one could write the insertion sort in Ruby; this is more or less an literal translation of the Intro to Algorithms pseudocode to ruby — it could perhaps be made a little more ruby-ish, but here’s my version:


def insertion_sort(sequence)
  sequence[1..sequence.size].each_with_index do |j, index|
    i = index
    sequence[0..i].reverse.each do |k|
      break unless k > j
      sequence[i + 1] = k
      i = i - 1
    end
    sequence[i+1] = j
  end
end

In a nutshell:

Start with the second element (index 1).
Save the index in a local variable, because we’re going to use it to figure out which array element to swap the current element into.
Take the sub-array 0..i (where i is the current index being looked at), and go backwards until the element in your inner loop is less than the current element from the outer loop, also decrementing i each iteration.
Copy the element in index [i] to index [i + 1]
Outside the inner loop, we’ll put the current element at [i + 1].

In case this is a little unclear, it would go something like this:

Starting array: [5,2,3,1,4,0]

First pass: [2,5,3,1,4,0]

Second pass: [2,3,5,1,4,0]

Third pass: [1,2,3,5,4,0]

Fourth pass: [1,2,3,4,5,0]

Fifth pass: [0,1,2,3,4,5]

(Bold elements are the ones which were the “current” element moved back, italic elements are the ones that had to be shifted forward in this step.)

Merge Sort

The merge sort is split into two parts; a merge method that acts as a helper, and the actual merge_sort which calls itself recursively, also calling merge when needed.

Here’s a version modeled after the pseudocode in Intro to Algorithms:


def merge_sort(sequence, first, last)
  if first < last
    mid = (first + last) / 2
    merge_sort(sequence, first, mid)
    merge_sort(sequence, mid + 1, last)
    merge(sequence, first, mid + 1, last)
  end
end

def merge(sequence, first, mid, last)
  left = sequence[first..mid - 1]
  right = sequence[mid..last]
  left.push(Float::MAX)
  right.push(Float::MAX)
  i = 0
  j = 0
  (first..last).each do |n|
    if left[i] <= right[j]
      sequence[n] = left[i]
      i = i + 1
    else
      sequence[n] = right[j]
      j = j + 1
    end
  end
end

A few notes: You’ll notice that in the merge method, when the sequence is split into two parts, the value Float::MAX is pushed onto each as the final element. Intro to Algorithms uses the idea that “infinity” is set to the last element. Hopefully I can explain why in the description of the algorithm.

First, the merge method. The merge method assumes that the left half and the right half of the section of the array it’s looking at are already sorted. Having made this assumption, it loops through the range it’s considering (first..last), and puts either the first element of the left side, or the first element of the right side, whichever it least. It increments each subarray as it goes; when it gets past the last element of either array, Float::MAX will always be higher (or so we assume, for the sake of this implementation) than whatever is in the other array. So merge finishes up, basically (ahem) merging the two halves together in place, with the whole first..last range sorted.

Now, the actual merge_sort method. It first checks to see if first < last; if this were false, then the range would be an array of size 1, and an array of size 1 is already sorted. So assuming the range first..last is > 1, it calculates a midpoint; integer division works fine for this, using (first + last) / 2. Then it calls itself recursively on each subarray; these in turn will continue splitting each subarray into two parts until it gets to the point where it’s just two subarrays of one element each; which are then fed to merge and sorted. As the method returns from each level of recursion, each “half” of the subarray under consideration has been sorted, until it gets all the way back to the first call to merge_sort, and executes merge on each (sorted) half of the full array.

Phew. I’m going to attempt to show another example, in case that’s helpful. Let’s say we started with the same starting array as the insertion_sort example. This time, to show what the recursion is actually doing, I’ll write out what each nested call to merge_sort( and/or merge) would actually look like:

Starting array: [5,2,3,1,4,0]

merge_sort([5,2,3,1,4,0], 0, 5):
  mid <- 2
  merge_sort([5,2,3], 0, 2):
    mid <- 1
    merge_sort([5,2], 0, 1):
      mid <- 0
      merge_sort([5], 0, 0):
      merge_sort([2], 1, 1):
      merge([5,2],0, 1, 1):
        left <- [5,∞]
        right <- [2,∞]
        loop(0..1):
          [2,5] # just showing the result in this step; the two elements are sorted.
    merge_sort([3], 2, 2):
    merge([2,5,3], 0, 2, 2):
      left <- [2,5,∞]
      right <- [3,∞]
      loop(0..2):
        [2,3,5]
  merge_sort([1,4,0], 3, 5):
    mid <- 4
    merge_sort([1,4], 3, 4):
      mid <- 3
      merge_sort([1], 3, 3):
      merge_sort([4], 4, 4):
      merge([1,4], 3, 4, 4):
        left <- [1,∞]
        right <- [4,∞]
        loop(3..4):
          [1,4]
    merge_sort([0], 5, 5):
    merge([1,4,0], 3, 5, 5):
      left <- [1,4,∞]
      right <- [0,∞]
      loop(3..5):
        [0,1,4]
  merge([2,3,5,0,1,4], 0, 3, 5):
    left <- [2,3,5,∞]
    right <- [0,1,4,∞]
    loop(0..5):
      [0,1,2,3,4,5]

Uhm, hopefully that’s clear. If you’re bothering to read this and it still isn’t clear, just run the sort locally and add some print or puts statements liberally so you can see what’s going on. Note: I did take a liberty in the above listing of what’s happening; in actuality the entire array is passed each time; I made it look as though just the subarray were being passed in each case, because that is the only part that is being looked at in each nested section. Again, if you’re interested enough in the topic that you’re still working out this algorithm, fire up irb and just try it out, it will make more sense as you do so.

Wait, why is this called "how not to write sorting algorithms...?"

Aha. I thought you’d never ask. Well, the main reason is that both of these methods are significantly slower than good old Array::sort, which is built in to Ruby (and which, as far as I know, is implemented using the quicksort algorithm).

So, just for fun, I wrote a little script to make some benchmarks of these various methods on arrays of various sizes. Here were the results:

      user     system      total        real

 small_array has 100 elements in it...
Insertion Sort (small_array): 
  0.000000   0.000000   0.000000 (  0.002122)
Merge sort (small_array): 
  0.000000   0.000000   0.000000 (  0.001499)
Ruby Array::sort (small_array): 
  0.000000   0.000000   0.000000 (  0.000016)

 bigger_array has 1000 elements in it...
Insertion sort (bigger_array): 
  0.240000   0.000000   0.240000 (  0.238994)
Merge sort (bigger array): 
  0.030000   0.010000   0.040000 (  0.027746)
Ruby Array::sort (bigger_array): 
  0.000000   0.000000   0.000000 (  0.000161)

 medium_array has 10,000 elements in it...
Insertion sort (medium_array): 
 23.960000   0.010000  23.970000 ( 24.096455)
Merge sort (medium_array): 
  0.720000   0.020000   0.740000 (  0.726312)
Ruby Array::sort (medium_array): 
  0.000000   0.000000   0.000000 (  0.001637)

 huge_array has 100,000 elements in it...
Sorry, the insertion_sort was taking too long! Skipped it.
Merge sort (huge_array): 
 61.710000  11.990000  73.700000 ( 74.332743)
ruby Array::sort (huge_array): 
  0.020000   0.000000   0.020000 (  0.020800)

The interesting column is the last one: real, as in “real time” (more or less, taking into the account that we’re just benchmarking).

The small array is pretty fast for all three methods, but even still, we can see that merge_sort is a little faster, and the built in .sort! (using quicksort) is way faster: only 0.000016 seconds.

The next bigger, bigger_array, the differences stand out a little more. Insertion takes 0.24 seconds, merge takes 0.028, and sort! (again), way faster, only 0.00016 seconds.

A ten thousand element array starts to show the difference even more dramatically: insertion_sort now takes 24.1 seconds, close to half a minute, while the merge_sort still runs in under a second. sort!, once again, is blowing them away at only 0.0016 seconds.

Finally, a hundred thousand element array; sorry for the lack of stats, but I was too impatient to let insertion_sort finish. Let’s just say it would take awhile. Now even the merge_sort shows its limits, taking over a minute, about 74.3 seconds. And finally, good old sort! clocking in at only 0.02 seconds.

So the reason this is how not to write sorting algorithms in ruby is simply that, you really probably don’t need to, unless you need something faster than a quicksort written in C. The reason, hopefully, to be playing around writing algorithms in Ruby or in whatever your favorite language happens to be, is just to understand them better.

And it’s fun.

Relative Primes, Revisited

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

As I thought; there’s always a better way to do it. @jmchilton, who was a TA when I took Structure of Computer Programming I (or whatever it was called; the Scheme class) at the U of M, supplied this alternative solution to the relative prime problem:


def gcd(a, b); b == 0 ? a : gcd(b, a % b); end; def rp(a, b); gcd(a, b) == 1; end

Or, indented:


def gcd(a, b)
  b == 0 ? a : gcd(b, a % b)
end

def rp(a, b)
  gcd(a, b) == 1
end

In other words, it pays to know your math. gcd is a recursive function, basically Euclid’s algorithm for finding the greatest common denominator. rp, then, simply returns true if the GCD of a and b is 1; otherwise false.

Very nice. I wish I’d thought to do it that way, but I’ll certainly remember it.

Relative Primes

2010-07-07T00:00:00-07:00

I didn’t expect to do a “code kata”-type post again so quickly, but here it is anyways.

I was reading Randall Hyde’s excellent Writing Great Code: Volume 1 and came across the concept of relative primes.

If you haven’t heard the term in awhile, relative primes are simply two numbers that are not both evenly divisible by the same value (not counting 1, of course).

Writing some code to determine if two integers are relatively prime seemed interesting, so I gave it a first shot:


# relprime01.rb

def rel_prime(a, b)  
  # if either number is one, they are automatically relatively prime.
  return true if (a == 1 || b == 1)
  
  # determine a's factors.
  fa = factors(a)
  # determine b's factors.
  fb = factors(b)
  
  # are any factors the same? then false
  # if no factors are shared, then true.
  # ie, if the intersect is empty, true, else false.
  (fa & fb).empty?
  
end

def factors(a)
  return a if a == 1
  (2..a).map{|k| k if a%k==0 }.compact
end

So, open up irb, require ‘rel_prime01.rb’, and you have a method for determining if 2 integers are relatively prime. It has some issues, and would not be very efficient for large values. Before addressing that, I thought I’d just go straight to monkeypatching Integer again.

Note: there’s another problem with the above method, too. See it? See below the next listing for what it is.


# rel_prime02.rb

class Integer

  # usage: x.rel_prime?(y)
  # returns true if x and y are relatively prime.
  def rel_prime?(n)
    return true if (self.abs == 1 || n.abs == 1)
    
    # All number pairs have 1 as a shared factor; it doesn't count. So we subtract it from the array before checking [ ].empty?
    ((self.factors & n.factors) - [1]).empty?
  end

  # usage: x.factors
  # returns an array of the factors of x
  def factors
    (1..self.abs).map{|k| k if self.abs%k==0 }.compact
  end
end

Essentially the same algorithm; if either integer is 1, then the numbers are automatically relative primes; 1 has no factors other than itself, so the only factor they share is 1. If both numbers are not 1, it gets the full list of factors of both numbers, checks to see if they have any in common, returns false if they do, and true if they don’t.

The problem fixed in the second code is the use of Integer::abs in the appropriate places; that first code listing would blow up if you supplied a negative integer. Negative integers should be allowed, so this code uses .abs to make everything work properly, as it should.

There’s still a big problem for checking large numbers. Each time we check relative primes, we’re getting ALL the factors of each integer, and then comparing them when we’re done. That could take a really long time, and the code above iterates though every single value from 1..x for each x we give it… even if that number turns out to be (gasp!) prime. This won’t do at all. It will give us correct answers, but it will take a really long time to do it if we supply large values.

How could we improve it? Well, one way would be to check common factors as we go. That way, if both numbers are even, we find out they share a factor on the very first iteration, and we simply stop: they are not relatively prime. Here’s this one:


# rel_prime03.rb

class Integer

  # usage: x.rel_prime?(y)
  # returns true if x and y are relatively prime.
  def rel_prime?(n)
    return true if (self.abs == 1 || n.abs == 1)
    
    # different approach; go through (1..min(self,n).abs), 
    # build an array for each number's factors as we go.
    # each time you add a factor, check if the two arrays share it.
    # if they do, end right away with false; 
    # else, keep searching for common factors.
    x,y =[],[]
    
    
    (2..[self,n].sort[0].abs).each do |k|
      x << k if self % k  == 0
      y << k if n % k     == 0
      return false unless (x & y).empty?
    end
    
    # if you get here, it's because you found no common factors. return true.
    true
  end

end

So, this time we make 2 empty arrays, x and y. Each time we find a factor of self or n we add it to either x or y and then check if the intersection of those two arrays (using &) is empty; if it’s ever not empty, return false right away and stop checking. If we get all the way to the end without finding a common factor, we can return true.

This is better; works great for large numbers IFF the common factor is a fairly low number. But what if it isn’t? What if the common factor is a 7 digit long prime number?

We know that there will be cases … large primes, for example … where we do basically need to check all the way up till we reach the last value that could be possible (the lesser of self and n, whichever that happens to be). But there’s a lot of number in-between that we don’t need to check. For example, if 2 is not a common factor, then we never need to check multiples of 2 again. If 3 is not a common factor, we never need to check multiples of 3 again. And so on. So really, if x is the lesser of self and n, the range we need to check will look something like:

[2,3,5,7,11,13 … x]

Hm. That list looks familiar. Basically, we only need to check to see if prime numbers are factors of self and n; if a given prime number is not a factor, neither will any of its multiples be a factor.

Generating a list of primes wasn’t on the to-do list, but fortunately ruby has a class in mathn called Prime, which returns an enumerator for iterating over the prime numbers. How convenient!


# rel_prime04.rb
require 'mathn'

class Integer

  # usage: x.rel_prime?(y)
  # returns true if x and y are relatively prime.
  def rel_prime?(n)
    return true if (self.abs == 1 || n.abs == 1)
    
    # one more quick check; does self % n == 0?
    # if it does, we save some time; we know right away they aren't relatively prime,
    # and we don't need to iterate all the way up before we find out.
    return true if self % n == 0
    
    x,y =[],[]
    
    # Prime.instance gives us an enumerator over the Prime numbers.
    # Enumerating over only primes saves us the wasted effort 
    # of rechecking multiples of factors we've already ruled out.
    # etc.
    p = Prime.instance
    
    p.each do |k|
      x << k if self % k  == 0
      y << k if n % k     == 0
      return false unless (x & y).empty?
      break if k >= [self,n].sort[0].abs
    end
    
    # if you get here, it's because you found no common factors. return true.
    true
  end
end

Now, the above code uses Prime::instance to create the enumerator, which is a ruby 1.9 thing; you can do this in ruby 1.8.x, but you’ll need Prime.new instead of Prime.instance. Warning, though, I found that the Prime enumerator in 1.8.x was still pretty slow for larger integers. The 1.9 version is very fast. For easy ways to get ruby 1.9.x installed without messing too much with your existing environment, check out rvm.

So now we’re doing essentially the same as the rel_prime03.rb version, but we’re skipping the multiples of any factors we’ve already ruled out by only iterating through the prime numbers. In the loop, you’ll see we stop if k >= [self,n].sort[0], which is the lesser of self and n (I felt like there might be a more elegant way to quickly find the lesser of two integers, but I didn’t look; anyone?).

One more thing was added, here: right at the beginning, after checking if self or n (abs) is equal to 1, we also check if self % n == 0. If it does, we just saved some time; see the comments in the listing above.

That’s that, then. A method added to Integer that checks if two integers are relatively prime.

Is there a better way to do it? I’m fairly certain there is (there usually is), so if you know of one, feel free to leave a note or a link in the comments.

various fizzbuzzes

2010-07-06T00:00:00-07:00

Every so often I remember reading posts like Why can’t programmers… program?, or Are you one of the 10% of programmers who can implement a binary search?, or even various things about the idea of code kata, and that makes me want to just spend a little time practicing, rather than just working. Very often while working, we’re resolving a problem we (and/or others) have solve dozens of times before, and it’s really not very challenging or stretching.

Since I was thinking about it, I decided to just start with the FizzBuzz example, from Reginald Braithwaite via Jeff Atwood.

First solution:


(1..100).each do |k|
  print k % 3 == 0 ? "Fizz" : ""
  print k % 5 == 0 ? "Buzz" : ""
  print k unless (k % 3 == 0 || k % 5 == 0)
  print " "
end

So, that’s simple enough. I thought maybe it could be a little more compact, but essentially unchanged, here was the next version:


(1..100).each do |k|
  print k%3==0 ? "Fizz" : "", k%5==0 ? "Buzz" : "", (k%3==0 || k%5==0) ? "" : k,  " "
end

That’s nice and all, but I’m now trying to think if I can find other ways to do it. Preferably shorter and/or more elegant. Maybe. 003.rb was next.


(1..100).each do |k|
  word = ''
  word << "Fizz" if k%3==0
  word << "Buzz" if k%5==0
  print word.empty? ? k : word, " "
end

Not really shorter or elegant, but a slightly different approach, filling a placeholder variable with “Fizz”, “Buzz” (or both), and then deciding which one to display based on whether or not the placeholder was empty? (If you aren’t familiar with Ruby, “”.empty? == true && “anything”.empty? == false.)

Again, I tried to pare that down a little.


puts (1..100).map {|k| w='';w<<"Fizz"if k%3==0;w<<"Buzz"if k%5==0;w.empty? ? k : w }.join(" ")

Well, I don’t know if it’s readable, or anything resembling elegant, but it’s, um… more compact.

At that point I glanced back at my first solution, and something was bugging me about it; oh, yeah. The ternary expressions that returned “” for the false case. That seemed unnecessary. 005.rb tries to fix it.


(1..100).each do |k|
  print "Fizz" if k % 3 == 0
  print "Buzz" if k % 5 == 0
  print k unless (k % 3 == 0 || k % 5 == 0)
  print " "
end

Essentially unchanged. I’m not even sure it’s any more efficient but it feels less like there’s wasted code in there, so I like it a little better. Now, it’s not really changing much, but what if we extract the logic into it’s own method?


def fizzbuzz(k)
  w = ''
  w << "Fizz" if k%3==0
  w << "Buzz" if k%5==0
  w.empty? ? k : w
end

(1..100).each {|k| print fizzbuzz(k), " " }

Hey, that’s… well, it’s essentially the same, but the lesser rites of refactoring have been appeased by pulling that code into it’s own little method.

Hey. That makes me think we could just:


class Integer
  def fizzbuzz
    w=''<<(self%3==0 ? "Fizz" : "")<<(self%5==0 ? "Buzz" : "")
    w.empty? ? self : w
  end
end

puts (1..100).map{|k| k.fizzbuzz }.join(" ")

So, a couple different things here. We open up Integer and add a fizzbuzz method to it. The idea of a place holder with either “Fizz”, “Buzz”, or both added to it is streamlined slightly by adding the concatenation lines right into the variable assignment. To make that work, we have to go back to using the ternary operator (can you see why? If we just did w << “Fizz” if k%3==0, it would try to append nil to the String, and you’d get a horrible “Unable to convert nil to String” error anytime a non-multiple of 3 or 5 came up).

So, that’s that. I know this is simple, maybe trivial, but hey, who wants to be the guy who couldn’t program a FizzBuzz solution in the interview?

This was a fun exercise, so I’ll probably try to do some more like it. I’ll likely start by mining Code Kata, implementing some algorithms, or something. Feel free to leave problem suggestions in the comments.

Thanks!

Introducing henry, a theme for Toto

2010-06-28T00:00:00-07:00

As a response to no demand whatsoever, I nevertheless extracted my theme for this blog into it’s own standalone theme for toto that you could use just like dorothy

Keeping with the Oz names, I called it henry.

Installation is pretty much identical as you would to for toto and dorothy:


gem install toto
git clone git://github.com/philcrissman/henry.git myblog
cd myblog
heroku create myblog
git push heroku master

Now, I pretty much completely disregarded IE support when I designed the blog, so as a result I don’t think henry will look like anything much in IE. You’re on your own. I will probably eventually feel like I should update this or address it somehow, but I’m not making any guarantees as to when that would be.

Rails Links 001

2010-06-25T00:00:00-07:00

As an experiment, I’m going to start making a link-post every so often. Maybe weekly? We’ll see.

Eric Davis provides a big list of Capistrano variables (via larkgroup)
Fabio Akita took the opportunity to interview a bunch of folks at RailsConf (via RubyInside)
You still have time to take Hampton Catlin’s 2010 Ruby Survey
Some thoughts on the new Ruby ecosystem from Paolo Perrotta (via coder.io)

Also, feedback appreciated. Is this sort of post useful, informative, handy? Or overdone, redundant, irrelevant? Somewhere in between?

It's unanimous

2010-06-23T00:00:00-07:00

WhinyRendering

2010-06-18T00:00:00-07:00

Quite often I’ll come into a Rails project with a good portion of the code already written. Depending on style the developers were using, this sometimes means that I may not be able to easily tell, when looking at a given view, how the view is being generated. The URL may say /pages/1, but for all I know, the routes file has instructions to use the ArmpitsController when it sees a route for pages/*; the URL might say /user/login, but for all we know, that may map to SessionController::sign_in. In other words, it’s not always clear.

And that’s not even getting into the cases where there are multiple partials being used, some of which might be in app/views/shared, or who knows where.

We’ve talked in the office a few times about a mythical plugin that could provide a little output stating exactly what controller, action, and template are being rendered, as well as any and all partials. Thus the idea for WhinyRendering was born.

If any of the preceding scenario sounds familiar, I hope it’s helpful.

WhinyRendering

All Your Webs

2010-06-17T00:00:00-07:00

Taptaptap made an extension that adds comments to Daring Fireball, and, as you can see in the comments, sparked a little debate on whether or not this was A Good Thing.

It’s fine. I mean, I don’t really care if I can comment on DF or not, but if someone wants to, and if people use this and like it, great. It’s the web. You can’t control how people view your page. They could view it on any browser, with any extension, greasemonkey script, or other shenanigans inbetween, and there is absolutely nothing you or I can do about it.

They can block your ads. And that’s fine, because it’s their computer, and they can do that if they want to. Period.

They can implement their own stylesheets for your site (yes! they can!) and they will never again see the letter-spacing and line-height choices you painstakingly tested and implemented the last time you redesigned your blog. They can view your articles through Readability or something like it.

It just is. That’s just how the web is set up to work. And it’s a good thing. It doesn’t matter.

see more Lolcats and funny pictures

You Should Really Consider Parking Somewhere Else

2010-06-07T00:00:00-07:00

Design Is a Wicked Problem

2010-06-01T00:00:00-07:00

[Wittel and Webber] defined a "wicked" problem as one that could be clearly defined only by solving it...

... One of the main differences between programs you develop in school and those you develop as a professional is that the design problems solved by school programs are rarely, if ever, wicked. ... You'd probably want to tar and feather a teacher who gave you a programming assignment, then changed the assignment as soon as you finished the design, and then changed it again just as you were about to turn in the completed program. But that very process is an everyday reality in professional programming.

— Steve McConnell, Code Complete: A Practical Handbook of Software Construction

Roll Your Own Computer Science Masters Program

2010-05-01T00:00:00-07:00

Struck by some sort of errant whim to get more edumacated, I started googling Computer Science Master’s Degree programs today. Actually, I did one google search and then jumped straight to the University of St. Thomas page on graduate programs in software. Did a little back of the envelope thinking, noted that St. Thomas wants $762.50 per credit, and decided against a Masters degree at this point in time.

But it did get me thinking. Why would I want a Masters Degree, anyways? All the reasons I could think of boiled down to these two:

I want to go into a role, career, or position that requires a Masters Degree.
I want to go into a role, career, or position that requires the knowledge presumably attained from a Masters Degree.

This is a pretty important distinction. Some roles might simply have a Masters as a requirement. Doesn’t actually mean they care if you know anything. Yes, of course, they assume that you do, and that your Masters actually means something, but really, for this type of thing, all that’s important is the piece of paper.

And the truth is, I’m not really interested in any of those roles. Off the top of my head, all I could come up with in that category would be roles in a Fortune 500 or similarly credential-obsessed enterprise, or a role at a University, neither of which is something I want to pursue.

On the other hand, maybe I just want to know the information I might learn in a Masters program. Or maybe I have my sights on a career that really requires the knowledge, but doesn’t necessarily care if I have the piece of paper or not. That sort of role might include (again, off the top of my head), the technical founder or lead in a startup, a writer or speaker about tech topics, or simply a kick-ass software developer who knows more this year than he did last year. Now those sorts of things are interesting.

All of which means it doesn’t really matter if I go to a University.

Continuing on with this line of thought, I started mulling over the knowledge I’ve accumulated so far. How much would I attribute to college education, and how much did I teach myself? It’s a little hard to quantify, because there’s a lot of overlap, but even allowing some margin of error, the topics which I’ve taught myself have been far more useful/valuable than those I learned in my undergraduate degree (which was in Computer Science).

More importantly, and maybe more telling, I have a far better grasp on the things that I’ve taught myself than I do on many of the things I “had” to learn in college. I know Ruby and Rails far better than I know Java, and I’ve had at least four or five college courses dedicated to Java (most of which, even the 4th year course in Operating Systems, assumed we didn’t know anything about Java or OOP and re-taught it all over again).

I’m going to make a suggestion as to why this might be. I’m going to suggest that when we’re teaching something to ourselves, we hold ourselves to a higher standard than the average college course holds us.

In an average college class, all that really matters is:

Attendance (as crazy as it sounds, evidently they actually still care if you attend class, for reasons unfathomable to me).
Making an average effort to skim the material.
Making an average effort to complete assignments (often can combine with #2, as usually the only material you ever need to read is whatever is pertinent to the assignment).
Remembering just enough information for just long enough to have an adequate number of correct answers on your exams.

(Aside: the possible exception to this is Calculus and other advanced math classes, unless you are one of those people who absorb that with a minimum of effort; you either understand Calculus (et. al.), or you don’t, you can’t really just push your way through those one. YMMV.)

When you’re teaching yourself, on the other hand:

While you are working at your own pace, chances are you actually want to use the information or ideas that you’re learning, so you don’t want it to take forever. You may or may not have a fixed deadline in mind, but regardless, you are motivated to make progress for it’s own sake, not simply to get to the end of a semester.
You can’t fake yourself out. You can’t tell yourself that you know something when you know you don’t. You won’t fool yourself into thinking that you understand lambdas, or ruby blocks, or closures, or monads, or red-black trees, or any data structure or algorithm, if you know that you don’t. So if it matters to you that you learn it, you just have to keep going back until you get it.
Again, you have some reason that you actually want to use this information. It’s not solely to check of a list (e.g., Okay, I have memorized a bunch of ideas about Design Patterns, check), but it’s because you want to do something with the knowledge once you have it (e.g., Okay, I’ve learned some design patterns. Am I using any of these in my software side projects? If I did use one, would it improve my application? Can I identify these patterns if I see them in the wild? Etc.)
Not only can you not fake yourself out, you probably underestimate yourself. When you’re teaching yourself, your often painfully aware of how much you still don’t know, how much you still have left to learn, and it frequently blinds you to how much you’ve actually learned so far. Why is this good? Well, eventually you do need to recognize your progress and give yourself a pat or two on the back, but in general I think it’s good because it means you’ll push yourself harder to learn more. A good way to gauge your progress is to join a forum, a StackOverflow-type site, or an IRC chat room in the area you’re studying, and look at the questions people are asking. Chances are you’re going to find that a lot of people are asking questions that you (gasp) already know the answers to (now would be a nice time to help them, if you have time). That’s a good sign.

Now, self-discipline, which I didn’t mention, may or may not be an issue. An oft-mentioned advantage of college or course-work in general is that it pushes you to learn faster because of the built in deadlines, exams and assignments. The problem is, as I argued above, that yes, it may push you to accomplish specific milestones, but all too often this means you are pushed to accomplish the bare minimum with the least effort at the last minute.

And don’t tell me that means I’m just “not a very good student”, then. Sure, if you can combine powerful self-motivation with college coursework, you can get more than the “minimum” amount of education from a class, and some students do. So have I, in some courses.

But for better or worse, I’ve found that in many courses the combination of arbitrary requirements (i.e., the need to be present in class), horrible textbooks, frequently unenthusiastic professors (sorry guys; to be interesting you have to be interested in what you’re talking about), and a highly subjective qualification for success (complete these n assignments and learn these n concepts well enough to pass an exam or two), means that the very structure and implementation of a college class encourages you to do just enough to get by and no more, period.

(Aside: on horrible textbooks: the only textbooks I’ve wanted to keep from my entire time obtaining a computer science degree have been Sipser’s Introduction to the Theory of Computation and Larman’s Applying UML and Patterns; and of those, I gotta say, the Larman book is pretty boring (sorry, Craig, maybe we can blame your editors), but there’s some good material in there.)

So, enough complaining about colleges. I don’t really have any suggestions for how to fix the education system, if indeed it is broken — I’ll leave it to others to debate and solve that problem. But since I’m convinced that self-learning is more productive and more effective, then if I’m interested in the information that I might learn in a Masters Program in Computer Science, it seems reasonable that I’d be better off concocting my own program and just starting to plug away.

At the top of this article I put a link to the University of St. Thomas' graduate program in Software Engineering. Suppose we take that as a model and make a plan.

Required courses we have:

Foundations of Software Development. It’s waivable with experience, and if you’re even reading or contemplating doing something remotely like this, I’m going to guess you and I can waive this one. We’re assuming you can already code your way out of a paper bag, people. If you can’t do the FizzBuzz problem or write a binary search given the description, then you can’t waive this. Get up to speed, folks.
Technical Communication. Writing and speaking. I can see it being useful, but you’re going to have to decide if it something you want to be good at it. If it is:
- Write a technical blog. Force yourself to do it semi-regularly. Explain a concept, how you solved a problem, why something is the way it is, etc. You’re not doing it to become a ProBloggerSuperStar, you’re doing it to improve your written communication skills.
- Find & join a local users group in your field of interest (say, Ruby, Java, Cocoa, whatever) and give a presentation. At least one, to start. In anything. If this is something you want to be a lot better at, try to think of several presentations you could give; then volunteer to give them.
Software Engineering. Read (or re-read) Code Complete. The St. Thomas course description also includes the idea of estimating, so Mike Cohn’s Agile Estimating And Planning might also be apropos. If you’ve read both of those, then scan them to make sure you’re still up to speed and either a) give yourself a pass, you’ve got this one, or b) re-read or pick an alternate/more advanced tome on the subject and plow through it.
Database Management Systems And Design. I’m assuming you already know and use regularly at least one or more DB system; probably MySQL, but possibly sqlite, Postgres, or even MS SQL Server or Oracle. Great. Maybe you even know CouchDB or MongoDB or some other NoSQL system. Well, this is a Masters program. That’s Not Good Enough.
- Give yourself a refresher in DB design, SQL, maybe relational algebra if you like that sort of thing. Database in Depth is a good book. You might know others.
- Learn another system, whatever seems most useful to what you are doing (remember a HUGE key in making this work is that it must be something you really want to know about; follow what interests you): maybe a NoSQL db, or maybe Postgres. Learn what makes this DB different from others, from what you know already, and why. Try to figure out real reasons and/or scenarios you’d want to use one or the other.
OOAAD (Object Oriented Application Analysis and Design). Well you could read or re-read Larman or Booch, and that’s probably not a bad idea. Try to make it applicable to things you want to work on, as always.
Software Project Management. This is an area I could probably stand to improve in; I’m not certain, but I think I’d start with one or more of Scott Berkun’s books (The Art of Project Management, Making Things Happen) on the topic, which seem to have attained a sort of Gold Standard status. If you’re certification-minded you might reach for a PMP-based book. I’m not gung-ho on certifications, but maybe you think it will be good to have; and honestly, of all the certs out there, this one seems the most useful. If you have experience with PMP pro or con that you’d like to leave in the comments, please do, but remember that the whole point of this plan is to be more interested in results than whether or not my certification can get me a job with SAP.
Software Quality Assurance. This would be the ideal place to learn even more about software testing. Aside from that, I would have to look for some specific material pertinent to Software QA; suggestions welcome.
Operating Systems. Yeah, I guess it’s useful. And maybe it’s super-interesting to you; at the moment it’s not an area of intense interest to me, but I can see its applicability. I’d probably start by identifying the areas in which this sort of knowledge will help the most; probably in the areas of processes, threads, memory management and related themes. Might want to brush out the old C programming toolset and pick up a book on the Linux kernel; I don’t know. Again, if the only point is to check another item off the checklist, it probably will be hell to learn and you might not even bother. So find a way to make it interesting. Maybe just spend awhile really learning or re-learning multi-threaded application programming.
Computer and Network Communications. Again, I’m guessing we have the foundations of at least some or much of this down. So find an area of interest to you and push your knowledge further. Learn Node.js and write a server. Find an Open Source server/networking project and attempt to contribute something to it (even if it’s just documentation; come to think of it, contributing to a related OSS project would be a fantastic progress gauge for every area on this list.)
5+ electives. There’s always more to learn; what are you most interested in?
- Applied Statistics/Machine Learning/Analysis
- Other Maths? Go nuts.
- Another programming language. Lisp, Erlang, Python, Ruby, C(++/#), Objective-C/Cocoa, Javascript… pick something that you don’t know that you’d like to know, and start knowing it. Since one of the major hurdles in learning a new language is the “what the heck should I write in this language?” problem, a good tactic might be to apply your new language to one of the above subject areas; do your DB, Networking, or QA/testing explorations in a language other than the ones you already know.
- Security. Big topic.
- Cryptography. Related to security, but also a big topic all on its own.
- Algorithms and Data Structures. We all probably have some exposure to these, but if it’s an area of interest to you, I’m betting you’ll always learn something from a refresher course.
- Data Warehousing/Mining/etc.
- Distributed Databases or servers.
- Real Time systems/concepts.
- Artificial Intelligence, related research.
- …. ? I don’t know, you pick something you’re interested in.

There’s some of the above I feel like I have a decent grasp of, there’s some that I don’t. There’s some things that interest me, and that applies directly to the ways I pay the bills each month, so obviously those are the things I’d probably gravitate towards learning first.

I’m not going to “log my progress” on following this or any similar plan, but my point is:

It’s doable.
It’s valuable in and of itself.
You don’t need to spend 20K+ at a university to do it.
If/when you really have a grasp of all (or even MOST) of the above, you’re a software engineer who really knows his/her stuff, and especially if you can show the Open Source or other projects that you’ve contributed to along the way… you really don’t need the piece of paper from the university.

If you don’t like my list, or the books/ideas I’ve listed, make your own. Or, you know, whatever. I think most really good developers plan to keep learning continuously anyways, and are probably already doing so; this just happens to be a little more structured list based off a given Masters program description. Part of my whole theory here is that you’re going to be more successful if you’re trying to learn things that really interest you, or that you really want to use, so if you don’t care about project management, or networking, or databases, then by all means, just skip it. Focus on what you want to know. Maybe you’d rather jump straight in to statistics and machine learning. Go download R and have a ball.

Comments, suggestions, hate mail, fan fiction, can be submitted below. Thanks for reading.

Validating Nested Attributes on Update

2010-04-12T00:00:00-07:00

So, let’s say you have a model, and a has_many relationship to another model. You want to accept nested attributes for the child models in your forms, and you also want to validate that the children must be present; the parent model can’t be saved unless it has at least one of the child model associated. Easy enough, right?


class Parent < ActiveRecord::Base
  has_many :children
  
  accepts_nested_attributes_for :children, :allow_destroy => true
  
  validates_presence_of :children
end

class Child < ActiveRecord::Base
  belongs_to :parent
end

That’s not too bad. But the thing is, this will validate presence of the children on create, but not on update…


>> p = Parent.new # note: no children
=> #<Parent id:nil ... >
>> p.save!
=> # errors glaore
>> p2 = Parent.find(:last)
=> #<Parent id:23 ... >
>> p2.update_attributes("childen_attributes" => {"0" => {:_destroy => 1}, [... etc. Assume all children are sent a destroy flag here]})
=> true # what! it saved?
>> p2.valid?
=> false # what! it's saved, but not valid anymore... (because it has no children)

So, the trouble is (I think), when you save the existing Parent, at the moment validation is checked, there are still children. They won’t be deleted until .save is called. So the object is valid. Then after it’s saved, the children have been deleted, and the object is saved, but it is no longer valid. What to do?

Well, after some pondering, I wound up with this (in the update method):


class ParentsController < ApplicationController
  # other methods...
  
  def update
    @parent = Parent.find(params[:id])
    
    # assign the attributes _without trying to save_
    @parent.attributes = params[:parent]
    
    # this line winds up as true if all items are marked for deletion; otherwise, false
    reject = @parent.children.inject(true){|truthiness, n| !!(truthiness && n.marked_for_destruction?) }
    
    # check reject's truthiness first. Only try to save if reject is false. 
    # If we save first, it will save even though items will all be deleted.
    if !reject && @parent.save(params[:order_form])
      flash[:notice] = "Object updated"
      redirect_to parent_path(@parent)
    else
      flash[:notice] = "Object could not be saved"
      render :action => :edit
    end
end

Now, checking for an objects validity in the controller seems wrong to me, too, but it works. Anyone who has run into this find another way to do it?

xwing

2010-04-01T00:00:00-07:00

Oracle To Acquire Oracle

2010-04-01T00:00:00-07:00

REDWOOD SHORES — Oracle is rumored to have lined up yet another in a long string of billion dollar acquisitions, and this time they have set their sights on their very own corporation. No one from Oracle has been willing to make an official statement regarding the rumors, but the news has been spreading throughout Silicon Valley.

Oracle, currently worth an estimated 47 billion USD, is a market leader in enterprise software, known particularly for their database product. Industry analysts admit that a corporation buying itself outright is unprecedented, but that, “As a strategic move, it makes a great deal of sense.” Enterprise consultant Robert Forsythe comments, “At this point, there are not a whole lot of other companies for Oracle to acquire. Purchasing themselves provides a creative way around this dilemma. Also, adding Oracle’s stellar sales staff to their already exhaustive line of software products is sure to be a winning combination.” Forsythe added, “I would predict that the shareholders will be happy to hear this rumor confirmed in the near future.”

Not all industry analysts are quite so certain. “Rumors fly all over Silicon Valley on a regular basis,” said veteran Valley analyst Pratik Singh. “This is just the latest in a long line of the same. Could Oracle buy Oracle? Well, sure they could. They certainly have the capital to do so, and are in a better position than anyone else to know the details of Oracle’s business and strategy. But I fear this will only end up much like last year’s rumored acquisition of software giant Microsoft, by software giant Microsoft. That had everyone’s heads turning as well.” Pratik added, “Of course, no one in the press bothered to pay attention to the fact that this would have been a terrible acquisition.”

When questioned about the apparent contradiction inherent to the rumors, Forsythe said, “Sure, industry outsiders might ask questions like, why would Oracle buy themselves? Don’t they already own themselves?” Forsythe paused to allow himself a knowing chuckle. “But that just betrays a lack of understanding of how things work in the Valley.”

Indeed, acquisitions in and around Silicon Valley have a long and convoluted history, especially Oracle’s own long list of corporate purchases. Just last year, Oracle announced a purchase of BEA Software, an announcement which was hastily retracted when it was discovered that Oracle had already purchased BEA Software the previous fiscal year.

Even the skeptical Singh notes, “Oracle does have some of the brightest business minds in the world on their payroll. It would be irresponsible to assume that they have not considered the possibility of an acquisition of Oracle, by Oracle, and that they would not have made some detailed projections on the possible results of such a transaction. If they believed it would be a positive move for the shareholders, well, of course, every consideration would be made and Oracle would ultimately make the decision that is best for itself, it’s shareholders and its customers and other stakeholders.”

Regardless of the many and varied opinions put forth by the industry pundits, the rumors continue to gain momentum, and Oracle’s stock price has indeed jumped several points by close of business yesterday as a result.

Oracle’s CEO, Larry Ellison, also refused to comment directly on the rumors, saying only, “I’m Larry f@#$ing Ellison, I’ll buy whatever the f@#$ I want to,” before threatening members of the press corps with disembowelment at the hands of his samurai bodyguards.

Here Are The News

2010-03-23T00:00:00-07:00

This is simply awesome.

Courtesy Dan Misener.

Hello Toto

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

Moving this blog over to Toto. I did not move all the posts, but I don’t think there’s a big loss for the ones I neglected, and you can alway spend time looking for cached or archived pages if it Really Matters. Sorry.

Was having some trouble getting the feed to worked automagically, we’ll see what has happened there when it goes live.

Dumb Results Can Be Better Than Smart Results

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

The last couple posts have crossed over into a couple really big topics; one is web application usability, the other is the quality of results returned by an algorithm. They are not the same topic. Anything that can be made more usable should be. The quality of an algorithm’s results are not necessarily related to that. I started chatting with @Kurafire about this, and he is making some great points… but I still don’t precisely agree.

For example:

The problem with Google's algorithm is that a "mere" blog could outweigh the second-most visited website on the planet.

My point is that a site's traffic rank should be weighed more heavily, certainly when the difference btwn the two is so huge.

Let’s forget the “Facebook login” going to ReadWriteWeb rather than Facebook itself, for a moment. Let’s generalize.

Question: should an article about a company or entity ever get a higher search ranking than the website of the company or entity itself?

When you phrase it that way, I think the answer is clearly YES, there are situations where that could and should happen.

In late 2001, it would make a lot of sense for a search for “ENRON quarterly earnings” to point to an article about the accounting scandal rather than simply going straight to an official PDF of their earnings.

It’s reasonable that a search for “Amway” could return an article skeptical of MLMs as high or sometimes higher than the company’s own site.

Not all the time, and not every time, but there are situations where an article about something could or should get a higher result than the thing itself.

A human being organizing the results might never do that; or they would only do it after it became obvious. Algorithms are dumb. They will just spit out a result based on some sort of process. Sometimes, that’s better, since it removes our innate bias to how we think things should be ordered. If we try to weight an algorithm too much for the things we innately think should be on top, we could actually be detracting from the value of the algorithm.

Just a thought. I’m by no means saying that the googorithm can do no wrong, or has no room for improvement. Just that it’s possible for dumb results to be better than “smart” results.

Why It's Not A Google Failure

2010-02-17T00:00:00-08:00

By far the most common and seemingly reasonable objections to my recent post about internet applications and users have been along these lines:

Well, a ReadWriteWeb article about Facebook login is certainly not the same as Facebook's actual login page. So if people are looking for Facebook's login page, using Google, and are getting to a blog post instead, Google has indeed failed them.

Guys, gals, listen. This sounds very reasonable. It sounds empathetic. It feels right.

It’s wrong.

Stop and think, for a second, what it means to hold the conclusion that Google has failed their users in this case. It would mean, first and foremost, that in an ideal world, Google should never have returned any other result than the Facebook login page as a response to the query “facebook login.” Okay; if that were true, what does that mean? Either:

Their algorithm is not good enough. It's easy to say this, but let's remember that this algorithm that is "not good enough" is the same algorithm that catapulted a startup out of nowhere to complete domination in a field (search) that was well saturated by large successful search engines, even in the late 90s; this algorithm that is "not good enough," was nevertheless good enough to pull users away from every other established search engine. In this case, for an algorithm to be "good enough" to anticipate this particular scenario, I think it would basically need to be fully fledged artificially intelligent. So great, good luck with that; have fun on the research staff at the major university of your choosing. Also, I'd dare to suggest that if you can come up with a better algorithm, you have a corner office and a stack of VC money with your name on it waiting for you any time you want it, so get cracking.
Google should have anticipated this and manually set a top search result with the correct site for this query. It seems that people actually think this; it seems outrageous and unthinkable to me. There's no way Google, or any other large service, could anticipate this. I mean, it would be insulting to even suggest it: Engineer 1: Wait... wait... what if people are searching for a website login, and they query that? We should make sure that it is returned as the first result. Otherwise they might go to another page and think that they are on their website, and they will be confused that they can't log in. Engineers 2-999: Wait, now, the users may not be technical, but they aren't that clueless. Engineer 1: But... Engineers 2-999: Man, are you ever condescending. Engineer 1: I just... Engineers 2-999: Why do you hate users so much? Engineer 1: But I'm just trying to help... Engineers 2-999: Come on, users are going to know that they are not on the webpage they're looking for. It won't look the same. It'll have a different name. Unless it's a deliberate phishing scheme, and we are implementing this to detect and remove those... (long technical discussion about programmatically detecting phishing sites begins) Seriously, stop and think about it. You would need to be horribly and resolutely cynical about the intelligence level of your users to even suggest, ahead of time, that they (for example) would mistake a blog post from a different website for a web application that they use regularly, possibly daily. Besides that, there is an unwritten contract implied by Google's search listings. The fact that sponsored listings occur (reasonably clearly marked) at the top of the list, implies that the rest of the search results are untampered with. They have been selected based on their relevance to the search query which you supplied. If Google can just select any old result at the top of the list, it completely destroys the credibility of the results. But wait, you might say. They could do something along the same lines as the "Did you mean: [this]? that they already attempt to do for common mispellings...".
Oh, yeah, that *is* what I meant.
Yep, they could. And it's on this that I will concede, willingly, that perhaps they should try to do something like this in the future. Where I disagree is the idea that they should have already been doing this; that they should have somehow (magically?) known that this would be necessary.

So there’s that. I’m not saying “Screw the users, let them figure it out! Survival of the fittest FTW”. Really, I’m really not. Yes, absolutely, let’s make changes based on user behavior. Let’s make things easier to use when we find out they are not easy to use. Let’s do all those things.

But let’s also say:

It is okay to expect your users to have a basic understanding of the core functionality of your application. In the case of Google, this is not asking very much of the user.

Google: Okay, here’s how it works. You type something in the box. User: Okay, I’m typing. Google: … and I’ll try to find anything on the whole entire internet that seems to match what you’re searching for, and I’ll give you a list. User: Great, so you’ll find exactly what I’m looking for. Google: .Well, not exactly…. I’m going to find everything that seems to match, and I’m going to give you a list, and here’s the thing, it might be a humongous list… User: Awesome, so you will find exactly what I’m looking for. Google: … well, I’ll tell you what, I’m going to put what I think are the most relevant results near to the top of the list, okay, so chances are, hopefully… User: Hey, that’s just what I was looking for. Thanks Google! Google: Yes, well. That did work out pretty nicely. Actually, I hope it works that well every time, but you should understand that I’m just giving you a list of what I think will be the most relevant results, based on your query, and it might… hello? Hello?

I used to have to log on to the internet uphill, both ways.

Listen, I understand that it’s challenging. I don’t actually think “non-technical” people are “stupid,” any more than a tailor would think a programmer was “stupid” for being bewildered when sat down in front of a state of the art sewing machine. But if I’m going to insist on using the sewing machine, the tailor will try to tell me how to use it. If I continue to try to use it incorrectly, the tailor will eventually want to give up on me, unless I’m able to grasp at least the basic principles of how the thing works.

The Tailor: Look, it’s a sewing machine. See, here’s the bobbin… Me: I don’t really want a bobbin, I want thread. Or the needle. I think. The Tailor: The thread is on the bobbin… and it goes through the needle here… Me: And I push this pedal now? The Tailor: No, no, not now! Ok, so here is where you set the sort of stitch you want — Me: I just want to sew these two pieces together. Won’t it just know what sort of stitch I want? The Tailor: It’s just a machine, it doesn’t know anything. So we want this stitch here… Me: How would I know that? That’s easy for you to do. Why does this have to be so hard? The Tailor: If you’d just stop for a minute and learn to use it, it wouldn’t be that hard… Me: This all strange and unknown and mysterious and frightening and frustrating. Sewing sucks! The designers of this machine are stupid! (The Tailor gives up on me and goes to get a beer. I proceed to sew my index finger onto my jeans.)

Funkatron, whose post on this contributed to inspiring the original rant, added some points to the end of his post in response; and since he’s a smart guy, he completely understands the point I was actually making (or attempting to make):

I certainly don’t think that the computer can become (anytime soon) a magic box that determines our whims, nor do I think that people shouldn’t have to learn some things.

This is the point exactly. If we really expect that Google should “just know” what we want, we are expecting it to be magical. We are asking for something that belongs to the realm of unicorns and rainbows with pots of gold at the end.

Magic Google Power!

At the risk of sounding like an asshole again, it’s called a search engine, not a finding engine. It cannot read your mind. If you expect it to be able to read your mind, you are stepping outside the bounds of what can reasonably be expected from a machine. The famous button is “I’m feeling lucky,” not “Take me to exactly the page I’m thinking about in my brain.”

Neither You, Nor Me, Nor Google, Can Read Minds

I’m married. Inevitably, my wife will say things or ask things, and lo and behold, the thing that she really wants or means is not exactly the same thing as what she says. Ideally, I would “just know” what she intends me to get from her comment or question. And while, over time (we’ve been married 8 ½ great years), I can become a better guesser, I will never be 100% able to do this because (surprise) I cannot read minds.

Here’s the real point: if I view myself as a failure because of my inability to read minds, I am setting myself up for misery. It is not reasonable to set impossible tasks as criteria for success.

Really, if that one thing is not communicated in these most recent two posts, then I’m just not going to be able to communicate it. Expecting Google (or any software) to “know,” with certainty, my intentions, is completely absurd. And with that in mind, there is no way to call this a failure on the part of Google.

Ed goes on to say:

What I do think is that the current interface modern OSes on computers provide is simply overwhelming for most users, to the point that it’s very challenging to learn how to accomplish tasks without a very significant investment of time.

Look, here I agree completely. I have agreed with this the whole time. I’m a huge supporter of user testing, of good UX design, and of changing things based on user feedback.

In fact, I’m probably just being a bit pedantic to be stuck on this one, single atom of disagreement, that is, the idea that Google or developers generally have “failed.”

Here’s another example. When you go to a gas station to fill up your car (here in the US, at least), you can usually use a credit card at the pump to pay for your gas. A credit card has a magnetic stripe on one edge of one side of the card. So because I can flip a credit card upside down or front to back, there are four ways I can put the card into the slot, and only one way that the machine can read the magnetic stripe. Now, there is (almost) always a handy diagram showing you how you’re supposed to put the card into the machine. But people do it wrong all the time. Because the part of the card reader that reads the stripe is usually clear, there are normally only two obvious ways to insert the card: stripe up facing left, or stripe up facing right.

Now, at some point, some wonderful person who designs these machines said, You know what? People are always putting their card in the wrong way. It would be really trivial to just put a magnetic stripe reader on both sides, and then as long as the stripe is at the top, it is impossible to insert the card incorrectly. And they implemented it, and it seems to be standard on most new gas pumps.

Is the new design, where it is (almost) impossible to run your card incorrectly, better? Absolutely it is. It’s improved.

Hey, now that’s pretty handy.

Was the old design wrong? Was it a failure on the part of the gas pump card reader designers? I’m going to say no. It wasn’t wrong. It did what it was supposed to do, and asked only that the user glance at the diagram to know which way to put the stripe in to the card reader. There was room for improvement, and it was indeed improved, but it was not “wrong.”

Steve Krug’s disciples might now be saying, The old design requires you to think, so it is failing! Don’t make people think!“

Steve Krug’s work is great, and I agree completely with the “Don’t Make Me Think” mantra. But there comes a point, with anything, at which people must make a decision, and we have to assume that people will demonstrate some common sense.

The machine knows where it is going!

Wired claims that 300,000 accidents in the UK have been caused by people following their GPS systems

So you can only take that so far.

If I want to sew, I can argue all day that sewing machines should be easier to use, and hey — maybe we can still come up with ways to improve their usability. But sooner or later, I need to accept that I must learn to use a sewing machine in order to get the results that I want. The responsibility is mine. It is not the sewing machine’s fault if I can’t stitch two things together.

And if I blame the sewing machine, I’m wrong.

No, We're Not The Stupid Ones

2010-02-16T00:00:00-08:00

Update: follow up post on why it’s not a Google failure.

If you follow the same flow of information I do, you probably saw the article Facebook login is hard, or are at least aware of the confusion it’s talking about. Just in case, for context: last week a ReadWriteWeb article became the top-listed result on Google for “Facebook Login”, and several hundred (just going off the number of comments) Facebook users wound up at ReadWriteWeb trying unsuccessfully to log in to facebook, eventually leaving comments venting their frustration. (Aside: my favorite was the one who found the “right” way to get to facebook, now: search for it on Bing instead…)

But I’ve started seeing comments and blog posts to the effect that this is actually a failure on the developers part; that bad UI or bad software/UX design is somehow responsible for this.

To which I say, bullshit.

I’m a big fan of making things that have great user experience, intuitive UI, well developed information architecture, etc, etc. So I empathize with that line of thinking, to a point; yes, if there’s a city intersection that gets 500% more traffic accidents than every other intersection, maybe we should look at the urban planners and suggest they might have screwed it up and should now fix it. I don’t find this analogous to that, though.

Not (for example) with this:

Isn't this really a failure of Google? (From We're the stupid ones)

No. It’s not a failure of Google. RWW wrote an article about Facebook Connect — about logging in with Facebook — and said article became a top result for the phrase “Facebook login” on Google. That is an example of Google working as it is intended to work.

I think it’s fine if people use a search engine field as a sort of web-based CLI; heck I use it for that, if I’m looking for a site and don’t remember if it’s .com or .net or .info, or if it’s somethingapp.com or somethinghq.com or getsomething.com, and hey, if I know that it’ll come up if I simply search for it, then yes: why not. Search is quicker than having to try even one extra URL because the first one you used the wrong TLD. So using a search engine to find your website: fine, go for it. I’m not arguing that this should be discouraged. (That said, I believe there have been studies showing that people actually also search for fully qualified URLs, like “myspace.com,” and really, it does seem like someone should tell those folks about the address bar… but I digress.)

Facebook evidently has somewhere in the neighborhood of a bazillion users, now. I don’t want to stop and look it up, so lets just say it’s one bazillion, where 100 million < 1 bazillion < infinity; in that neighborhood somewhere. So the several hundred confused and frustrated users were something along the lines of a fraction of a rounding error on a percentage point of Facebook’s entire user base. Not what I would call a UI catastrophe.

This is not to say that these people are not important, only that it is okay to expect them to learn how to use the internet. It is okay to expect people to invest a little time to learn how stuff works and to retain an adequate portion of that education.

Just because it’s photoshopped doesn’t mean it’s not funny.

Take ReadWriteWeb. I don’t know if they’d win an award for UI or UX, but they don’t suck. I think that it’s fairly clear that ReadWriteWeb is a distinct website named ReadWriteWeb. I don’t think we should have expected them to introduce a flashing banner warning visitors: ATTENTION — THIS SITE IS NOT ACTUALLY FACEBOOK. They wrote an article, that article got some google juice. All in all, they’re doing what they set out to do, writing stuff that is findable to the people who are looking for it.

Taking an event like this one and suggesting that it is somehow the fault of the designers of Google and/or developers generally, is absurd. It just isn’t. I empathize with some of what folks are saying (Funkatron, linked above, for example). If they just want to say maybe we’re being too hard on people, I could grant a well maybe, but overall, look:

If I search for “basecamp” in Google and wind up at a mountain climbing equipment supply store instead of the 37signals product I wanted, it is not Google’s fault (or 37signals', or the camping store’s) if I start banging my head against the screen and asking “Wheerre are my prooooojectsssss?????”

It just isn’t.

Update: follow up post on why it’s not a Google failure.

A Fledgling Freelance Professor

2009-08-20T00:00:00-07:00

[_why] is a fledgling freelance professor, one who will die young and make no lasting impression. except there was that time when i vacuumed all of Greenland for them.
bio from the blog that formerly lived at whytheluckystiff.net

Unit testing, in particular, is designed to reel in spontaneous hacking. It is like framing a picture before it has been painted. Hacking, at heart, will continue to be something of spontaneous order, something of anarchy, and the landscape of hacking is something which comes from human action but is not of human design.
From "This Hack was not properly planned," quoted on Anarchaia

No, let's not have rules. I don't feel comfortable with having coding standards or any protocol on Camping. The point of Camping is to have very ugly, tricky code that goes against all the rules that people make for "beautiful" code these days. To show that ugly code can do beautiful things, maybe. I don't want to demonize anyone here, I just want to express the ideas that make Camping different. Camping's personality is 80x50. It is like the little gears of a watch that are all meshed together into a tight little mind-bending machine. The challenge of Camping isn't to figure out how to automate obfuscation. The challenge is to bring new tricks into the code that push Ruby's parser and make everyone look twice. Not all code needs to be a factory, some of it can just be origami. _why
From Kyle Neath's tumblr.

Why the lucky stiff

John Resig’s eulogy to _why

script/console, Under The Hood

2009-07-24T00:00:00-07:00

Photo by Steffe

I’ve recently started digging into script/console a little deeper. As a tool for Rails development, I think it’s safe to say that words like “indispensable” come to mind when the topic of the console arises. That said, I’ve yet to see a really complete guide to using script/console — lots and lots of collections of tips and tricks, but never a good solid guide to what’s going on with script/console.

This is the first of what will hopefully be several posts about what’s really going on when you open the rails console.

If we look at just the console script, we’ll find just these three lines:


#!/usr/bin/env ruby
require File.dirname(__FILE__) + '/../config/boot'
require 'commands/plugin'

The first line is simply the shebang line that lets the file be an executable ruby script. The second line requires the file config/boot. This file is a little over a hundred lines by default, so we won’t reproduce it here; you can read it quickly (if you want to) in one of your own rails projects. It basically sets some load paths and some constants, and ends by booting rails with Rails.boot!.

The third line requires commands/console… and that’s it. So to see what’s actually happening, we’ll have to look there.

You can find commands/console.rb in railties/lib in your rails directory, in vendor if you have frozen rails to a specific version, or otherwise under your rails gem in the lib directory.

(e.g., on this machine it’s in /usr/local/lib/ruby/gems/1.8/gems/rails/lib/commands/console.rb).

console.rb looks like this:


irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'

require 'optparse'

options = { :sandbox => false, :irb => irb }
OptionParser.new do |opt|
  opt.banner = "Usage: console [environment] [options]"
  opt.on('-s', '--sandbox', 'Rollback database modifications on exit.') { |v| options[:sandbox] = v }
  opt.on("--irb=[#{irb}]", 'Invoke a different irb.') { |v| options[:irb] = v }
  opt.on("--debugger", 'Enable ruby-debugging for the console.') { |v| options[:debugger] = v }
  opt.parse!(ARGV)
end

libs =  " -r irb/completion"
libs < < %( -r "#{RAILS_ROOT}/config/environment")
libs << " -r console_app"
libs << " -r console_sandbox" if options[:sandbox]
libs << " -r console_with_helpers"

if options[:debugger]
  begin
    require 'ruby-debug'
    libs << " -r ruby-debug"
    puts "=> Debugger enabled"
  rescue Exception
    puts "You need to install ruby-debug to run the console in debugging mode. With gems, use 'gem install ruby-debug'"
    exit
  end
end

ENV['RAILS_ENV'] = case ARGV.first
  when "p"; "production"
  when "d"; "development"
  when "t"; "test"
  else
    ARGV.first || ENV['RAILS_ENV'] || 'development'
end

if options[:sandbox]
  puts "Loading #{ENV['RAILS_ENV']} environment in sandbox (Rails #{Rails.version})"
  puts "Any modifications you make will be rolled back on exit"
else
  puts "Loading #{ENV['RAILS_ENV']} environment (Rails #{Rails.version})"
end
exec "#{options[:irb]} #{libs} --simple-prompt"

There’s a fair bit in there, so let’s look at what it’s doing in detail.

Line 1 is setting a local variable named irb. It checks to see if the constant RAILS_PLATFORM matches a value that would indicate we’re using some flavor of Microsoft Windows; if we are, it sets irb to irb.bat, which is what irb will be named for a Windows build of ruby; otherwise it’s set to simply irb, which is the commands name on *nix systems, including Mac OS X.

Next it requires ‘optparse’. optparse is a Ruby library for parsing options (I imagine you guessed that).

Then a local variable named options is created, and is given a few default parameters: :sandbox is set to false (more on this in a moment), and :irb is set to the local variable irb (in other words, to either ‘irb.bat’ or ‘irb’, depending on the result of the expression on line 1).

An OptionsParser object is created next. We won’t dive into the details of this, but you’ll note a striking similarity to what you see in this block and what you’ll see if you type script/console -h in your rails root.

So if we follow along, we’ll read about the three standard command line arguments we can use when firing up the console:

—sandbox, which just adds the feature that any changes you make to the database will be undone at the end of your console session —irb, which allows you to choose a different version of irb if applicable; so, if you have Ruby 1.9 installed, but not set as your default ruby version, you could start up the console with script/console —irb=irb1.9, and see how your console experiments work with Ruby 1.9. —debugger, which enables ruby debugging.

Next a local variable named libs is created; it’s a string, and a number of lines are concatenated to it, each in the form “ -r [some library or module]”. The libs variable is eventually going to be passed to irb when the console starts it; the -r switch to irb simple requires whatever the next argument is. So this is simply building a list of the modules and libraries which are going to be present when the console is fired up.

The next section handles the case where you have actually typed script/console —debugger; it tries to require ruby-debug, and if an exception is raised, it will helpfully suggest that you run gem install ruby-debug.

On line 31, console sets the environment; it looks at your first argument to see if you tried to specify an environment, and if not, sets it to either ARGV.first (the first argument, if applicable), ENV[‘RAILS_ENV’] (whatever the environment is already set to), or as a last resort to ‘development’ (which is probably what you want, most of the time, hence why you may only rarely use this feature).

If you try this by typing script/console foo, you’ll see that console will try (and fail, unless you’ve created a foo environment) to find the file /config/environments/foo.rb. So as long as the environment you specify exists, the console will use it.

Now, since it’s using ARGV.first, you might ask yourself why, if you type script/console —sandbox, the console does not try to load the “—sandbox” environment. Good question! The answer can be found up in line 11: opt.parse!(ARGV). The parse! method parses destructively; it pulls any valid options out of ARGV, and then returns whatever’s left over. So if ARGV started out as “test —sandbox —irb=irb1.9”, after opts.parse!(ARGV) it will just equal “test”. If nothing but valid options were supplied (i.e., no attempt to specify an environment), ARGV would be an empty string, and the environment will be set to either ENV[‘RAILS_ENV’], if it exists, or to ‘development’ if it doesn’t.

So now console’s figured out which environment to use, it checks to see if you’ve specified the sandbox option, and if you have, it prints a friendly message to remind you that anything you do to the database will be undone when you exit the console.

But wait, you might say. Other than print a message, it doesn’t do anything; what actually makes the sandbox/database rollback work? Good question. If you look back up at lines 14-18, where the libs variable is set, you’ll note that console_sandbox is required, but only if options[:sandbox] returns true. console_sandbox will take care of all that database rollback headache for us; so that’s where it will come from.

There’s only one line left: an exec expression. exec is going to execute the string you pass to it on the command line. So a plain vanilla run of script/console is actually running:


irb -r irb/completion -r ~/your_rails_project_path/config/environment -r console_app -r console_with_helpers --simple_prompt

If you really want to, you could just type all that every time you want to use the console, but I’m guessing you’ll stick with script/console.

If you’re thinking there must be a little more to it than this, you’re right; you’ll remember that when libs was created, the modules console_app and console_with_helpers were required. That may be what I write about next, but in the meantime, if you have Rails installed you can always just open those files up and see what’s in them.

Ruby's Object#send Can Call Private And Protected Methods

2009-06-26T00:00:00-07:00

Photo by xiaming

One of the hallmarks of object oriented programming in most every implementation of it that I know of is the ability to designate certain methods as “private” or “protected”, thus keeping them from being called willy-nilly by any old script that wants to call them. Ruby also has this, of course, but interestingly enough it can be easily circumvented.

I guess there are a few posts floating around about it, but I discovered it by accident playing around in irb this evening. I was reading David A. Black’s The Well Grounded Rubyist, where he mentions that you could send a message to a class either within the class definition itself, or by simply sending it to the class object like you’d send any other message:


# The normal way to do it
class Thing
  message :whatever
end

# you could also do this
Thing.message(:whatever)

David mention’s attr_accessor in this context, so I thought I’d try that. Open irb:

>> class Thing
?> end
>> Thing.attr_accessor :name
NoMethodError: private method 'attr_accessor' called for Thing:Class

Oh. So much for that, then. But, knowing of the existence of the send method, I thought I’d try that.

Thing.send(:attr_accessor, :name)
=> nil

For the non-irb user, that nil that was returned, and the fact that no error message was returned, indicated that our experiment worked. Now Thing’s have a name attribute.

>> t = Thing.new
>> t.name = "Larry"
=> "Larry"
>> t.name
=> "Larry"

What’s interesting about all this is that attr_accessor is a private method on Class. Yet we just called it.

send is often introduced as a way to show how everything is an object and that you can do exciting things like 1.send(:+, 1) and get 2 as the result. No one usually mentions that it can be used to call private or protected methods from outside a given class.

To make it clear what you could do here:

>> class Thing
?>    def hello
?>     puts "Hello, world!"
?>   end
?>   private
?>     def private_hello
?>       puts "Hello, privately."
?>     end
?> end
>> t = Thing.new
>> t.hello
Hello, world!
=> nil
>> t.private_hello
NoMethodError: private method 'private_hello' called for ...
>> t.send(:private_hello)
Hello, privately.
=> nil

So, yes. You can do this, if you so choose. Please use your powers for good, and not for evil.

Now why this works, I can’t yet say, though I’m interested in learning, if there is a reason. Evidently there may have been some debate as to whether ruby 1.9 would still have this behavior, but as of this writing it does.

Note: I did only a brief search, and it seems this functionality is not unknown, though it still seems somewhat odd to me that such an easy way to sidestep the private/protected designation of methods exists.

Rails: Testing Your Floating Point Numbers

2009-04-17T00:00:00-07:00

You’re being a Good Software developer and diligently testing all your code, and lo and behold, you get this result to one of your tests:


1) Failure: ... <1.0> expected but was <1.0>

An annoying problem with floats that might look and for all practical purposes be equal, but internally as stored by the computer are not precisely equal.

You’re probably using:


assert_equal 1.0, a_value_expected_to_be_1.0

Instead, use:


assert_in_delta 1.0, a_value_expected_to_be_1.0, 0.000001

Though, you may also want to ask yourself if you really need to be using floating point numbers; but assuming that you do need them, assert_in_delta will compensate for the annoying fact that floating point numbers might not actually be precisely what you expect them to be.

Testing Ajax Requests In Rails

2009-01-18T00:00:00-08:00

Just figured out a test on which I spent far too long wondering why it wasn’t working. I kept coming back to it and trying something else, and it kept not working.

We have a form which submits to a create action by a remote_form_for; so, an Ajax request, in other words. The controller action just uses render :update and replaces some HTML instead of redirecting. But in every other respect, it’s a POST to the controller, and is going to call :create. Easy, right?

We’re using shoulda, and despite having a perfectly reasonable post :create, :whatever_id => @thing.id, :our_model => { :stuff => “stuff” } in the setup, it wasn’t actually creating the item; shoulda’s handy should_change “Thing.count”, :by => 1 kept failing.

I finally just started flipping through The Literature (in this case, the Rails Way’s chapter on testing), and happened to notice an off-hand remark that, in addition to methods for POST, PUT, GET, etc, there was an xhr method, to simulate an XMHHttpRequest.

Well.

What I should have been writing, all along, was:


xhr :post, :create, 
  :whatever_id => @thing.id, 
  :our_model => {:stuff => "stuff"}

It’s always the little things.

Remember to read the literature.

In Which I Am No Longer A Very Good Bachelor

2009-01-16T00:00:00-08:00

My wife has gone to Thailand for two weeks. So I’m on my own.

I am, as they say, “batching it” for a couple weeks. This is usually understood to mean that I will wear the same underwear for two weeks, eat nothing but junk food, abandon cleaning the house, and play video games all night.

This isn’t working out so well.

The video game thing isn’t happening. I look at my X-box (old one, not a 360) and think, I could sit and play something for… for, well for hours. But then I think, But I’ve finished all the games I own. And I don’t really feel like replaying them yet, and I could go get a new used game, but I can’t think of anything I’d want to own, and really, is that responsible?

I tried to leave the dishes in the sink. Normally this is no problem. This week I keep looking at them and thinking, Sheesh, it’s only going to take five more seconds to put it in the dishwasher. And the next thing I know, it’s in the dishwasher.

I bought a huge bag of potato chips when I went grocery shopping. They are still sitting unopened on the kitchen table. Every time I look at them, I think, Those sound good, but I should really eat some real food. Those aren’t very good for me.

I have a strange compulsion to vacuum the rug. I can’t explain it, it’s just there.

I’ve tried leaving my clothes on the floor when I change, but it just throws the whole room off. I have to put them in the hamper.

I’m beginning to think that I am no longer a very good bachelor.

Oh, I can talk the talk. I can say I’ll eat cereal two meals a day, shower “later,” and stay up till 3am. Except that there are some leftovers to eat, and that sounds a little better. Or maybe pasta. Or a roast. With some potatoes and broccoli. And I will feel a lot better if I have a shower, and 3am… man, I need to get up early, I can’t do that.

So far, I have not shaved my face. I am counting that as a point for the “batching it” score.

But for now, I should get back to work. And if I’m not going to open those potato chips, I think I should really take them off the kitchen table and put them in the pantry.

I Hold Strong Opinions About The Placement Of Curly Braces

2009-01-14T00:00:00-08:00

I hold strong opinions about the placement of curly braces.

I don’t care where K & R put them, I’ll put them wherever I want to put them. And don’t even start with the CSS files with the closing curly brace indented inline with the rules. Where did that come from?

It appears that I also hold strong opinions about indentation. Also, on whether or not a space should be left on the inside of opening and closing delimiters before the argument(s) they contain, where such delimiters are optional, whether or not they should be used, and whether or not text should wrap in the source listing, .

I have strong opinions about choices of languages to use for programming. Although I will concede, probably grudgingly, that there are other languages which may be faster, more elegant, more efficient, or more popular than my favorite language(s), this will not alter my preference, and if pressed I will defend my language regardless of its perceived shortcomings. If nothing else, I will claim that my language is more fun, or some other reason for its superiority which has nothing to do with programming languages per se. Furthermore, I will not accept the use of these same arguments if used to show that a different language is somehow superior to my favorite language or languages.

I have a great respect for people who understand topics or concepts which I do not understand yet, but which I nevertheless place on a pedestal as pinnacles of programming wisdom.

I have deeply held convictions about text editors. Really, it’s better not to talk about it. Just walk away.

I am strongly attached to the frameworks and libraries which I approve of, and repulsed by the ones of which I do not approve. Large libraries which I like are multifaceted, while the ones which I do not like are bloated. Small libraries which I like are elegant and efficient, while those which I do not like are incomplete or trivial.

I have strong opinions about Operating Systems. People who are not using my favorite Operating System would be far more productive if they would simply “wake up” and get “real computers”. Brilliant people whom I respect but who nevertheless use other Operating Systems are exempt.

We should talk about indentation some more. I hold opinions on whether said indentations should use spaces or tabs, and how many spaces they should use. They are only opinions. However, if you do not share them, you are probably wrong.

When there is more than one way to do something, I will have an opinion on which is the best way to do it. This opinion is correct, although I may tell you that your way of doing it is fine also. I am just being nice. Your way is retarded, slow, inefficient, insufficiently clever, unmaintainable, obfuscated or deprecated, pick two.

I have opinions about software development methodologies. These opinions cover project management styles, agile methodologies, artifacts, modeling languages, and best practices. Projects which fail to do well invariably failed because they neglected an area which I feel very strongly about, and will describe to you in great detail if you show a sign you are interested.

I am deeply attached to my preferred tool for source control management, which is better than your preferred tool for source control management, unless you happen to prefer the same one, in which case you are correct.

I have a favorite computer acronym, a favorite obsolete piece of hardware, a favorite programming anecdote, joke, historical event, and aphorism. I have a favorite algorithm, meme, binary operator, ascii character and UTF entity. I have a favorite NP Complete problem, which is more interesting than your favorite NP Complete problem, even though they can both be shown to be reducible to a common problem, or even to each other.

Despite my not yet having designed or created a killer app, I am convinced that I know why other apps have failed, and will not hesitate to share this knowledge if prompted. Despite having not run a multi-million dollar technology company, I know exactly what is wrong with the companies which are out there, and how they could be fixed.

Just don’t ask me about politics or religion, now; I prefer not to be argumentative on the internet.

Some Ruby & Rails Tricks

2008-08-27T00:00:00-07:00

I certainly can’t claim to have discovered these tips; but they’ve been pretty helpful to me. Maybe this will just make them a little easier to find for whoever is looking for them next.

Getting A Collection's Index From Within a Partial

Lets say you’re passing a collection to a partial, but that somewhere in that partial you are interested in knowing which index you’re at. Do you need to implement a counter? Nope; there already is one. A collection passed to a partial implicitly creates a counter called [partial_name]_counter. So, if you called with


< %= render :partial => 'thing', :collection => @a_few_of_my_favorite_things %>

then in your partial, you could use:


< %= thing_counter %>

to return the index as you plow through the collection. Life is good. Rails is looking out for you. (Hat tip to GMarik, which is where I saw this one.)

Obtaining a Class name From a String

Today I found myself wanting to take a string, let’s say “Thing”, and use it as a class name, Thing. Again, it turns out this can be done. In Ruby, class names are constants, so you can do


str = "Thing" #=> "Thing"
Kernel.const_get(str) #=> Thing

Hooray!

Make Finding Easier

Find yourself writing long, complicated find expressions in your code? There is a better way.

Perhaps in your code… maybe even in a view… maybe you want to find all Things that don’t belong to the current use, and which are flagged with some property, and you’re temped to write something like:


Thing.find(:all, :conditions => ["user != ? and flag = true", current_user])

What we could do is put some has_finders in the Thing model, something like


class Thing < ActiveRecord::Base
has_finder :exclude_user, lambda {|user| {:conditions => "things.user_id != #{user.id}"}
has_finder :with_flag, :conditions => "things.flag = true"

Having done that, you could now replace that first bit with:


Thing.find(:all).with_flag.exclude_user(current_user)

It’s a little shorter, sure, but more importantly, when you read it, it just makes more sense. A completely new person coming to look at this line would have a good idea what it was doing without even looking in the model to see what the has_finders were doing.

Okay then

If you’ve spent any amount of time using rails, these probably aren’t new to you. Everything’s new at least once, though, so hopefully these are helpful to someone.

Other favorite ruby or rails tricks? Leave a comment! Heck, we’re not prejudiced, here, go ahead and comment with your favorite Python or Perl or [other language] tricks, too, if you like.

Clearing Form Fields With jQuery

2008-05-09T00:00:00-07:00

I used a little jQuery last night to clear some form fields. The basic idea was, there were a couple text inputs in the form for first and last name; rather than label the fields, I made the value of each form to be initially “First” and “Last” respectively.

Then I was requested to make it so that when the field was clicked on, the word “First” or “Last” (respectively) would disappear, so that you could then proceed to enter a value without needing to highlight and delete the existing value of the text field.

It turns out that with jQuery, this is simple enough; let’s assume your field has the class “clearme”:


$(document).ready(function () {
  $('.clearme').focus(function() {
    $(this).val("");
  });
});

If you’re familiar with jQuery, you know that the wrapper $(document).ready() simply waits until the page is finished loading, then executes the function you’ve passed to it. In this case, the function passed looks for an item of the class “clearme” and waits for that element to receive focus. When it does, it changes the value to “”.

Simple enough… but wait! Now if the user types in “Beauregard Charles Maurice” as a first name, if he inadvertently clicks on the text box again, his name will disappear. He would need to type that all over again. What can be done?

There may be multiple ways; but jQuery has a handy method called “one” which will execute an event one time only, which sounds like just what we want. So we’d change the body of that inner function to look like:


$('.clearme').one("focus", function() {
  $(this).val("");
});

Blizzard Closes My Unused World Of Warcraft Account For Unclear Reasons

2006-09-25T00:00:00-07:00

So, this was in my inbox this morning:

***Notice of Account Closure*** Greetings, This is a notification regarding your World of Warcraft account. Access to this account has been permanently disabled for exploitation of the World of Warcraft economy or for being associated to accounts which have been closed for intended exploitation. While we try to be as lenient as possible in our assessments of the results of exploitation investigations, reoccurring trends in exploitative endeavors on your account have ultimately resulted in account closure. As a result, this account will no longer be able to access any aspect of World of Warcraft. This action has been taken in accordance with the Terms of Use (http://www.worldofwarcraft.com/legal/termsofuse.html) and our game policies (http://www.blizzard.com/support/wowgm/?id=agm01712p). According to the World of Warcraft Terms of Use, to which all players agree when installing World of Warcraft, Section 3, Paragraph C [Rules Related to Game Play] states that you may not do anything that Blizzard Entertainment considers contrary to the "essence" of World of Warcraft. Thank you for your time and understanding of our position in this matter. Please feel free to contact us with any questions or concerns you may have. Regards, Account Administration Blizzard Entertainment www.WorldOfWarcraft.com

Hmm. Access to this account has been permanently disabled for exploitation of the World of Warcraft economy or for being associated to accounts which have been closed for intended exploitation. That’s interesting.

It’s especially interesting considering I cancelled my subscription over a month ago since I simply did not have time to play World of Warcraft. I’m fairly certain I have not logged on to any WoW server in well over two months, possibly longer.

I was considering re-activating the subscription at some point, if and/or when I have more free time to play MMORPG-type games (I just like typing MMORPG) — so this is a little annoying.

I replied to them; hopefully they can explain exactly what it is about NOT PLAYING that flags an account as “exploitative”.

UPDATE: Folks keep visiting this post, so I can only guess that this keeps happening to people, or that people are still trying to resolve it.

In my own case, my World of Warcraft account is still closed. The only means they will accept to re-open it, apparently, is for me to send them a fax (yes! a FAX) of my driver’s license. I don’t have a fax machine, nor a scanner most of the time, so I keep putting this off. I finally got around to doing it one day, and they replied that the incoming fax was too fuzzy and that I should scan my ID again and re-fax it.

That was about a year ago. I haven’t bothered to re-fax it yet.

The Emperor's New Web

2006-09-22T00:00:00-07:00

Once upon a time there was an emperor of a far country. In this country, the internet prospered and grew, and the web was used by many of the emperor’s subjects. The emperor himself was a web aficionado, and was a great patron of Internet and web related ventures in his empire.

One day, two developers arrived at the palace, and asked if they could have an audience with the emperor. When pressed, they stated that their purpose was something mysterious to do with the web, in which they believed that the emperor would have great interest, but which they could not reveal to the porter unless he signed a NDA. The porter, knowing his majesty’s affinity for all things webby, immediately ushered them to the audience room.

When the emperor learned of their presence, he immediately went to meet them, and to ask them what it was they wished to show him.

“We are working on a Whole New Web,” said the first.

“It will be the New New Internet,” said the other.

The emperor raised an eyebrow.

“It will be more responsive… more socially connected,” said the first.

“It will look fancier,” said the second. “Everything will be shiny and beautiful.”

“It may have to stay in beta for awhile,” began the first.

“Also — it possesses the unique quality that only those users who ‘get it’ — users with ‘clue’ — will be able to see it,” said the second.

“Yes,” said the first. “You will immediately be able to tell who are the best and brightest in your empire by how they react to the New New Internet.”

“I’m interested,” said the emperor. “Tell you what; you can stay in the palace, and work on this.”

And so the two strangers began to work. For a long time, they worked in solitude, but eventually, after the emperor had signed up for their release notification mailing list several times, they announced that they were ready to show him the results of their labors.

Extremely excited, the emperor rushed down to the development lab. There he sat down in anticipation in front of a computer, and one of the developers clicked a link, and their new site sprang to life.

The emperor blinked.

“Well,” said the first, “What do you think?”

The emperor considered. Certainly, it was very pretty. All the colors were vivid, and there was an attractive design scheme to the whole page. The logo was very shiny. It had a transparent shiny badge that said “Beta” covering one corner of it. You could connect with other users of the site. It had tags. It had RSS feeds.

But none of these were things that were new to his majesty the emperor.

“Well,” he began.

“Have you seen this?” said the second, and he began clicking things.

As he clicked, various bits of the page would fade in and out, and slide around, and expand and contract. It was very slick-looking, and while it was not a completely common practice, the emperor was aware of how this was done, and that it had been possible to do things like this on web pages for some time.

“That is nice,” he admitted. “Well…”

“As we mentioned,” said the first, “Only people who ‘get it’, netizens with ‘clue’ are able to see the New New Web.”

Anxiously, the second said, “You do see it, don’t you?”

At this point, the emperor was unwilling to say that he did not have “clue”, or that he did not “get it”, so he said, “Well of course I see it. It’s the new new web. I ‘get it’!”

“Wonderful,” said the two developers in chorus. “We knew you would!”

“Now we just need to share this with the rest of the empire,” said the first. “You will notice that you have several ‘invites’ to share to our beta.”

“Perhaps after it has spread around we can talk about second round funding,” said the second.

The emperor agreed, and dutifully “invited” some of his relatives and courtiers to the beta. He was sure to say that this was, indeed, The New New Web, and that only those “with clue” could “get it.”

Needless to say, all of his invitees gladly proclaimed that they, too, “get it”, and began to invite others to the Emperor’s New Web.

All over the empire, everyone began to flock to the Emperor’s New Web, and everyone said they “got it,” and were not about to admit they did not have “clue.”

One day, they threw a New New Web Conference, and gathered together to talk about important things like well-styled XHTML, the use of gradients in company logos, tag clouds, and social networks. While the emperor himself was giving the keynote of the highlights of the New New Interweb, a young boy in the crowd proclaimed loudly:

“But it’s just the same as the old web! There isn’t anything new at all!”

There was an awkward pause, and then the crowd began to laugh. “Pay no attention to him,” they said. “He’s just a boy. He doesn’t ‘get it’.”

“Sure it’s shiny,” said the boy, “But shiny is not enough to call it a Whole New Web.”

“It has social networking and tagging!” said someone.

“Social networking is not new,” said the boy. “Bulletin boards are an example older as old as my parents. And surely tags alone are not… the Whole New Web?”

“It has Ajax and fancy JavaScript effects!” said someone else.

“And those… programming languages and effects that are caught on but are not ‘new’ at all — those are all that you are calling the New New Web?” asked the boy.

The emperor decided it was time to speak. “But it is the combination of all these elements, together, that is new.”

The boy seemed perplexed. “Is it?” he asked.

The emperor stammered. The crowd began to murmur and to look suspiciously at the emperor, and at the large plasma screen which displayed a page of the Emperor’s New Web.

Suddenly, the emperor said, “Also, I would like to announce that I am providing first round venture capital for entrepreneurs who are developing applications for the New New Web!”

At this, everyone in the crowd proclaimed, “Ah! Now we see it! There it is — it’s the New New Interweb!” And they began to rush forward to display their Powerpoint presentations.

And that is the story of the Emperor’s New Web.

Howto Add Your Xscreensavers To Gnome Screensaver

2006-07-25T00:00:00-07:00

The fully qualified directories in this particular “howto” are specific to SLED 10, and will undoubtedly be different on a different version of Linux.

Something you might notice on installing SLED 10 is that, like most distros which feature Gnome 2.12 or 2.14, xscreensaver has been partially or fully replaced by gnome-screensaver. In the case of SLED 10, xscreensaver was installed, but none of its screensavers were available; gnome-screensaver listed only a scant five or six options.

I spent some time tracking down how to make xscreensaver’s hacks available to gnome-screensaver, so here it is.

Each screensaver, for both gnome-screensaver and xscreensaver, has a config file. So to move files from xscreensaver to gnome-screensaver, we need to move not only the screensaver programs themselves, but also the config files.

Moving the screensavers is the easy part; all you’d need to do is:


cp -i /usr/lib/xscreensaver/* /opt/gnome/lib/gnome-screensaver/gnome-screensaver/

Yes, technically this code copies the screensavers, not moves them… but that’s okay. The -i switch is to make the process interactive; if any other the new screensavers has the same name as an existing one, it will as if you want to overwrite it, rather than just deciding for you. There should be only one such anomaly: popsquares. I chose not to overwrite it, as it works fine already and is probably exactly the same.

Next, you need to move the config files. The only problem is, xscreensaver config files are .xml files, and gnome-screensaver files are .desktop files.

It turns out that this is a problem with a ready made solution: our friends at Gnome have a script which will migrate our .xml files into .desktop files. For this to work, you’ll need 2 files:

migrate-xscreensaver-config.sh

xscreensaver-config.xsl

Just click the “download” links on the above two pages. I moved the two files to /opt/gnome/lib/gnome-screensaver/, but you can put them anywhere — they just need to be in the same place.

You’ll need to make migrate-xscreensaver-config.sh executable (it should go without saying, but you’ll need to execute the following command from whatever directory you put the files in):


# chmod +x migrate-xscreensaver-config.sh

That being done, all you’ll have left is:

# cd /opt/gnome/share/gnome-screensaver/themes/
# /opt/gnome/lib/gnome-screensaver/migrate-xscreensaver-config.sh /etc/xscreensaver/*.xml

That’s that. You will find (at least on SLED 10) that you need to restart X — just logging out of Gnome and back in should do it.

If you’re attempting to use these steps on a different version of linux, you may need to use find or locate to figure out the proper file paths to use. Enjoy.