ones zeros majors and minors

Redis to the Resque

2009-11-03T00:00:00-08:00

SORT in Redis

2009-10-20T00:00:00-07:00

Now that Hurl is open source I thought I'd talk a bit about one of my favorite open source projects: Redis.

In Hurl we keep track of all the hurls you make, then show them to you on the "your hurls" page:

One of the more fun features is the re-ordering of your Hurls. If I click on the Twitter URL then hit 'Send,' I can re-issue the request and see the new response. The next time I visit the "your hurls" page, the Twitter URL will have moved to the top of my list:

This is probably pretty trivial in a SQL database, but Hurl uses Redis - a key/value database. How do we do this kind of sorting?

First let's talk about the three key/value types involved.

Hurls

A Hurl (in Redis) is a JSON object describing an HTTP request. Its key is the SHA1 of its value. This is convenient because it means we won't store duplicate values - we use Redis' SETNX command to only save the value if its key doesn't already exist - and probably won't get collisions.

Let's look at one of my Hurls:

$ redis-cli get da0838427e5fef02921ca2346f59480da2e9e5d9
{
    "auth": "none",
    "id": "da0838427e5fef02921ca2346f59480da2e9e5d9",
    "method": "GET",
    "url": "http://github.com/api/v2/json/user/show/defunkt"
}

Notice we store the id with the object. We simply compute the SHA before saving then stick it in the object - this is real handy for generating links and whatnot later on, after pulling the object from the db.

Your Hurls

Each user has a SET of SHAs which correspond to Hurls she has made. For example, here's mine (I'm user #59):

$ redis-cli smembers Hurl::User:v1:59:hurls
1. da0838427e5fef02921ca2346f59480da2e9e5d9
2. eebb1e7782d0eefb5e4a82c6ee6a3779497a8d14
3. 0efea52740ebf7c388884461bda6b4a4198c4fa2
4. 59de6e57bda2a07505987a8fa40317a535e769e3

If you and I both query "google.com," we'll both share a SHA in our Hurls list. And that's okay.

Recently Visited Hurls

Each time you make a Hurl request we store the timestamp. This is important for the sorting.

The timestamp is stored as a basic key/value pair. Here's one of mine:

$ redis-cli get Hurl::User:v1:59:hurls:da0838427e5fef02921ca2346f59480da2e9e5d9
1256015372

Simple Unix epoch format. The next time I hit "send" on that Hurl the timestamp will be updated.

Sorting

Now that we have all those pieces in place, sorting is cake. You can see the sort call we use in lines 53-57 of user.rb. Here's an expanded version of it:

hurls = redis.sort "Hurl::User:v1:59:hurls",
  :by    => "Hurl::User:v1:59:hurls:*",
  :get   => "*",
  :order => 'DESC',
  :limit => { :start => 0, :limit => 100 }

We're telling Redis to grab each member of SET Hurl::User:v1:59:hurls then find the corresponding timestamp value at key Hurl::User:v1:59:hurls:* (where * is replaced with the sha) then order the SET by those timestamps. Once it has the ordered list of shas, use each one as a key (again replacing the * with the sha) and return the values. Descending, first 100.

What we end up with is a sorted list of Hurl objects. Beautiful!

Here it is in Ruby pseudocode:

shas = {}

# Find each sha and its timestamp
redis.smembers("Hurl::User:v1:59:hurls").each do |sha|
 shas[sha] = redis.get("Hurl::User:v1:59:hurls:#{sha}")
end

# Sort the shas by their timestamp
shas.sort_by! { |sha, timestamp| -timestamp }

# Return a list of all the Hurls
hurls = shas.map do |sha, timestamp|
  redis.get(sha)
end

That's a wrap

I had a big "a-ha" moment when I finally figured out Redis' SORT. Not because it's complicated, nor because it uses concepts that were entirely new to me, nor because it's fast. No, the a-ha moment was when I realized how damned simple it was.

And not only is Redis' SORT simple - it made my app simpler, too. Just check out the first commit where we introduced SORT. We were able to cut out my complicated, hacky implementation using Redis' LIST type and replace it with something elegant.

