Who Needs Photoshop? at Scotland on Rails from bantic on Vimeo.

Engineyard is hosting the rest of the Scotland on Rails videos.

Here are the slides. When the video becomes available I’ll put up a link to it. Update: The videos are now available. Here’s me talking.
Cory Forsyth Image Manipulation

I learned the nuts and bolts of how to add these scripts from Paint the Tiger, Carve the Dragon. Basically, you need to create an Applescript that has a “substitute()” function, put it in “/Applications/Adium.app/Contents/Resources/Scripts/System Statistics.AdiumScripts/”, and then edit the Info.plist file (at the same path) to contain the necessary information to tell Adium what to call your script, when to invoke it (what “%_” string to use), and the filename of the script.

Since I wanted to do some network calls and some fairly complicated parsing of those results, I delegated the heavy lifting to a Ruby script and had the Applescript simply execute that ruby script as a shell script. To use the script yourself, unzip this file. It contains an applescript called Politics.scpt and a directory called “politics” that includes the “politics.rb” ruby script. Copy both the applescript and the “politics” directory to “/Applications/Adium.app/Contents/Resources/Scripts/System Statistics.AdiumScripts/”.
You may want to try running the politics.rb file directly to ensure that it will work and you have all the dependencies you need. If anything’s awry, you’re probably missing the ruby gems hpricot or open-uri. The commands “sudo gem install hpricot” and “sudo gem install open-uri” should fix that.

Then edit the Info.plist file in the above directory, adding the text:

<dict>
   <key>File</key>
   <string>Politics</string>
   <key>Keyword</key>
   <string>%_politics</string>
   <key>Title</key>
   <string>Obama Politics update</string>
</dict>

Now, after you restart Adium, you should have the “Obama Politics update” option in your “Insert Script” menu when writing your custom away message. Just typing in %_politics directly should work as well. I don’t know how to control Adium’s refresh rate on the script, it seems to refresh every 15-30 seconds on its own.

Chris Wanstrath, parse tree

• Sake, rake tasks that you can use between different projects.
• Cheat — command line interface for looking up documentation. Like ‘man’ for ruby and rails methods.
• Ruby2Ruby (I can’t find the official homepage, that’s a placeholder). Looks very cool, but I am not 100% sure what it does other than self-document (?) your ruby code with ruby code. I have to play with this to figure it out.
• RingServer, RingyDingy — a way to do mapreduce type stuff using drb in ruby. I wonder if we can use this for tasks at outside.in

Ryan Davis, Hurting Code For Fun and Profit

• Code-writing ability increases non-linearly when you become a Ruby sadist/asceticist
• coined a new term: menturbating/mentorbating
• “Introspection-driven development”
• self-improvement: read 1 nerd book/month (12x the industry avg). c2.com , read 10-20ish smart blogs
• ignorance is not bliss. NYT article by Erica Goode
• wtf, coding horror and other idiot forums, trim the blogs in your newsreader, focus
• important/not-important, urgent/not-urgent. these form a quadrant. push towards important. the not-important and not-urgent stuff are useful at times, too, for fighting burnout. via 7 habits of highly effective people by covey. “do you want to be right, or do you want to be effective?”
• study something non-coding-oriented. push yourself. write more code, lots of it. junk code. write stuff to figure something out. quantity can be greater than quality (sometimes)
• “The function of the overwhelming majority of your artwork
  is simply to teach you how to make the small fraction
  of your artwork that soars.” from: “Art & Fear”
• Don’t be a sheep. challenge the status quo. Feel. Let your emotions flow. Have an opinion (but dont be an asshole).
• zentest, flog (complexity reported based on ABC metric, correlates to testing complexity. the scores are important relative to each other, not absolutely) & heckle — (love of good dev tools)
• vlad and image_science — (hate of complex code)
• use feedback. ask for it. listen to it. feed the feedback back. constantly refine.
• find your balance. between 0-100% action and 0-100% thought is your sweet spot. find that balance an dyou’ll be most of effective.
• ryan hates inject — why? (see the mailing list)
• heckle: runs your tests and mutates your implementations to verify that your tests are good. if youre mutated tests still pass after mutation, you missed an edge case
• enjoy hurting bad code and you’ll have less of it over time. eschew complexity.

Paul Dix, Collective Intelligence

