heyPanda

When You're Serving 10-60MM Requests Per Week...

mason — Thu, 25 Jun 2009 02:50:35 -0400

... don't forget to cache.

Yes, even if you're using Rails Metal.

Especially if you're using Sinatra as your Metal.

No, Sinatra doesn't have a built-in request cache like Rails has an action-cache.

Yes, it's easy to build your own.

Maybe I'll post the code once it's cleaned up.

Until then, take heart in the fact that it's easy, and you should just try it.

Too Many Twitter Friends? Kill Stale Accounts.

mason — Thu, 26 Mar 2009 13:54:10 -0400

Noticed my friends list was getting a bit out of control. Decided to write a quick script to kill people who haven't updated in X days.

Relies on Bricklayer and ActiveSupport.

require 'bricklayer' # http://github.com/heypanda/bricklayer/tree/master
require 'active_support' # to get the to_datetime function
require 'json' # to parse the twitter response
require 'creds' # because I'm paranoid

class TwitterTrimmer < Bricklayer::Base
  authenticate USERNAME, PASSWORD
  service_url "http://twitter.com/statuses/friends.json" do |r|
    JSON.parse(r)
  end
  remote_method :get_friends

  service_url "http://twitter.com/friendships/destroy/{id}.json" do |r|
    JSON.parse(r)
  end

  remote_method :destroy_friend, :required_parameters => [:id], :request_method => :delete


  def stale_friends(days = 5)
    f = self.get_friends
    stale = []
    comparing = days.days.ago
    f.each do |s|
      ls = s["status"]
      if s["status"] && s["status"]["created_at"]
          last_time = s["status"]["created_at"].to_datetime
          stale << s if last_time < comparing
      else
          stale << s
      end

    end
    stale
  end

  def destroy_stale_friends(days)
    stale = self.stale_friends(days)
    puts "Deleting..."
    stale.each do |s|
      puts self.destroy_friend(:id => s["id"].to_s)["screen_name"]
      sleep(0.5) # keep twitter happy
    end
    puts "Done"
  end

end

require 'pp'
tt = TwitterTrimmer.new
# List stale friends
# tt.stale_friends(5) # People who haven't updated in 5 days
# puts tt.stale_friends(5).collect{|f| "http://twitter.com/#{f["screen_name"]}"}.join("\n")

# Delete stale friends:
tt.destroy_stale_friends(10)

I Can See Why Erlang Doesn't Seem To Care So Much About Regular Expressions

mason — Sat, 21 Mar 2009 12:11:52 -0400

One of the main things on my mind as I learn more about Erlang is how dependent I've become on all the niceties Ruby provides. Yes, I know that's a bit like always talking about your ex while trying to court a lovely lady you met at a cafe. But it feels valid.

A lot of my miscellaneous Ruby scripts do text processing. Rip though this data, find this data, run this calculation on this data, show me this data in a way I can understand. That usually means a few well-placed regular expressions, and a whole lot of string manipulation. Thanks to Ruby's incredibly terse syntax, I tend to lose myself in how it's done, and just rely on it being done. I type this, I get this.

If you do something a certain way for too long, you begin to think it's the only way. The most elegant way. The Matz Way. Different becomes bad. But it's not bad. Just... different.

So when I look around and notice that people in the Erlang community don't rely as heavily on regular expressions, I automatically assume they're stupid. If Ruby developers are humble enough to recognize their need for RegExes, then so should Erlang developers, dammit!

After thinking for a while, I wrote the following:

-module(my_matcher).

-compile(export_all).

whats("foo-" ++ What) ->
  io:format("foo handler says: ~p~n", [What]);
whats("bar-" ++ What) ->
  io:format("bar handler says: ~p~n", [What]).

and ran it:

[my_matcher:whats(M) || M <- ["foo-bark", "bar-woof", "foo-mreow", "bar-meow"]].

No surprise here. Erlang calls the appropriate version of whats/1 by matching the parameter being passed in. Wait... wait... you can do that? HOLY BALLS! Hell yes you can. Such is the power of pattern matching in Erlang. Combined with a form of fusion, you now have all the power you need. (Yes, I watched The Matrix with my girlfriend last night. Sue me.)

How I Spent Friday From 3AM to 5AM

mason — Fri, 20 Mar 2009 06:32:35 -0400

I was playing with Erlang tonight, experimenting with the language and getting a feel for "the process". As a toy problem, I decided it would be fun to parse some HTML, and look for specific attributes in specific types of tags.