Why do I think the SORT implementation in Hurl is elegant? Because it's calling into Redis, using existing features, and not re-implementing features (poorly) in app-land.

Always a win.

Hurl is Open Source

2009-10-20T00:00:00-07:00

Yep.

Check out Leah's post for details, including the Hurl homepage, Hurl Twitter, and, of course, the live Hurl site.

rake start

2009-10-16T00:00:00-07:00

I'm working on a Sinatra app that uses MongoDB. I'd love to start both Sinatra and MongoDB at the same time, then kill them at the same time, too. Luckily we can use Rake's multitask for this.

namespace :mongodb do
  desc "Start MongoDB for development"
  task :start do
    mkdir_p "db"
    system "mongod --dbpath db/"
  end
end

namespace :haystack do
  desc "Start Haystack for development"
  task :start do
    system "shotgun config.ru"
  end
end

desc "Start everything."
multitask :start => [ 'mongodb:start', 'haystack:start' ]

Now I can start both MongoDB and my Sinatra app with rake start. It'll run in the foreground and when I Ctrl-C, both apps will be sent the Interrupt and gracefully shutdown.

Homebrew + Mysql + Snow Leopard

2009-10-15T00:00:00-07:00

I just had trouble installing and running Mysql on 5.1.39. Here's what worked:

brew install mysql

This printed some instructions which got mysql running just fine, but the mysql gem decided to be difficult - uninitialized constant MysqlCompat::MysqlRes. Some googling found the solution:

export ARCHFLAGS="-arch i386 -arch x86_64"
gem install mysql -- --with-mysql-dir=/usr/local \
--with-mysql-config=/usr/local/bin/mysql_config

That's assuming your homebrew prefix is /usr/local. Worked for me!

Who We Hire

2009-10-14T00:00:00-07:00

Someone recently wrote to GitHub and asked:

Basically, I'm just curious if you guys have any hints for a younger programmer on how to escape corporate mediocrity before it becomes too late. I know I could ask on StackOverflow or somewhere similar and get lots of good responses, but I'm looking for an answer from a company that I'd love to work at rather than someone who may be stuck in the corporate world themselves and are just giving bad advice.

I've written about getting a job with open source before. But this is more specific: who would (and do) we hire at GitHub?

Simple: at GitHub we hire "The Girl or Guy Who Wrote X," where X is an awesome project we all use or admire.

What's your X?

The Real-Time Web and a Git Overview

2009-09-09T00:00:00-07:00

I gave two talks at DjangoCon 2009.

The Real-Time Web talk is mostly about comet and our experiences building Leafy Chat.

The Git talk is the latest version of my go-to DVCS talk. I’ve given it a few time but these slides are the most complete (in that they include my notes).

The conference is really great so far. I’ll definitely be back next year.

Lyndon

2009-08-26T00:00:00-07:00

Yesterday Ilya Grigorik wrote:

“I’m still secretly hoping that one day our curl command client will just have a flag to return the final post-Javascript DOM.”

You don’t have to hope and it doesn’t have to be a secret, Ilya. Lyndon is most of the way there.

Tonight I committed a change that lets us pipe this into Lyndon:

  
<!DOCTYPE html>
<html>
  <head>
    <title>Lyndon Test!</title>
    <script type="text/javascript"
src="https://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js">
     </script>
    <script>
      $(function() {
        $('#content').append('<div id="hi">Hello world!</div>')
        $('script').remove()
        document.title = 'It worked!'        
      })
    </script>
  </head>
  <body>
    <div id="content">
    </div>
  </body>
</html>

to get this:

<html>
  <head>
    <title>It worked!</title>
  </head>
  <body>
    <div id="content">
      <div id="hi">Hello world!</div>
    </div>
  </body>
</html>

We added the Hello world! bit, changed the <title>, and removed the script tags dynamically. On the command line. With MacRuby.

Joyous.

Lyndon can even do a lot of the stuff Johnson can do. Check the README for the full scoop.

Hurl Preview