• Slides are up at paul’s blog
• explicit versus implicit data. implicit happens as a result of other actions. scrobbling is an example. explicit makes you make choices (give ratings/grades/stars to things, etc.)
• types of recommendations — content-, user- and item-based. content is like other content, users are like other users, items are like other items.
• basic strategy: map data to a euclidean spaces, calculate similarity using a metric, and use similarities to recommend. represent the data as vectors.
• (I discovered confreaks just now. cool. I think goruco vids will be up there later.

Ezra Zygmuntowicz, Merb

• Merb looks really cool. I got tired of taking notes here so I just sat back and watched his talk. Next personal project I do is going to be in Merb.

I’d just about decided to find a Rails-ready instance on EC2 and start deploying my apps there. Until today.

Today Google App Engine was announced and I spent all morning daydreaming about how I could easily deploy stuff with it, and have a great excuse to play with a new platform to boot. That is, until I read the documentation closely and saw that the sandbox environment runs Python. Darn.

I’m still very excited about the idea. Al3x has a good post about the benefits and drawbacks.

It’s good to see the bar continuing to be lowered. Used to be that in order to have a blog you had to start an account with a hosting company, register a domain, and install MT or WP. Now, anyone is about 30 seconds away from a new blog at blogger. Likewise, if you wanted to create a web app you had to have a hosting account, create a database on it (at least they have an admin panel), and start writing. Now, with EC2, S3, App Engine, Scalr and so on, the hard work of setting up a database and finding a hosting provider is getting further abstracted away.

There are two good things happening here. App Engine and Scalr and EC2 are making scaling a more manageable problem, but they’re also first steps in making it really easy to launch an application for the first time, without having to deal with the sysadmin-style stuff. We’re closer to being able to write code on your local machine and push a button to deploy it live, no need for setting up an environment on some host, it will all be abstracted for you into the cloud so you can focus on creating something innovative.

We are also seeing more building-block type applications, like Ning, that are trying to abstract away the code-writing in addition to the sysadmin-ing.

There are a lot of people with creative ideas. And there are some people with the technological fluency to use unix, install databases, and write code. Innovative startups used to happen at the intersection of those two groups. These new tools make that second skill set a lot less necessary. And the first skill set will become a lot more valuable.

Here’s the function I created to do that check:

 def self.table_exists?(name)
    ActiveRecord::Base.connection.tables.include?(name)
  end

And here’s the new first line of self.up:
drop_table :table_name if self.table_exists?("table_name")

Clean.

A few years ago, Google created a really clever job posting (more here). They put up banners and bought billboards in areas of the country with lots of smart mathematicians, such as Harvard Square in Boston, that said: “(first 10-digit prime in consecutive digits of pi).com”.

If you calculate that 10-digit number and combine it with “.com” to create a domain name, the website that comes up challenges you to another puzzle. Eventually, after answering several challenges correctly, you’re directed to a page that invites you to apply to work at Google. Pretty clever.

I found out about it a few years too late, but took the challenge upon myself anyway and wrote a perl script that calculated the correct answer. On this Pi Day I am endeavoring to code up a solution again, using my new favorite programming language, Ruby, mostly just for fun but also to see if my abilities have improved any since the last time. Unfortunately, the blog post I wrote about my perl solution has somehow been lost to the winds of /dev/null, so I can’t compare the code outright. But I will say that this time it only took me about 10 minutes to code up this solution:

#!/opt/local/bin/ruby

module Prime
  def prime?
    return false if self % 2 == 0 # divisible by 2

    # check odd divisors from 3 to the square root of this number
    (3..(Math.sqrt(self))).step(2) {|i| return false if self % i == 0}

    # didn't find any divisors
    return true
  end
end

# mix the module into the bignum and fixnum classes
class Bignum
  include Prime
end
class Fixnum
  include Prime
end

# digits of pi from http://www.eveandersson.com/pi/digits/
pi_digits_filename = "10000.txt" 

pi_digits = File.open( pi_digits_filename ).read
pi_digits.gsub!("\n","") # strip newlines
pi_digits.gsub!(".","") # remove the "." in 3.14...

# iterate 10-character strings
0.upto(pi_digits.length - 10) do |i|
  num = pi_digits[i,10].to_i
  if num.prime?
    puts num # found it
    break
  end
end

Update: Ok, it appears that the Google challenge was to find that prime in consecutive digits of e, not pi. Oh well. Next year I’ll do this exercise with whatever language is hot on 2/18.

Neat fact: I have a picture of Jason Fried of 37signals holding up a cardboard sign saying “Go Chronic!” (That’s the nickname for the coding team of Christian and Cory.)

Compare to PHP’s switch, which lets execution fall-through to every passing case until it finds a break. That’s just wrong. It’s so counter-intuitive. Sure, a veteran PHP programmer will have those breaks hardcoded into their fingertips, but that’s learned, not instinctual behavior. And yeah, you can get clever and take advantage of the cascading execution, but you do it at the expense of legibility. How many debugging hours have been spent chasing down forgotten breaks?

Ruby, on the other hand, does it right. The language doesn’t even give you the option of letting execution fall through. Less is more here. Less mental clutter and debugging, more natural, clean code.

Here’s the salient code:

pool = ["person1@email.address.com",
        "person2@email.address.com",
        "person3@email.address.com"]

avail = pool.dup
pairs = []

pool.each do |secret_santa|
  loop do
    index = (rand * avail.length).to_i
    recipient = avail[index]
    unless recipient == secret_santa
      avail.delete_at(index)
      pairs << [secret_santa, recipient]
      break
    end
  end
end

This generates a list of tuples (the variable pairs) that you can then iterate over, emailing out the results. Here's the full code (download here).

#!/usr/bin/ruby
require 'net/smtp'

PRINT_RESULTS = true # Print results to screen?
EMAIL_RESULTS = false # email the results?

pool = ["person1@email.address.com",
        "person2@email.address.com",
        "person3@email.address.com"]

avail = pool.dup
pairs = []

pool.each do |secret_santa|
  loop do
    index = (rand * avail.length).to_i
    recipient = avail[index]
    unless recipient == secret_santa
      avail.delete_at(index)
      pairs << [secret_santa, recipient]
      break
    end
  end
end

pairs.each do |secret_santa,recipient|
  from = "the_north_pole@northpole.np"
  from_alias = "santa"
  to = secret_santa
  to_alias = secret_santa

  sbj = "secret santa -- ho ho ho"
  msg = "You are #{secret_santa}. " <<
                  "Your secret santa recipient is: "<<
                  "#{recipient}."
  send_email(from, from_alias, to, to_alias, sbj, msg) if EMAIL_RESULTS
  puts "#{secret_santa}  => #{recipient}" if PRINT_RESULTS
end

def send_email(from, from_alias, to, to_alias, subject, message)
	msg = <
To: #{to_alias} <#{to}>
Subject: #{subject}

#{message}
END_OF_MESSAGE

   Net::SMTP.start('localhost') do |smtp|
      smtp.send_message msg, from, to
   end
end