First... it took me a hell of a long time to find a good HTML parser. I began with erlsom, but it proved too picky for me to use with HTML from "the wild, wild Internet", forcing me to first pass my content through an HTML cleaner. Boo. Java.

So I looked around more, and discovered MochiWeb has a reasonable implementation. After downloading and compiling a couple files, I was good to go.

So now I had a bigass tree. Crap. Let's do some searching!

-module(tree_walker).
-compile(export_all).

get_file_contents(File) ->
  {ok, Xml} = file:read_file(File),
  Xml.

finding(Pattern, Attribute, Tree) when is_binary(Attribute)->
 GetAttr = fun(Found) ->
    {Pattern, Attributes, _} = Found,
    [{Attribute, FoundAttribute} | _] = lists:filter(fun(Attr) -> case Attr of {Attribute, _} -> true; _ -> false end end, Attributes),
    binary_to_list(FoundAttribute)
  end,
  [GetAttr(M) || M <- finding(Pattern, [Tree], [])];

finding(_, [], Collected) ->
  Collected;

finding(Pattern, [Next | Siblings], Collected) ->
  case Next of
    {Element, _, Children} ->
    case Element of
      Pattern ->
        finding(Pattern, Siblings ++ Children, Collected ++ [Next]);
      _ ->
        finding(Pattern, Siblings ++ Children, Collected)
    end;
  _ ->
    finding(Pattern, Siblings, Collected)
  end.

Woo! Now I'm able to do something like this:

Content = tree_walker:get_file_contents("input.html").
Tree = mochiweb_html:parse(Content).
[io:format("Link to: ~p~n", [M]) || M <- tree_walker:finding(<<"a">>,<<"href">>, Tree)].

Super. finding does a breadth-first search of the nodes, returning a list of values corresponding to the attribute of the element I specify. Yes, it's brittle. This works because I'm always searching for the href attribute, which is present in every link in my sample HTML. If I'd been searching for, say, div.id, it would die rather pathetically, because not every div has an id attribute. But... handling that is as simple as tossing in a few case ... of statements, praying to a tiki god, and sacrificing a small animal, so I'm not too worried about it.

Rofl.

Also played with erlectricity a bit. Very cool. Sadly, I don't think the awesomeness of Ruby is worth the expense of having two language VMs running. But I could be wrong.

Writing Conveyor Clients Using Bricklayer

mason — Sun, 15 Mar 2009 03:36:34 -0400

Bricklayer, for the uninitiated, is a library I wrote for quickly writing clients to RESTful web services. I banged out most of the code on a lazy evening, and proceeded to let it rot. It did what I wanted, which was... enough to allow me to write an article about it.

Conveyor is, as its creator Ryan King calls it, "like TiVo for your data". It's a "distributed, rewindable, virtual queue server" that sits behind a RESTful HTTP interface. Since I'm using it for a project, I thought, "Heck, let's write a Bricklayer client for it". I ended up having to make several changes to Bricklayer to create a client that worked with Conveyor's Mongrel-backed system. Namely, Conveyor looks directly at the query string for parameters, whereas Bricklayer typically passed them as form data. Additionally, Conveyor spits you the data exactly as you passed it originally, so I wanted an easy way of posting data without using form params at all.

Anyhow. On to some code!

require 'rubygems'
require 'bricklayer'
require 'json'
class CrawlerEnqueuer <  Bricklayer::Base
  service_url "http://localhost:8011/channels/to_crawl"

  DDP_TRANSFORMER = Proc.new{|obj|
    obj.to_json
  }

  remote_method :enqueue, :direct_data_post => DDP_TRANSFORMER,  :request_method => :post, :headers => {:Date => Proc.new { Time.now.to_s}}, :wants => :object do |obj|
    obj.get_fields("Location")[0]
  end
end

c = CrawlerEnqueuer.new
puts c.enqueue({
  :url => "http://heypanda.com",
  :queued_at => Time.now
}) # puts /channels/to_crawl/#{id}

Crazy! What we have here is a simple script that queues up a URL to be crawled at a later date. service_url is my Conveyor endpoint. I define a remote_method called enqueue. Because I've specified a Proc for the direct_data_post param, this method will take one parameter, which will be passed to that Proc. In the future, this may take multiple parameters. I'm undecided. The request_method will be post. headers is also new. If any values in the headers hash respond to call, it will be executed before the request is sent. This allows me to have Time.now be executed at the time of the call instead of when this file is loaded by Ruby. Because I need access to the response headers, I've specified that the response handler wants the :object. If I didn't specify this, the method block would be passed the response body, which for Conveyor post responses is empty. The return value of the enqueue method will the path of the resource I just posted.

