# of People who make excuses to not do something is greater than

# of People who talk about doing something is greater than

# of People who attempt to do something is greater than

# of People who do something

So how do you get this set up?  Here’s how I do it (in ~/.bash_profile):

GIT_COMPLETION_PATH=/etc/bash_completion.d/git
if [ -f $GIT_COMPLETION_PATH ]; then
  . $GIT_COMPLETION_PATH
  GIT_PS1_SHOWDIRTYSTATE=true # */+ for dirty
  GIT_PS1_SHOWSTASHSTATE=true # $ for stashes
  GIT_PS1_SHOWUNTRACKEDFILES=true # % for untracked
fi

And then you can just include the git completion function in your $PS1 where you want it. My $PS1 is super simple, and just has this and the current path (and some nice colors):

export PS1="\e[0;33m\w\e[0;91m\$(__git_ps1 ' (%s)')\e[0;96m \$\e[0m "

Note: the location of your git bash_completion directory may be different (especially if you installed git via homebrew).  I like to solve that with a symbolic link, instead of changing this configuration (I just find it cleaner that way – much nicer for upgrades too):

git -> /usr/local/Cellar/git/1.7.9.6/etc/bash_completion.d/git-completion.bash

If you like this – read more of my dotfiles

git stash show -p  # view a diff

post :photo, :file => File.open(path)

You’ll actually be sending the string “<File:…>” down as a request parameter.  What you actually want is a bit more obscure, but works perfectly:

post :photo, :file => Rack::Test::UploadedFile.new(path, mime_type) # text/jpg

TV is a pretty exciting space, looking forward to what’s coming next – seems like it may be one of the next big battlegrounds as we head towards making computers even more ubiquitous.

With the new update, comes a lot more data to view, and the expansion (despite the name) beyond SOPA to other bills in Congress.  The re-design really helps to make the raw data more clear.  My favorite page is the bills page, which breaks down funding on supporting and opposing sides for each bill.

Check it out, and keep your congresspeople responsible!

1. An optimization can be made by taking advantage of the lock’s imperfect positioning, and instead of trying every number, trying every other number first.
2. Based on where 1 spin ends, you can make the next move you choose to make start close to the end position of your last move.
3. The last turn, you can spin the lock and continually attempt opening, without re-trying the combinations.

So, my hopes are that with these optimizations, I can go from:

• 1st dial – 40 possibilities
• 2nd dial – 40 possibilities
• 3rd dial – 40 possibilities
• 40 * 40 * 40 = 64000 combinations

To:

• 1st dial – 20 possibilities
• 2nd dial – 20 possibilities
• 3rd dial – spinning as I go
• 20 * 20 * 1 = 400 combinations

I’ll post here updates as I have them, and hopefully soon we’ll have a cool combination lock unlocker.

Check it out!

#caller returns an Array representing the current call stack, where each element is a String like “file:line in ‘name’”.  Here’s an example:

def actually_do_it
  caller.join("\n")
end

def do_it
  actually_do_it
end

puts do_it

which will output:

ex.rb:8:in `do_it'
ex.rb:11:in `<main>'

Often when I turn something into a gem, I want to work on my application and its dependency at the same time.  For that reason, bundler let’s you declare dependencies by path, instead of rebuilding:

If a normally line in your Gemfile looks like:

gem 'autodoc'

you can specify a path as an argument to `gem` like:

gem 'autodoc', :path => '/Users/john/Development/autodoc'

:GitLog

Will open a git log in a new buffer of the changes to the current file

:GitBlame

Will open a vertical buffer containing the line-by-line blame of the current file

:GitDiff

Will open a buffer next to the existing buffer, with its current diff

Are my German friends coming out again?

Rate limits, server load, edge cases, hardware failure, concurrency issues.  The worst part is, as much as you plan, you’ll never avoid it.  The best you can do is measure everything and adapt as the challenges come.  Scale is accomplished through planning and effort.

So, in Ruby it’s quite possible to hide the class of an object, and make it pretend to be something else.  Sometimes this can be useful – for example if you don’t want to extend a core object, but want people to be able to work with an object as if you had.  A core example of this is how Rails *used* to treat ActiveSupport::TimeWithZone.  You can take the concept pretty far:

class String
  def class
    Fixnum
  end
end

So, the class is…

"hello".class # Fixnum

Then we get smart with Ruby, but the library implementers keep up with us:

"hello".is_a?(Fixnum) # false

class String
  def is_a?(clazz)
    clazz == Fixnum
  end
end

"hello".is_a?(Fixnum) # true, gahhhh

Again and again, every time we think we’ve figured out the real class – we get stumped.

Luckily, there are a few ways that are normally not (and shouldn’t be) overridden:

Fixnum === "hello" # false

# which you can mess up with
class Class
  def ===(obj)
  if obj.is_a?(String) && self == Fixnum
    true
  elsif String === obj
    false
  else
    super
  end
end

Fixnum === "hello" # true
String === "hello" # false

And .. for the most fun, we can bind Object’s base implementation of #class against an object and call it:

Object.instance_method(:class).bind("hello").call # String

And wouldn’t you know it:

class Object
  def class
    if self.is_a?(String)
      Fixnum
    else
      super
    end
  end
end

Object.instance_method(:class).bind("hello").call # Fixnum

def some_method
  begin
    danger_danger
    true # good return
  rescue Error
    false # error return
  end
end

But you can make it a bit nicer to do the same with:

def some_method
  danger_danger
  true # good response
rescue Error
  false # error response
end

First, add “coffee-script” to your dependencies in package.json (definitely specify a real version instead of using *):

{
  ...
  "dependencies": {
    "coffee-script": "*"
  }
  ... 
}

And then, any time you need a file that’s written in CoffeeScript, just make sure you have require “coffee-script” before requiring it:

require("coffee-script");
require("./something_in_coffeescript"); // something_in_coffeescript.coffee
...

And off you go!

• The original – written in Ruby
• A small python client gist by Devon Meunier
• WinHaste by Aidan Ryan – using hastebin from windows
• A vim client from Grant Heffernan
• An emacs client from Ric Lister
• A tiny sed wrap by Norman Gray

Its fun to see people not only using hastebin, but thinking of ways to use it that are more convenient for how they work!