2009-08-23T00:00:00-07:00

Leah and I just finished our Rails Rumble 2009 app. It’s not ready for a public release yet, but here’s the screencast to tide you over until then:

It uses Sinatra, Redis, Phusion Passenger (via nginx), jQuery, and even some Python libraries.

Watch this space for the official launch announcement. Thanks to the Rumble organizers and all the sponsors!

His Name is Robert Paulson

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

Does it really matter what his name is? He didn’t want us to know and didn’t want us to call him by it.

Don’t call me Christopher. Call me Chris or defunkt.

Either way, I’m willing to bet it wasn’t Jonathan. Jonathan Gillette worked on Javuh with _why in 2002. They both, apparently, worked at iNetZ Media. Which would explain why their mailservers are they same – they both were emailing from work.

They both worked on the Javuh project at the same time:

They both contributed different parts of the documentation:

_why joined SourceForge in 2000:

Jonathan joined SourceForge 2001:

Jonathan also worked on other projects without _why:

Now we can all stop obsessing about who we think he was and instead focus on who he actually was – a prolific and inspiring hacker.

Thanks for the memories, _why.

Rip 0.0.4

2009-08-13T00:00:00-07:00

I just pushed the fourth alpha release of Rip. What’s new? Better gem support!

rip install gem now installs gem dependencies. This is awesome. Thanks to lazyatom – check out his writeup
Added rip show PACKAGE to inspect a package. Supports -f to see files. Again, thanks lazyatom.
Fixed bugs in gem installation.
Added gemcutter as a gem source.
rip help commands are now sorted alphabetically.
Improved rip build – Nokogiri is now supported.

The next release will focus on systemwide Rip installations. See you then.

Rip 0.0.3

2009-08-06T00:00:00-07:00

I just pushed the third alpha release of Rip. What’s new?

New git-style help system. Thanks Ben Burkert!
rip install blah -f does a “force” install.
Nicer rip env list output.
rip env list -p shows a few packages from each ripenv.
rip env list ripenv runs rip list for a specific ripenv.
Added rip use ripenv as an alias for rip env use ripenv
rip build now tries to run make clean before make install

And, of course, bug fixes. Also, I found a few projects that include a deps.rip file. Check ’em out:

We’re getting closer to Rip 0.1.0, which will contain a big surprise. You’ll love it. See you then.

define_method and rdoc

2009-08-03T00:00:00-07:00

Seen in evented-memcache-client:

# Wish these could be properly rdoc'd...
%w(flush_all version quit).each { |cmd|
  class_eval do
    define_method "#{cmd}" do
      book_it(cmd.to_sym)
      send_to_peer "#{cmd}\r\n"
    end
  end
}

I used to write a lot of Ruby code like this. define_method is there – why not use it, right?

Remember, though: write code that is easy to read. Here’s how I would rewrite the above to be rdoc friendly:

def flush_all; send_command(:flush_all) end
def version;   send_command(:version)   end
def quit;      send_command(:quit)      end

def send_command(cmd)
  book_it(cmd)
  send_to_peer "#{cmd}\r\n"
end

Just like that it’s rdoc friendly, has less nesting, and is still easy to modify.

New Bacondrop Icon!

2009-07-30T00:00:00-07:00

Thanks to Spencer Holtaway, Bacondrop now has a hot new icon:

Fake RubyGems in Rip

2009-07-28T00:00:00-07:00

Tonight I created a simple Rip plugin which lets you install a RubyGems stub into the current ripenv, for faking out RubyGems.

Why is this useful? Well, Grit includes the following code:

require 'rubygems'
gem "mime-types", ">=0"
require 'mime/types'

Grit doesn’t really need RubyGems – it just needs mime/types. Trying to run one of Grit’s tests, for instance, fails with mime/types installed through any means other than RubyGems:

$ ruby test/test_diff.rb 
/Library/Ruby/Site/1.8/rubygems.rb:826:in `report_activate_error': 
  Could not find RubyGem mime-types (>= 0) (Gem::LoadError)
  	from /Library/Ruby/Site/1.8/rubygems.rb:260:in `activate'
  	from /Library/Ruby/Site/1.8/rubygems.rb:67:in `gem'
  	from ./test/../lib/grit.rb:20
  	from ./test/helper.rb:1:in `require'
  	from ./test/helper.rb:1
  	from test/test_diff.rb:1:in `require'
  	from test/test_diff.rb:1

But! after installing the plugin we can simply run rip fake_rubygems to stub RubyGems in the active ripenv:

$ rip fake_rubygems
rip: rubygems successfully faked
$ ruby test/test_diff.rb 
Loaded suite test/test_diff
Started
.
Finished in 0.000676 seconds.

Fantastic. Check out the plugin. For now the easiest way to install it is to manually stick it in ~/.rip/rip-commands (after creating the directory).

So basically:

mkdir -p ~/.rip/rip-commands
cd ~/.rip/rip-commands
wget http://is.gd/1Sgvf

Next up: making plugin management simpler. Ta.

FakeFS Activation

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

Thanks to Pat Nakajima FakeFS now supports activation and deactivation.

require 'fakefs/safe'

FakeFS.activate!
# your code
FakeFS.deactivate!

# or
FakeFS do
  # your code
end

This means you can turn it on and off in your tests, if you please. Enjoy.

Rip 0.0.2

2009-07-21T00:00:00-07:00

I just pushed the second alpha release of Rip. What’s new?

C extensions are now built automatically during installation.
Rip can now uninstall itself using sudo rip uninstall rip.
Added ruby command for running Ruby within a specific ripenv: rip ruby some_ripenv file.rb
Add RUBYBIN env support to rip ruby: RUBYBIN=/path/to/jruby rip ruby cheat_env cheat.rb
Rip also respects the RAKEBIN and GEMBIN env variables.
Improved zshell support.
Support for the fish shell.
Added rip setup command.
Can pass --bindir, --libdir and/or --ripdir as to setup.
More friendly and informative rip check.
Rip now installs into /usr by default on OS X (not /usr/local)
Rogue plugins can no longer break Rip.
Packages may now respond to hooks in the installation process.
Added upgrade to setup.rb.

And, of course, bug fixes. Thanks to everyone who contributed!

Johnson

2009-07-21T00:00:00-07:00

Johnson has long been one of my favorite Ruby projects. As the description says, “Johnson wraps JavaScript in a loving Ruby embrace.” In other words Johnson lets you evaluate and manipulate JavaScript with Ruby (thanks to Mozilla’s Spidermonkey engine).

Ruby

A simple example from the README:

require "johnson"

Johnson.evaluate("4 + 4") # => 8
Johnson.evaluate("4 + foo", :foo => 4) # => 8

Why? Well, maybe you want to let people write plugins for your app in JavaScript – thereby locking down and controlling the environment in a way not really possible with Ruby.

Or maybe you want to run your JavaScript tests on the command line before booting up your browser.

Or maybe you want to run a JavaScript REPL.

$ johnson
js> 1 + 1
=> 2
js> var name = 'chris'
=> nil
js> name
=> "chris"

Emacs Lisp

If you’re using Emacs like me, you can setup johnson to run as your JavaScript shell by setting the custom variable javascript-shell-command to “johnson”.

Also you can use it to execute a buffer:

(defun js2-execute-buffer () 
  (interactive)
  (shell-command (concat "johnson " (buffer-file-name))))

Or a single line:

(defun js2-execute-line ()
  (interactive)
  (save-excursion
    (call-process-region (point-at-bol) 
                         (point-at-eol)
                         "johnson"
                         nil
                         (get-buffer-create "*johnson-line*"))
    (with-current-buffer (get-buffer "*johnson-line*")
      (search-backward "\n\n" nil t)
      (replace-match "" nil t)
      (message (buffer-string))
      (kill-buffer nil))))

I bind these functions to ⌘r and ⌘R.

(define-key js2-mode-map (kbd "A-r") 'js2-execute-buffer)
(define-key js2-mode-map (kbd "A-R") 'js2-execute-line)

Python

Python person? Try davisp’s python-spidermonkey or my fork (which does nothing but add a dead simple REPL script).

It’s very similar to Johnson. Except, you know, for Python.

>>> import spidermonkey
>>> rt = spidermonkey.Runtime()
>>> cx = rt.new_context()
>>> cx.execute("var x = 3; x *= 4; x;")
12

Again, the README has it all.

FakeFS

2009-07-15T00:00:00-07:00

FakeFS is a Ruby library which transparently causes File, Dir, and FileUtils to use an in-memory. faux-filesystem rather than the real filesystem on disk. Why? So you don’t have to deal with mocking libraries, so your tests are faster, and so you don’t need a hard drive to run them.

For example, this:

def test_creates_directory
  FileUtils.expects(:mkdir).with("directory").once
  Library.add "directory"
end

Becomes this:

def test_creates_directory
  Library.add "directory"
  assert File.directory?("directory")
end

I don’t know about you, but the second feels more natural to me. Also it means replacing our mkdir call with a call to mkdir_p won’t break our tests. Because, really, it shouldn’t.

Install it:

$ rip install git://github.com/defunkt/fakefs.git

And start using it in your tests:

require 'fakefs'

There really aren’t any usage examples: just write normal Ruby. If you insist, however, check out some of the Rip test or the FakeFS tests.

Bacondrop Libraries

2009-07-13T00:00:00-07:00

Bacondrop uses two third party libraries that are quite good.

The first is ChocTop, Dr Nic’s library for generating DMGs and managing Sparkle. The documentation is great and the gem is dead simple to use: all I had to do was run rake dmg (after installing it and running install_choctop path/to/project) to get a DMG ready for distribution. It even included an Applications shortcut in the DMG for easier installation. Though Bacondrop doesn’t use Sparkle, I already know I’ll use ChocTop in any and all Cocoa apps I write in the future.

The second library is ASIHTTPRequest. It’s an Objective-C wrapper for the CFNetwork API which makes it dead simple to issue HTTP requests. The file uploading support in particular is ridiculously good:

def beginUpload(url, path, username, password)
  request = ASIFormDataRequest.requestWithURL(url)
  request.username = username
  request.password = password
  request.uploadProgressDelegate = progressBar
  request.didFinishSelector = "uploadFinished:"
  request.didFailSelector = "uploadFinished:"  
  request.setFile(path, forKey:"file")

  @networkQueue.addOperation(request)
  @networkQueue.go
end

This’ll POST a file to the url of my choosing, authenticate with HTTP basic auth, hit the uploadFinished: method with the request object upon completion, and even update a progress bar for me along the way. Naturally it’s all done asynchronously – I can fire off as many as I want using the queue.

(It’s not the exact code I use in Bacondrop, but it gives you an idea of how easy it is to use this library.)

The documentation is fantastic and it even works on the iPhone. Ben Copsey really knocked this one out of the park.

Bacondrop!

2009-07-12T00:00:00-07:00

I just finished a rough 1.0 of my first MacRuby app: Bacondrop.

It’s a simple app for uploading files to Baconfile. Which, in turn, is a simple (and slick) interface to S3.

MacRuby is great.

Leafy Chat

2009-07-10T00:00:00-07:00

A few weeks ago I competed in the Django Dash along with Alex Gaynor and Leah Culver. Our team ended up placing second.

We made a comet powered, web based IRC client called Leafy Chat. In fact, we just launched a redesign.

Check it out.

Forking, Continued

2009-01-21T00:00:00-08:00

David Welton has posted a thoughtful reply to my comment. Unfortunately, he missed my point. I can only assume this is due to a lack of clarity on my part. (My comment was very brief.)

I mentioned the Network Graph and Fork Queue but David mentioned neither. I think he doesn’t know what they are, probably because I didn’t explain what they are :)

So, in an effort to be more clear, let me propose an alternate workflow to David’s. He says, “Here’s a concrete example of how things might go wrong.” I see his example and think, “That’s a concrete example of how things have gone right.”

(I’m going to make this visual so you don’t have to take my word for it or keep jumping between here and GitHub to try it out.)

The Network Graph

root@fortrock:~# gem1.8 search -r actionwebservice

*** REMOTE GEMS ***

actionwebservice (1.2.6)
datanoise-actionwebservice (2.2.2)
dougbarth-actionwebservice (2.1.1)
nmeans-actionwebservice (2.1.1)

The problem is obvious: which actionwebservice should we use?

Well, we know three of those gems are on GitHub. And all three of the GitHub gems have higher versions than the Rubyforge gem. So let’s check GitHub first.

I go to http://github.com/search and search for actionwebservice. (Actually I do this from my LaunchBar template, but you get the idea.)

In the results, I see that the first actionwebservice appearing has the most forks and watchers, and was the most recently active.

We could stop right here and choose @datanoise@’s fork. But let’s be sure.

I click on the repo and arrive at http://github.com/datanoise/actionwebservice. I click on the Network tab.

I arrive at http://github.com/datanoise/actionwebservice/network and glance at the graph.

There are commits unique to certain forks, but datanoise has the most activity and the most recent commits.

At this point, there’s no doubt: datanoise is the most recent, most active version of actionwebservice. Will it always be? Who knows. But for now, this is the best choice.

The Fork Queue

We can take it a step further, too. We see there are unmerged commits – changes people have made which have not been pulled into datanoise. We can examine them straight from the Network Graph, or we can attempt to merge them into actionwebservice.

I fork @datanoise@’s actionwebservice using the ‘fork’ button, still on the Network Graph’s page:

Now I have my own version of actionwebservice.

Time to visit the Fork Queue. (Only people with write access to the repository see this tab.)

Okay, so it looks like a lot of the changes made will not apply cleanly.

If any of these commits had a green background, we’d be able to apply them right there on the site (as explained by the legend). But we can’t.

Pull Requests

Since we can’t apply the commits, we could send datanoise a message asking him to check over his Fork Queue and merge in the changes that look promising. We could do it ourselves, too, by resolving the conflicts. All we’d need is to clone our repository, add one of the others as a remote, then merge and fix the conflicts before pushing back to our version. After that we could even send datanoise a pull request, since we’ve done the work for him. Or just wait for him to check his Fork Queue and see that our changes are green.

I’m just going to delete my fork, though.

Keeping Current

Even ignoring the forking and the Fork Queue, the point is this: it’s not hard to see which project is the most active. Yes, we (GitHub) need to make it more clear. We want to say “this is the fork you’re looking for” on the first page you see. And we want that to change as the most active, latest fork changes. But, for the time being, you can figure that all out with a single click.

What happens when it does change, though? Perhaps datanoise will lose interest and someone else will take up development. That’s the beautiful part, and that’s why you just can’t do GitHub without Git (or any equally powerful DVCS): switching the remote and pulling in changes from the new repository is trivial. Git doesn’t care where you pull from. It is not married to a remote URL in the same way a centralized VCS like Subversion is.

Imagine hitting the datanoise repository and being informed “this may not be the most active repository in the network. Check Person X’s.” Switch your remote to the new one, pull, and you’re up to date. This is the type of information the Network Graph makes available, we just need to make it more visible and plain. (Heck, maybe that message could be printed out when you git pull from an inactive remote.)

For instance, hitting @dougbarth@’s actionwebservice fork and checking the Network Graph makes it obvious that datanoise is the repo we want:

If we were previously using @dougbarth@’s fork it would be clear that @datanoise@’s is the one to watch in the future.

Moving Forward

It may seem strange, and perhaps even like a lot of work. “Why should I have to check to see which is the most current? In the old model, there’s always a canonical repository.”

In the old model, actionwebservice wouldn’t have made it past 1.2.6. Welcome to distributed version control.

Linux vs Classic Dev Style

2009-01-20T00:00:00-08:00

I tried to leave this as a comment on “Developer > Project, or Project > Developer(s)?”:http://journal.dedasys.com/2009/01/10/developer-project-or-project-developer-s but the form errored and I couldn’t find a contact email address. Here it is:

GitHub lets you do Linux-style fork development, or classic SourceForge style development. The difference is you have the choice.

Using the Network graph you can easily see which fork in a Linux-style network has the most recent activity. It’s one click away from any repository’s home page, but we’re working on better surfacing and summarizing the information.

As for lazy developers not requesting you pull in changes, the Fork Queue lets you see unmerged changes in forks and even lets you merge them in from the web interface.

We’re constantly working to improve our tools and the ways you can manage your projects, as well.

TextMate Minor Mode

2008-12-02T00:00:00-08:00

TextMate Minor Mode is an
Emacs minor mode that emulates some awesome TextMate features.

Like ⌘T (find file in project).

And ⇧⌘T (go to symbol in file).

And more! Really, the
README
says it all.

Installation:

$ cd ~/.emacs.d/vendor
$ git clone git://github.com/defunkt/textmate.el.git

In your emacs config:

(add-to-list 'load-path "~/.emacs.d/vendor/textmate.el")
(require 'textmate)
(textmate-mode)

Or just grab the elisp: textmate.el

TextMate Minor Mode was written for Aquamacs
but works great on console Emacs, CVS Emacs.app and Carbon Emacs. Try
it today!

Why Lisp Failed

2008-12-01T00:00:00-08:00

Emacs.

Writing Lisp without Emacs is just too painful. If your language
depends on specific features of a specific editor, you better be a big
company like Sun or Microsoft with the mad moneys. Otherwise forget it.

Learning Your Editor

2008-11-19T00:00:00-08:00

Text editors should take a lesson from video games. In many games, you have access to subset of total weapons, powers, whatever. As you advance and master the basic weapons, more weapons become available to you. By the end of the game you have direct experience with all or most of the weapons – from basic to advanced.

How many times have you done something cool or strange in Vim only to think, “How did I do that?” video-game-mode would be a fun way to learn an editor: start with the basic commands and unlock more as you progress.

Singin' Singletons

2008-11-18T00:00:00-08:00

There’s stuff I just don’t understand. David Bowie, for instance. Or the Southern Hemisphere. But nothing quite boggles my mind like Ruby’s Singleton. Because really, it’s totally unnecessary.

Here’s what they want you to do with your code:

require 'net/http'

# first you setup your singleton
class Cheat
  include Singleton
  
  def initialize
    @host = 'http://cheat.errtheblog.com/'
    @http = Net::HTTP.start(URI.parse(@host).host)
  end
  
  def sheet(name)
    @http.get("/s/#{name}").body
  end
end

# then you use it
Cheat.instance.sheet 'migrations'
Cheat.instance.sheet 'yahoo_ceo'

But that’s crazy. Fight the power.

require 'net/http'

# here's how we roll
module Cheat
  extend self

  def host
    @host ||= 'http://cheat.errtheblog.com/'
  end

  def http
    @http ||= Net::HTTP.start(URI.parse(host).host)
  end

  def sheet(name)
    http.get("/s/#{name}").body
  end
end

# then you use it
Cheat.sheet 'migrations'
Cheat.sheet 'singletons'

Any why not? The API is more concise, the code is easier to test, mock, and stub, and it’s still dead simple to convert into a proper class should the need arise.

Pretty Fixtures

2008-11-18T00:00:00-08:00

# in whatever test helper you use
class Test::Unit::TestCase
  def defunkt
    users(:defunkt)
  end
  
  def github
    repositories(:github)
  end
end

# in your tests
context "A user" do
  test "belongs to a repository" do
    assert_equal defunkt, github.user
  end
end

Somethin’ like that.

Sugar

2008-10-30T00:00:00-07:00

The console is part of your app. Treat yourself right.

$ ./console
Loading production environment (Rails 2.0.2)
>> me = User / :defunkt
=> #<User id: 2, … >
>> repo = User / :defunkt / :gist
=> #<Repository id: 61713, … >

User.instance_eval do
def /(name)
find_by_login(name.to_s)
end
end

Repository.instance_eval do
def /(name)
find_by_name(name.to_s)
end
end