When I call c.enqueue, the hash I provide is passed to the DDP_TRANSFORMER Proc. The return value of this Proc is posted as the requests body. When posting the body directly, any additional post parameters are ignored.

So that's the CrawlerEnqueuer. Let's look at the CrawlerDequeuer!

require 'rubygems'
require 'json'
require 'bricklayer'

class CrawlerEnqueuer <  Bricklayer::Base
  service_url "http://localhost:8011/channels/to_crawl?next"
  remote_method :dequeue, :request_method => :get do |response_body|
    JSON.parse(response_body)
  end
end

c = CrawlerEnqueuer.new
require 'pp'
pp c.dequeue

This one isn't as complicated. The endpoint I've specified returns the next message in the queue. Because I know it will be a stream of JSON, my response handler in dequeue merely calls JSON.parse. The return value of this response handler will be the return value of the method, so calling c.dequeue will, in this case, return a hash with :url and :queued_at keys.

Short and sweet. Two functional, customized Conveyor clients in a few lines of code. Superfly.

Determining If Your Script Was Executed Or Included

mason — Fri, 13 Mar 2009 15:31:53 -0400

This is an incredibly easy tip, one that I should have remembered (and indeed, recognized once I saw it).

If you have a script which you would like to treat as both a library (if included) or a working script (if run from the command line), then the following bit of code will be useful to you:

class MyCoolLibrary
  def bar
    "bar"
  end
end

if __FILE__ == $0
  # script start point
  foo = MyCoolLibrary.new
  puts foo.bar
end

Now, if you run this script using ruby my_cool_library.rb, you'll see it output "bar", but if you merely include this script using require 'my_cool_library', you won't see any output.

TADA! Hopefully this saves people some Google Hours.

Comparing Object Speed Versus... Object Speed

mason — Wed, 11 Mar 2009 09:47:29 -0400

My esteemed pseudo-former-coworker Ian Eure (now at Digg) made a post on the performance difference between PHP objects and associative arrays. Curious, I decided to recreate the test in Ruby.

It's not completely apples-to-apples, though, since everything in Ruby is an object, including hashes (Ruby's equivalent of associative arrays). Still, this does shed some light on the overhead of instantiating objects and assigning values.

For my two files, I used the following code (keeping @ieure's iteration count), running it on MRI v1.8.6:

# objectspeed.rb
class Foo
  attr_accessor :a, :b
end
1000000.times do
  x = Foo.new
  x.a = 'a'
  x.b = 'b'
end

# hashspeed.rb
# Keep the class declaration in there, so we don't have a variable for the test. Ian took advantage of the fact that you can assign object attributes without declaring them. Ruby has no such thing.
class Foo
  attr_accessor :a, :b
end
1000000.times do
  x = {}
  x[:a] = 'a'
  x[:b] = 'b'
end

And the results:

$ time ruby objectspeed.rb ; time ruby hashspeed.rb 

real    0m2.099s
user    0m2.048s
sys 0m0.020s

real    0m1.837s
user    0m1.802s
sys 0m0.019s

Surprising. Using the "real" time, PHP beats the pants off Ruby for the hash case, since associative arrays are primitives in PHP. However, Ruby performs better with objects. What's going on under the covers that PHP does so poorly?

I've Outsourced My Blog Comments to Facebook

mason — Tue, 03 Mar 2009 17:48:31 -0500

If you haven't noticed, the bottom of each page now contains a comment box!

I originally avoided implementing comments because I didn't want to deal with moderating them. Or writing the system to moderate them (if you remember, this blog is home-cooked). Plus, my subscribers are only in the double-digits, and they're not a very verbose crowd.

But since Facebook has taken the work out of it, I thought "hell, why not". If spam becomes a problem, I'll make people sign up. For Facebook. Because I'm evil like that.

The Accidental DSL, or, Why Ruby Is So Damn Great

mason — Tue, 03 Mar 2009 17:36:56 -0500

An old friend recently connected with me on Facebook. As per protocol, his first wall post consisted of the usual "What have you been up to?" Since he's also a programmer, I replied with:

forever do
  work :hard
  play :hard
  sleep 5.hours
end

It was supposed to be a joke, but after posting it I realized that I needed to implement it (if only for completeness). And in Ruby, that's quite simple.

class Fixnum
  # returns seconds
  def hours
    self * 3600
  end
end

def forever
  while true
    yield
  end
end

def work(intensity)
  puts "You worked #{intensity}!"
end

def play(intensity)
  puts "You played #{intensity}!"
end

alias :old_sleep :sleep
def sleep(time)
  old_sleep(time)
  puts "You slept for #{time} seconds!"
end

So let's go over this, shall we?

class Fixnum
  # returns seconds
  def hours
    self * 3600
  end
end

This code enables me to write 5.hours. Since Ruby allows you reopen classes, adding methods to integers is simple. This is quite similar to the way ActiveSupport (one of the gems that makes up Rails) adds helpers such as 5.megabytes. The difference is that in ActiveRecord, these methods are defined in modules and included into Fixnum as Mixins. For a more thorough explanation, you can reference my tutorial on Rails Plugins and Metaprogramming.

def forever
  while true
    yield
  end
end

Here we define forever, which does nothing but loop forever, yielding control once per iteration to the block passed to the method. A more explicit way of writing this would be:

def forever(&block)
  while true
    block.call
  end
end

And our last two methods:

def work(intensity)
  puts "You worked #{intensity}!"
end

def play(intensity)
  puts "You played #{intensity}!"
end

These are your run-of-the-mill method definitions. Since I am defining them at the top-level of the script (and not within an object definition), they are effectively "global". We are actually defining this method within the context of an instantiated Object, where all loaded code runs. If you don't believe me, write a script that contains nothing but puts self.class, and you'll see that the output is Object.

alias :old_sleep :sleep
def sleep(time)
  old_sleep(time)
  puts "You slept for #{time} seconds!"
end

sleep is a bit different. The Kernel module defines a sleep method, and that module is included into the run instance. If we simply define sleep, we'll clobber our access to the original sleep method. alias allows you to define an alternate way of referencing a method, so before I clobber it, I give it the handle old_sleep.

This toy DSL doesn't really do anything useful. It does, however, illustrate how friendly Ruby can be. This is also an example of "Behavior Driven Development" (BDD). We first define how we want the interface to look, and then we write the functionality to make it work. If I were HCBA (Hard Core Bad Ass), I would use something like RSpec or shoulda to help me keep track of which expectations I have and haven't implemented.

Now... go make something fun.

Being Stupid with Ioke

mason — Sat, 28 Feb 2009 04:28:13 -0500

I was reading Hackers and Painters on my flight from Orange County to Chicago today, and came across the bit where Paul Graham reminisces about past programming languages. The example he gives is something like:

add x to y giving z

I wondered what it would be like to work in such a strange language. Of course, the idea is to make the code as English-like as possible, but in return it gives wordy descriptions to what should be simple expressions.

Since one of my goals is to play more with Ioke, I wrote a simple bit of code to re-create(to some degree) this syntax for me to play around with. That's not to say the following code is in the Ioke Style, whatever that may be. I just wanted to mess around with building something that, y'know, ran (and had a Macro in there):

    Summer = Origin mimic do(
      addends = []

      initialize = method(num,
        self addends = []
        self addends << num
        self
      )

      to = method(num,
        self addends << num
        self
      )

      giving = macro(
        result = self addends inject(+)
        len = call arguments length
        case(len,
          1,
          call ground cell(call arguments[0] name) = result
          ,
          0,
          result
          )
      )

    )

    Setter = Origin mimic do(
      var = nil
      initialize = method(var, self var = var)
      to = macro(
        call ground cell(self var) = call evaluatedArguments[0]
      )
    )

    Divider = Origin mimic do(
      dividend = nil
      divisor = nil

      initialize = method(num, self dividend = num . self)

      by = method(num, self divisor = num . self)

      giving = macro(
        quotient = self dividend / self divisor
        len = call arguments length
        case(len,
          1,
          call ground cell(call arguments[0] name) = quotient,
          0,
          quotient
          )
      )
    )

    ; Top level, so I can call them from ground...
    add = method(num,
      Summer mimic(num)
    )

    ; I'm redefining set. Bad me.
    set = macro(
      Setter mimic(call arguments[0] name)
    )

    divide = method(num, Divider mimic(num))

    set(x) to(1)
    ; sets x = 1 in the caller context, i.e.,
    x println ; => 1

    set(y) to(2)
    ; Sets y = 2 in the caller context,
    y println ; => 2

    add(x) to(y) giving(z)
    ; sets z = x + y in the caller context,
    z println ; => 3

    divide(8) by(2) giving(a)
    a println ; => 4

Of course, this turns into madness when you try to nest things:

    divide(set(x) to(add(5) to(6) giving)) by(x) giving

... which, of course, is 1.

Extending Your Models Using Custom Plugins, Or, A Brief Introduction to Metaprogramming

mason — Fri, 20 Feb 2009 18:52:04 -0500

Repeat after me: copying and pasting is evil. Learn how to extract common functionality with custom Rails plugins and metaprogramming.

Overview

Rails developers work with plugins every day. They're the preferred method of sharing functionality between applications. They're also a convenient way of extending ActiveRecord's functionality across your models without duplicating code. In this tutorial, I'll walk you through the process of creating a custom Rails plugin for use in your applications.

Step 1: Identify a Need

Imagine you're working on a blog application. You'd like the ability to use markdown to write your content. You settle on the Maruku gem because of its excellent markdown parsing. You settle on something like the following:

  class Post < ActiveRecord::Base

  before_save :convert_body_html

  # ...

  private
  def convert_body_html
    self.body_html = self.body.blank? ? "" : Maruku.new(self.body).to_html
  end

  end

There! Now, before your Post model saves, it sets Post#body_html to the HTML version of Post#body.

A little while later, you're writing a generic Page model to handle content on your site, and find yourself doing the same thing:

  class Page < ActiveRecord::Base

  before_save :convert_content_html

  # ...

  private
  def convert_content_html
    self.content_html = self.content.blank? ? "" : Maruku.new(self.content).to_html
  end

  end

That code looks strangely similar to what you did for the Post model. Being the savvy web developer you are, you realize there's probably a better way to handle this: behavioral decorators.

Behavioral Decorators: The Magic Behind ActiveRecord

If you've ever built a Rails application with more than one model, you've already used decorators. Consider the models for a simplified blogging system:

  class Post < ActiveRecord::Base
    has_many :comments
    belongs_to :user
  end

  class Comment < ActiveRecord::Base
    belongs_to :post
    belongs_to :user
  end

  class User < ActiveRecord::Base
    has_many :comments
    has_many :posts
  end

Each of these relationship descriptions - has_many, belongs_to, has_one (not shown), and has_and_belongs_to_many (not shown) - are behavioral decorators. The best way to think of them is as class methods defined in ActiveRecord::Base, since they are accessible within the scope of the class declaration. In reality, they are defined in modules and extended into the class definition. This magic isn't something specific to Rails; it's one of the many tools Ruby makes available to you, which makes this type of programming (sometimes called metaprogramming) common among the Ruby community.

Designing Your Behavioral Decorator

In our imaginary system, we have two models, Post and Page, which need similar markdown functionality. Using behavioral decorators, we'd like to achieve something like this:

  class Post < ActiveRecord::Base
    marukuable :body
  end

  class Page < ActiveRecord::Base
    marukuable :content
  end

Why did I choose marukuable? In the early days of Rails, it was common practice to prefix these decorators with acts_as_ and end them with a word ending in "-able". This allowed you to read the class definition by saying something like "That blog acts as commentable" or "That blog acts as taggable". These days, you see fewer acts_as_ decorators, but I'm keeping the -able as a homage to our roots. You can name it whatever makes sense to you (just be sure to substitute your method name for mine below). But first, some background...

Metaprogramming 1: A Brief Introduction to Ruby Modules

Ruby is an object-oriented programming language. If you didn't know that by now, I suggest you put this tutorial on pause and find an article on object-oriented programming (OOP).

One aspect which sets Ruby apart from other OO languages, such as C++ and Python, is that Ruby only supports a single-inheritance model. This means that while any class can have multiple child classes which extends its functionality, each class can only have one parent class. While this makes the inheritance tree nice and pyramid-shaped, it introduces question marks when you want to add shared behavior to multiple classes which don't share the same parent. It's not always apparent how far up the inheritance tree you should walk before adding a feature, and sometimes leads to the creation of unnecessary "intermediary" classes which don't always make sense. Technically, you could define the functionality by re-opening the Object class, but since all classes inherit from Object, that's considered taboo, as it liters all objects across your system.

Ruby makes up for this drawback of single-inheritance with modules, also referred to as Mixins. Mixins allow you to (quite literally) "mix in" functionality to different classes, as seen with the following snippet:

  module Slammable
    def slam
      "SLAM!"
    end
  end

  class Window
    include Slammable
  end

  class Door
    include Slammable
  end

  door = Door.new
  puts door.slam # => SLAM!

  window = Window.new
  puts window.slam # => SLAM!

Running this code spits out "SLAM!" twice. By calling include, we turn Slammable's method definition into an instance method for both Door and Window. We can use another method, extend to mix in the module methods as class methods:

  module Bar
    def bar
      "bar!"
    end
  end

  class Foo
    extend Bar
  end

  puts Foo.bar # => bar!

This code is functionality equivalent (in terms of output) to the following:

  class Foo
    def self.bar
      "bar!"
    end
  end

  puts Foo.bar # => bar!

One thing many people don't realize: because this is defined as a class method, it's available outside other class methods, within the class definition:

  puts class Foo
    def self.bar
      "bar!"
    end

    bar

  end # => bar!

In practice, you probably shouldn't be puts-ing a class definition, but I do it here to prove a point. After you define Foo.bar, you can call it from within the class definition. Since it's the last thing evaluated, it's also the return value, which is why this outputs "bar!". In fact, that bar call looks a lot like ActiveRecord's belongs_to!

Metaprogramming 2: Evaluating Strings as Code

Due to its incredibly dynamic nature, Ruby is able to not only add code to classes at runtime, but also execute arbitrary strings as code. This, in combination with Mixins, makes Ruby incredibly powerful (if used wisely). Consider the following code:

  class Foo
    def self.define_my_method
      class_eval <<-EOD
        def bar
          "bar"
        end
      EOD
    end
  end

  f = Foo.new
  puts f.respond_to?(:bar) # => false
  Foo.define_my_method
  puts f.respond_to?(:bar) # => true
  puts f.bar # => bar

Here we instantiate a Foo object, and ask if it has a Foo#bar method. The first time, it says no (false). We then call Foo.define_my_method, which defines Foo#bar using a string as the source of the code. Now asking our instance yields yes (true), so we go ahead and do it, outputting "bar".

You now know everything you need to create our "marukuable" plugin. Let's get started!

Generating The Plugin With `script/generate`

If you've ever opened your vendor/plugin directory, you may have been overwhelmed with all the files and folders inside each individual plugin's directory. Don't worry. Rails provides a generator to get you started. Inside your project directory, type the following in your shell (ignore the dollar sign):

  $ ./script/generate plugin marukuable

Rails will spit back the following at you:

  create  vendor/plugins/marukuable/lib
  create  vendor/plugins/marukuable/tasks
  create  vendor/plugins/marukuable/test
  create  vendor/plugins/marukuable/README
  create  vendor/plugins/marukuable/MIT-LICENSE
  create  vendor/plugins/marukuable/Rakefile
  create  vendor/plugins/marukuable/init.rb
  create  vendor/plugins/marukuable/install.rb
  create  vendor/plugins/marukuable/uninstall.rb
  create  vendor/plugins/marukuable/lib/marukuable.rb
  create  vendor/plugins/marukuable/tasks/marukuable_tasks.rake
  create  vendor/plugins/marukuable/test/marukuable_test.rb
  create  vendor/plugins/marukuable/test/test_helper.rb

The files we'll be working with are vendor/plugins/marukuable/init.rb and vendor/plugins/marukuable/lib/marukuable.rb. Crack open marukuable.rb and enter the following:

  module Marukuable
    def self.included(base)
      base.extend(ClassMethods)
    end

    module ClassMethods
      def marukuable(name)
        before_save "convert_#{name}_to_markdown".to_sym
        class_eval <<-EOC
          def convert_#{name}_to_markdown
            self.#{name}_html = self.#{name}.to_s.strip.blank? ? "" : Maruku.new(self.#{name}).to_html
          end
          private :convert_#{name}_to_markdown
        EOC
      end
    end
  end

And in init.rb, enter:

  ActiveRecord::Base.send :include, Marukuable

Most of this should be clear. init.rb is the file which gets loaded once (and only once) when your start your server or initialize a console session. You may have figured this out before if you've ever installed a plugin and had to restart your development server; unlike your application code, vendor code isn't reloaded on each request in development mode.

Let's tackle the process in order:

Rails loads your init.rb file.
ActiveRecord::Base includes the Marukuable module.
Marukuable.included is called, passing ActiveRecord::Base as the base param.
ActiveRecord::Base extends the methods in the ClassMethods module, which makes marukuable available as a class method of ActiveRecord::Base, as well as its children classes.

This allows us to use marukuable within the class definition of our models, as before:

  class Post < ActiveRecord::Base
    marukuable :body
  end

  class Page < ActiveRecord::Base
    marukuable :content
  end

When marukuable is called, it registers a before_save callback (an instance method), which we define just below using class_eval. We're able to call before_save directly because marukuable is executed in the context of the class definition. If our plugin called for it, we could also call other class methods, such as table_name and find.

Our marukuable method takes one parameter: the name of the column we want marukuable. Using this name, it defines a private method in the pattern "convert[name]to_markdown". In the case of our Post class, this will be convert_body_to_markdown. For Page, it will be convert_content_to_html. This method merely sets our [name]_html content to the Maruku'd version of [name] (or an empty string, if there's no content). Finally, we set our newly created instance method as private, since only our callback needs to know about it.

To use this code, just make sure your posts table has both a body and body_html column (probably using a text type). Similarly, your pages table should have content and content_html. And there you have it! A fully-functional, reusable Rails plugin!

An Exercise For the Reader

For brownie points, modify marukuable so it only defines the method if it doesn't exist. (Hint: Ruby has a class method, Object.instance_methods, which returns an array of instance method names as strings.)

Tweet Like a Sailor Day!

mason — Tue, 10 Feb 2009 17:28:41 -0500

So. Even though I'll probably be only one of three people who actually have the initiative to swear in every tweet, I've decided to declare tomorrow, February 11, Tweet Like a Sailor Day (TLSDay). This means every tweet should have some form of foul language, sexual innuendo, or awkwardly non-PC spin on it.

If you're against swearing, feel free to fall back on crafty insults from yesteryear. Sailors have been around a long time. There's no shortage of verbiage at your disposal.

Have a great day tomorrow. Unlike today. Which was long and hard. That's what she said.

(P.S. - Feel free to tag your inappropriate tweets #TLSDay. Y'know. So future employers know you were just taking one for the team.)

Random Saturday at Bucketworks

mason — Sat, 24 Jan 2009 17:23:26 -0500

If you're viewing this on an external site, click through for the video.

So, Io is pretty cool

mason — Wed, 31 Dec 2008 00:15:38 -0500

So, introspection and dynamic class creation are pretty easy in Ruby. Very easy, actually.

I came across Io a couple weeks ago, and recently found a little time to play around.

someType := "Person"
someSlot := "name"
Object setSlotWithType(someType, Object clone)
n := Object getSlot(someType) clone
writeln(n type)
# ==> Person

Pretty simple. As _why pointed out, Io's introspection capabilities and run-time modality are pretty bomb. This example here only touches the surface.

No Time Like the Present

mason — Sun, 30 Nov 2008 08:03:45 -0500

Layoffs, bailouts, scandal, Wall Street, Main Street. ARE YOU AFRAID YET? I'm not. Not yet, anyhow. A lot of my friends are either looking for work, hate their jobs and want to quit, or are afraid of losing their jobs due to the recent "economic slowdown". (Keep in mind–I'm a youngin' of only 22 years, so most of my friends are still in college or recently graduated.) When I tell them to just do something instead of complaining, I'm greeted with empty stares. OMFG R U SERIOUS?! IN THIS ECONOMY?! Calm down, folks. Until our dollar bottoms out, there's no reason you can't shake things up a little, and when it does, it won't matter if you have a job or not: your money will be worthless. Okay, that sounds a little doomsday-ish, but the point is that we seem to be petrified by the fear of "what if". This is nothing new, but it's now accepted. We're fearing fear. Snap out of it, dummy.

Why I'm Jobless and Don't Care

I don't have a "normal" job. So far, work as a contract web developer seems bountiful. I can't waste money like I did when I had a 9-5, but that's probably a good thing. It's taught me to tighten my belt (and also caused me to become something of a hermit, but really that's my own fault). I'm not advocating that you quit your job (but you can, and you should follow that link if you want to). What I *am* doing is suggesting that there are more ways to make money than working for the man. There is a misguided notion that you have to be a MEGA HUGE SUCCESS to make cash. Absolutely not true. There's a dirty little secret to making money, only it's not so dirty, and it's not to little. If you want to hear the message with your own ears, check out DHH's talk at Startup School 08.

Strangely, People Are Willing to Pay

I came across DesignFTP via Twitter. After viewing the screencast, I immediately recognized the software stack. DesignFTP is, it its core, Rails + SWFUpload, both great pieces of Open Source software that I've used many many times. I've effectively created DesignFTP half a dozen times in the course of my development career, and it never occurred to me to productize and monetize it. Kudos to Chris for making that connection. With over 500 customers already using the service, it's apparent that there's a demand, if only a small one.

But What is Small?

Facebook has tens of millions of users. MILLIONS I say, MILLIONS! But do you need millions? If you're trying to quit your day-job, don't you just need enough to pay your salary? I think that's a reasonable milestone. So how many users do you need?

It's simple math. And if you're one of my "poor friends" (I am my own poor friend), it's also very modest math. If you can get by with $40,000 a year, take that number and divide it by twelve months. And then, just find a happy balance between cost vs. volume. If you have a monthly subscription service that you think is worth about $15/month, then you need about 225 customers paying you every month. In a world where millions of people are only a few clicks away, 225 people is not a lot.

But It's Not Limited to Software

But what if you're not a geek like myself? Remember, the world existed before the Internet. Take those offline ideas and bring them online. Go start your own clothing brand. Seriously. T-shirts are a multi-billion dollar industry. And you don't have to be the next Threadless. Educate yourself, start small, and grow as you go. If there's one thing I know, it's that few people are so vain as the American people. I guarantee that they'll keep buying those designer t-shirts, even as their bank is chasing them down for overdraft fees.

In Closing...

So if you want to escape the rat-race, work for yourself, take super-long lunch hours and stay up late without having to worry about being up at the crack of dawn, and not starve for it, then sit down with a pen and a pad, write down some ideas, and attack. Time will tell if your idea was good. And even if it's not stellar, there has to be at least 225 people who think like you. ;-)

For a more thoughtful and intelligent version of what I've said here, check out Paul Graham's article, Why to Start a Startup in a Bad Economy.

Another Example of Mac OS X Winning

mason — Sun, 09 Nov 2008 04:35:11 -0500

There I was... with a mess of windows on my desktop. I wanted to move a window in the background without my foreground window losing focus.

"Huh. If I were the designer behind this fabulously gorgeous interface, I would probably... press down Command while dragging title bar of the background window," I thought.

There was silence for a moment, as I pondered the likelihood of this actually working. Coincidentally, my music stopped as the current track completed.

Just as Björk's ghostly voice faded in, I pressed Command, and clicked.

And much to my satisfaction, the foreground window stayed in the foreground, and I began dragging the background window. I was so satisfied, I felt it must be recorded in this blog.

When I discuss with people the virtues of Mac OS X over Windows, my number one reason is this: OS X behaves according to expectation, rather than training. The Windows experience is incredibly broken; we are trained how to overcome the broken paradigms and quirky behavior. When Windows users try OS X, their biggest complaint is that nothing works as they expect. This is incorrect. Nothing works as they've been trained for it to work. If you empty your cup, and approach it without expectations, you'll find it actually behaves quite naturally.

It's unfortunate that so many people have been brainwashed to just "live with" fighting their computers. What's more unfortunate is many of Window's current (and likely future) innovations merely consist of ways to make their OS work in ways it should have from the beginning.

Microsoft Dumps Money on Vista Advertising, Development Division Suffers

mason — Sat, 08 Nov 2008 22:25:08 -0500

I saw the following advertisement while reading a Merb tutorial on DevX:

It's a little sad. Definitely doesn't say "multi-million dollar advertising budget" to me.

More and More, I'm Liking Flex on Rails

mason — Thu, 30 Oct 2008 06:26:39 -0400

Slowly chipping away at the administrative end of Kasumami. For whatever reason, Flex makes a lot more sense this time around. Am I smarter, or is *it* dumber?

(For those reading an imported feed, click through to the original source to view the screencast below.)

Algorithms In Real Life

mason — Mon, 27 Oct 2008 17:22:18 -0400

From lbrandy:

The Coffee Problem

So I woke up the other day, took my shower, got dressed and got on the elevator. My apartment complex has complimentary coffee in the lobby area (that’s why the rent is so high). This particular morning, when I got there, I noticed all of the little tags that tell me which dispenser was which were missing. So there I stood, with five identical coffee dispensers, virtually certain at least one of them was decaf. I don’t want decaf. What do I do?

If I was David Carruso or that dude from CSI: Las Vegas, I could have smelled the coffee, detected the bean’s nation of origin and deduced which was decaf based on the trade distribution of that country’s beans throughout the continental United States. Or maybe I could have used some nearby chemical MacGuyver style to determine which was caffeine. I’m just a dude needing caffeine, so I thought for a second, and then went for the middle one. How did they likely set these up? It seemed logical to me that since there were five, no more than two would be decaf. That seems like a good assumption. Furthermore, my “opponent”, being a rational person, likely put the decafs together, and on one end. That means the middle one is probably caffenieted.

Woo! A Moving Ball!

mason — Mon, 27 Oct 2008 07:49:04 -0400

A colleague and I have been discussing creating and selling a game for the iPhone. Since I'm still a n00b with regards to iPhone development, I'm mocking it up in Python. And re-learning Python. I present to you... the Moving Ball!