Originally submitted at REI

Metolius Porta-Cord™ rope bag can also be used as a lightweight pack or a rope bucket during long multipitch routes and big-wall climbs.

Metolius Porta-Cord Rope Bag

Better than a rope bag. Not a crag pack.

Pros: Wear Resistant

Cons: Small Compartments

Best Uses: Sport Climbing, Cragging

Describe Yourself: Avid Climber

Was this a gift?: No

I really wanted to love this pack. To that end, I used it for a full season before returning it to try a better pack.

This pack is, hands-down, better than any rope bag available. If you’re replacing a rope bag, or avoiding buying one, this is a great way to go.

That said, it’s a pretty bad pack. I found the straps uncomfortable, the lid hard to close when overstuffed, and the side pockets useless for holding anything when carrying a rope longer than 50M.

Unless you’re carrying a super-skinny rope or a 50M sub-10mm rope, you’re going to have trouble closing the pack, taking other gear with you, getting anything into those side pockets, and difficulty getting the load to ride correctly.

Also, I find those gear lashing daisy chains overrated. If you clip your shoes, harness, helmet, or water bottle to the outside of this pack, you’ll suffer from an unstable load that snags on trail obstacles. Not ideal.

I live in Rumney NH, exactly 3/4 mile from the crags, and I’d avoid taking this pack to the cliffs. Instead, I found myself favoring my hiking pack: so I knew something was wrong.

If you have short approaches, a short rope, not a lot of personal gear, and don’t mind the minimal padding on the straps, then this is an excellent pack.

If you are looking for a rope bag and can have your partner carry the rack, food, and water, then this is the pack for you.

Otherwise, it may not be.

(legalese)

• A 20MB Keynote ‘o9 file
• A 10MB PDF file (transitions and animations will not work)
• A 52MB Quicktime Movie ar 1024×768
• A 9.1MB Quicktime Movie formatted for the iPod and iPad (640×480)

I hope you enjoy the slides. If you missed my talk and want me to present the material at your Ruby User Group, contact me.

All presentation material is Copyright 2010 Peter Jackson, licensed under CC 3.0 Attribution. You can reused, redistribute, and remix the content. Just make sure you attribute it with a link.

Enjoy!

:false

You keep using that symbol. I do not think it means what you think it means.

Today, I’d like to describe something I like to call: The Inigo Montoya Attack. It is the implementation in code — often with good intentions, but sometimes simply because of ignorance — of an algorithm which masks one clear, well-known paradigm inside of another that completely obfuscates your actual intent. Unless you have six-fingers on your right hand (I’m talking to YOU, Count Rugen) you are forbidden from this practice.

Here’s some code I came across in a codebase I was maintaining.

 def logged_in_from_token?
    current_user = token_exists? ? log_in_from_token : :false
 end

It looks strange. It OUGHT to look strange. What is that :false symbol all about?

I’ll tell you what it is. It’s a very misleading piece of code. Because when you do not log the user in from a token, current_user is NOT set to false, in the boolean sense. It is, in fact, a boolean “true” value in Ruby.

Try this in IRB:

 if :false  
   puts "You keep using that word. I do not think it means what you think it means." 
else 
  puts "Have fun storming the castle!"
end

If :false evaluated to a boolean false value, then you’d see “Have fun storming the castle!”. But instead, you get “You keep using that word. I do not think it means what you think it means.” If you’re trying to make readable code, using the symbol :false is dangerous and misleading.

To make matters worse, this code assigns :false to the value current_user, which is a well-known and established name used in a number of Rails patterns. RESTFul Authentication and Authlogic BOTH support the notion of current_user, and when nobody is logged in, THAT METHOD RETURNS FALSE. Not the doppleganger wannabe :false, but a real, honest to goodness, boolean false. (OK: it’s actually returning nil, but nil is false).

So imagine my bewilderment when this basic test no longer worked:

  <%- if current_user %>
    <%= display_logged_in_stuff()  %>
  <% else %>
      You are not logged in
   <% end %>

So a couple hours of debugging later, I found myself using ‘ack in project’ to remove all references to the silly symbol :false.

Lessons for Rubyists:

1. Be clear. :false is never actually false. Don’t use it.
2. Follow established conventions. The method some_test? should always return a boolean value. If it doesn’t, leave off the question mark!
3. Don’t reinvent the wheel! The implementor of the code above could have simply used RESTful Authentication or Authlogic and have avoided the whole mess.
4. Unit tests are still important! Remember that someone has to maintain your stuff someday. A simple unit test would have caught the bug introduced by using the symbol :false in place of a boolean false.

Have fun storming the castle!

I won’t go too far into how to use the adapter until it’s ready for prime time. This message is intended to encourage collaboration among anyone else who is in the unfortunate boat of having to use Oracle Spatial and Rails without built in driver support (which is not fun).

To use the functionality, install Oracle, Install GeoRuby , then install my fork of the spatial_adapter.

Then you can do this:

   create_table :points_of_interest do |t|
      t.geometry :location
      t.string :venue_name 
      t.timestamps
   end
 
   add_index :points_of_interest, [:location], :spatial => true

Then all of the relevant rows will be set up for you in SDO_GEOM_METADATA, SDO_INDEX_METADATA, and SDO_INDEX_METADATA_TABLE.

Currently, there is only support for geometry types. Explicit point, polygon, line, and multipolygon types will come later.

Feedback is encouraged.

P.S. To everyone wondering what happened to the VoteFu major upgrade, it’s imminent. Thanks to everyone who has submitted patches in the past few months. It’ll be released *real soon now*

For me, the last straw with TextMate was the issue illustrated in this video. When you have all of your methods folded up, and you delete a line of whitespace that follows a folded up block of code, the editor will in fact delete the entire folded up code block. This might be working as expected, but I expect better.

Some other annoyances I’ve had with TextMate include:

• Random Pinwheeling (lockups that take unspecified amounts of time to clear)
• Sluggish performance
• Drawer behavior: When I want it on the left, I want it on the left. Even if my window is too close to the left side of my monitor. STOP OPENING ON THE RIGHT! DO YOU HEAR ME! (excerpt from an actual conversation with TextMate).
• No significant updates in over two years. Not even the kind you pay for. I guess the upside of this is that any Bundles you find are pretty well guaranteed to work with your version of TextMate, because there’s really only one version.

After making the decision that I couldn’t continue to work in a professional setting with an editor that contains so many productivity-sapping limitations for me, I decided to switch.

I found that in making my list of requirements for a replacement editor, the beginning of it was an enumeration of what sucks about TextMate. I needed:

1. Fast Search in Project
2. Fast “Find Usages”
3. A lack of code-munching bugs.

But there are a lot of things that I like about TextMate. I wanted to keep those features too:

1. Autosave
2. Fuzzy Match
3. Strong Ruby Language Support
4. HAML and SASS support
5. Modules / Plugins / Bundles
6. No Crashing
7. Themes and control over colorization

First, I checked out RubyMine, but found that it crashed and froze on me a lot. I can’t have a code editor that crashes or freezes a lot. Alex Chaffee of Pivotal Labs likes RubyMate, however, so your mileage may vary. It’s worth checking out. And you can check it out for free.

Next I investigated Coda: it’s pretty, but doesn’t have a made-for-ruby feel to it. It’s got a very extensible plugin framework, and a lot of plugins made for it, but a couple of key plugins were missing, and I can’t afford to take the time to write the plugins right now.

Then I tried BBEdit: nice, but again: not enough support through plugins for the kinds of ruby development I do.

Then MacVim: which is awesome but I HATE ‘vi’ (if I’m going to use a UNIX editor for programming, it’s going to be emacs).

Finally, I decided to try NetBeans, and found everything I needed, and some stuff I didn’t even KNOW I needed. I was genuinely surprised that I liked NetBeans, given its background as a Java IDE. But the Ruby modules for Netbeans are very nice. Here’s what I liked the most, in no particular order:

• Autotest, running right in the IDE: I don’t have to remember to start it in a terminal. It just runs in my IDE.
• Search. It’s Fast. And I didn’t have to install Ack In Project to make it so.
• When my continuous integration build fails, my IDE is notified, and it tells me so.
• It integrates with bug trackers.

Aside from the “search” item, I didn’t even know I needed half of that stuff. But now that I have it, I can’t go back.

I still use TextMate for a basic editor, and still love the column-wise cut-and-paste feature. But I won’t use it for development anymore.

So long, TextMate. It’s been a ride.

I’ve extracted the basic code i use to do this and published it as a simple plugin called yaml_twitter_oauth.

It allows you to set up your consumer tokens like this:

defaults: &defaults
  request_token_url: http://twitter.com/oauth/request_token
  access_token_url: http://twitter.com/oauth/access_token
  authorize_url: http://twitter.com/oauth/authorize
 
development:
  <<: *defaults
  consumer_key: 12345678
  consumer_secret: this-is-your-application-secret
 
staging:
  <<: *defaults
  consumer_key: 12345678
  consumer_secret: this-is-your-application-secret
 
production:
  <<: *defaults
  consumer_key: 12345678
  consumer_secret: this-is-your-application-secret

It’s also useful if you want to regenerate your secret key and need a simple declarative way to update it.

To install the plugin:

 script/plugin install git://github.com/peteonrails/yaml_twitter_oauth.git

Enjoy!

Want to see how easy it was to move to GemCutter?

ping:$ sudo gem install gemcutter
Password:
 
========================================================================
 
           Thanks for installing Gemcutter! You can now run:
 
    gem tumble        use Gemcutter as your primary RubyGem source
    gem push          publish your gems for the world to use and enjoy
    gem migrate       take over your gem from <a class="zem_slink" title="RubyForge" rel="homepage" href="http://rubyforge.org/">RubyForge</a> on Gemcutter
    gem owner         allow/disallow others to push to your gems
 
========================================================================
 
Successfully installed gemcutter-0.1.6
1 gem installed
Installing ri documentation for gemcutter-0.1.6...
Installing RDoc documentation for gemcutter-0.1.6...
ping: Pete$ gem tumble
Thanks for using Gemcutter!
Your gem sources are now:
- http://gemcutter.org
- http://gems.rubyforge.org
- http://gems.github.com
ping:workspace Pete$ cd vote_fu_harness/vendor/plugins/vote_fu/
ping:vote_fu Pete$ ls
CHANGELOG.markdown      README.markdown         examples                init.rb                 rails                   test
MIT-LICENSE             db                      generators              lib                     spec                    vote_fu.gemspec
ping:vote_fu Pete$ gem build vote_fu.gemspec
WARNING:  no rubyforge_project specified
  Successfully built RubyGem
  Name: vote_fu
  Version: 0.0.11
  File: vote_fu-0.0.11.gem
ping:vote_fu Pete$ gem push vote_fu-0.0.11.gem
Enter your Gemcutter credentials. Don't have an account yet? Create one at http://gemcutter.org/sign_up
Email:   pete@peteonrails.com
Password:
Signed in. Your api key has been stored in ~/.gemrc
Pushing gem to Gemcutter...
Successfully registered gem: vote_fu (0.0.11)
ping:vote_fu Pete$

Scarily easy. In under 3 minutes I have a new primary gem source and am set up to publish to GemCutter.

So, why would one want o host Gems on GemCutter? I asked the same question. In a nutshell:

1. Download counts are shown inline
2. Build locally, then push-to-publish. No more waiting to make your way through DJ, BJ, Resque, or whatever the background framework of the day is at GitHub.
3. It’s nothing but gem hosting, so it’ll probably grow to do gem hosting really well.
4. It’s ThoughtBot. I like the ThoughtBot guys.

So, there’s no real compelling reason to run out and move your gems to GemCutter, but if your users ask you to do it, it takes 3 minutes or less.

I was always in favor of seeding short reference data right in the migration like this:

class CreateTestScopes < ActiveRecord::Migration
  def self.up
    create_table :test_scopes do |t|
      t.string  :name
      t.timestamps
    end
 
    %w(first second third).each do |e|
       TestScope.create(:name => e)
     end
  end
 
  def self.down
    drop_table :test_scopes
  end
 
end

JUST TO BE CLEAR: we’re talking about production reference data that the application requires in order to run. We are not talking about TEST data, which belongs in mocks or (gasp) fixtures. A really good example of legitimate production seed data is the creation of the out-of-box Administrative user.

And if I had to update my reference data, I was also a fan of including it in the migration. After all, it’s reference data, not test data, fixture data (eww!) or user data.

class CapitalizeTestScopes < ActiveRecord::Migration
  def self.up
    TestScope.all.each { |t| t.name = t.name.capitalize; t.save! }
  end
 
  def self.down
    puts "Can't undo, but don't freak out!"
  end
end

Later, I decided I wanted a sort-order column and decided to add something like this:

class AddSortOrderToTestScopes < ActiveRecord::Migration
  def self.up
    add_column :test_scopes, :sort_order, :integer
  end
  # omit self.down ....
end
 
class TestScope &lt; ActiveRecord::Base
  default_scope :order => "sort_order"
end

And here’s the crux of the issue:

By adding a column that the model depends on in the default_scope, we’ve made it a requirement for the sort_order column to be present in order to load and query the model object. That’s fine for me. This migration will run with no errors on my workstation, provided that I ran db:migrate immediately prior to my latest changeset.

However, if you want to come up to speed on my project, you cannot do this:

 bash# rake db:setup
 bash# rake db:migrate

Because here’s what will happen:

==  CapitalizeTestScopes: migrating ===========================================
rake aborted!
An error has occurred, this and all later migrations canceled:
 
SQLite3::SQLException: no such column: sort_order: SELECT * FROM "test_scopes"  ORDER BY sort_order

Since we’re using the ActiveRecord object to do our reference updates (which is A GOOD THING, since we get validations and abbreviated syntax), we can’t have dependencies in the default scope that are not defined before the first use of the ActiveRecord object in our migrations.

A lot of folks argue that migrations are not reliable and shouldn’t be the way you’re creating your schema in the first place. To that, I respectfully say, “You’re wrong.”

It is only because we developers make boneheaded mistakes like the one outlined above that we cannot rely on migrations to rebuild our schema incrementally from migrations. Rather than be boneheaded, we should be awesome instead and fix the migration dependencies by moving the data seeding out to a db:populate or other rake task that operates on a completely built data structure. (I know: this is not in line with the movement toward schema.rb as the authoritative source of the database structure. I’m not up for arguing that point today, but I will argue it.)

The answer is to do this:

# file: db/migrate/X_create_test_scopes.rb
class CreateTestScopes < ActiveRecord::Migration
  def self.up
    create_table :test_scopes do |t|
      t.string  :name
      t.timestamps
    end
  end
 
  def self.down
    drop_table :test_scopes
  end
end
 
# File: db/populate/001_seed_scopes.rb
%w(first second third).each do |e|
   TestScope.create(:name => e)
 end

Then, when you have to capitalize your model data:

# File: db/populate/002_capitalize_scopes.rb
TestScope.all.each { |t| t.name = t.name.capitalize; t.save! }

And then when you add the sort order:

class AddSortOrderToTestScopes < ActiveRecord::Migration
  def self.up
    add_column :test_scopes, :sort_order, :integer
  end
  # omit self.down ....
end
 
class TestScope < ActiveRecord::Base
  default_scope :order => "sort_order"
end
 
# file db/populate/003_seed_sort_order.rb
TestScope.each_with_index { |e, i| e.sort_order = i; e.save! }

Voila! You can run db:migrate with a fresh database and have no errors.

So far, when I encounter an issue that prevents me from rebuilding my complete schema incrementally using db:migrate, it’s been a Rails Smell. I haven’t found a legitimate reason why migrations can’t be sorted out to build cleanly every time. If you can’t rebuild your database incrementally using migrations, it’s likely that you’re doing something wrong.

I ignored this debate for a long time because it didn’t really affect me. Don’t be like me. Save yourself the trouble of unwinding your migration mess and use an outside seeding package like db:populate.

I’ve just republished the source code, so you can again download my example application for VoteFu.

Because they already know the answer to the burning theological question that has ignited fury around the globe for thousands of years.

[pete@me.local log]$ which god
/usr/local/bin/god

The idea is, instead of using “hours” to estimate how long a story will take to complete, you instead have the team use an arbitrary figure called a “story point”. So, a new input field on a web page might be “1 point”. A new login screen is probably “3 points”. And adding a new payment gateway may be “8 points”.

Each iteration will then have a point value assigned to it. For example, Iteration 6 may be “23 points”. When your team completes all of the functionality, the team’s velocity is “23 story points per iteration”. Savvy Scrum Masters will calculate Velocity as the moving average of the last 4 iterations.

Why bother ditching the “hour”? Here’s why:

1. It eliminates preconceived notions about how much code can be written in a day.
2. It eliminates the “Day” as an important unit of measure.
3. It forces you to forecast completion of your project based on evidence. If you estimate in hours, you’re already forecasting. If you estimate in points, you’re simply measuring complexity in relative terms and relying on past performance to predict future results. In software, that’s a good thing.
4. It helps to gel the team. If Joe can do a feature in 8 hours, and Eric can do that same feature in 12 hours, there’s going to be a disagreement on how much to estimate. Instead, shouldn’t Joe and Eric agree that “Two new fields on the screen is twice as big as one new field on the screen?” Over time, the difference in coding productivity between your team members will be abstracted away by the estimation technique, which allows each team member to play to their own strengths without being measures in widgets-per-hour.
5. It ends up being more accurate after 2 or 3 iterations.
6. It avoids the mythical man month problem. By insisting that you forecast based on evidence, a manager cannot offer to double the team size and cut the deadline in half.

There are lots more benefits. There are books full of the benefits. Read them.

In convincing stakeholders to allow the engineering team to use Story Points, I have run into several objections. Here they are, along with the answers that I use.

Objection: But if your numbers don’t map to hours, how do I know how long something will take?

Answer: You use Velocity, as calculated by the evidence of progress your team produces, and map target dates based on what actually happened instead of a gut feeling.

Objection: But then how do you know how much more you can get done by adding more resources to the project?

Answer: Again, you use the evidence. Adding a new team member doesn’t immediately produce a faster tempo on a project. There is no way to know how a new team member will contribute to a self-organizing team until you see them perform. As that team member ramps up, the team will eventually start producing more story points per iteration. You will only take on work in a sprint that you historically could complete, and as you start completing all of the committed work faster, your velocity increases. The team is continually winning instead of lagging. If you instead use “hours” to estimate, you’d be tempted to just add “40 hours” to the velocity. That’s a guess, and it’ll be wrong every time.

Objection: But then how do I calculate what a project costs me?

Answer: If you have all of the members of a Scrum team properly allocated, and you have an accurate forecast of the completion date, then you can easily calculate the project labor cost using very simple math. If you use hours instead, you use the same simple math, it’ll just be inaccurate.

Objection: But then how do I know how much overtime to ask the developers to work in order to meet my deadlines?

Answer: Forcing overtime to meet deadlines is a Scrum Smell. It means you are planning poorly, sticking to unreasonable deadlines, sacrificing quality, or the team is failing because of some organizational, process, or performance issue. That said, it is sometimes necessary to work overtime. Rather than tell everyone they need to work 10 extra hours this week to make the deliverable, it’s actually BETTER to say to your team: “We have 10 more story points to complete in 2 days, and we’re only burning 3 points per day.” If the Scrum Master is good, the team will know what to do. And they’ll do it as a team.

Good luck! Let me know how it goes.

MyQuotable was a fun distraction for me, but frankly, I really wrote it so I could have a POC application for VoteFu and a couple other plugins. it doesn’t have any particularly useful Intellectual Property and it’s not the Next Big Thing. So it doesn’t make sense to keep the source closed.

You can get the source code from GitHub.

if (!(typeof worldHasEnded == "undefined")) {
   document.write("YUP.");
} else {
   document.write("NOPE.");
}

From http://hasthelargehadroncolliderdestroyedtheworldyet.com/.

Aside from the very obvious “you don’t need to negate that test condition, just reverse your simple if and else clauses” issue, it’s quite amusing.

Clever. I like it.

• VoteFu now works as a standard gem in a Ruby application. (i.e. not as a Rails plugin)
• VoteFu now works as a Rails Gem Plugin.
• VoteFu now works with Rails 2.2.2.
• Other assorted small bugfixes.

To install VoteFu as a Gem Plugin:

sudo gem install peteonrails-vote_fu

Then in config/environment.rb:

  config.gem "peteonrails-vote_fu", 
     :source => "http://gems.github.com", 
     :lib => "vote_fu"

And then, optionally:

rake gems:unpack

Special thanks to Jon Maddox and Bence Nagy for the updated code. Check it out yourself!

Picture of a cute kitten attacking unseen prey

I absolutely LOVE the cover of this book. And the book itself looks pretty decent, though how the author fills 300 pages with tricks and tips on Ubuntu it beyond me.

I’m not sure when it happened, but the technical world starting using amusing pictures of animals on the covers of their books some time in the late 1980s or early 1990s, and they seem to be the only ones I can remember. I’ll bet they typically sell well too.

The first book I can remember buying in this genre was the Pink Camel Perl book in 1995 or so (it was published in 1991), with a picture of a camel on the front. This book proved to be a long-lived reference guide for me, and now I hold onto it for sentimental value. Interestingly enough, I’d never have been able to tell you the name of the book, which is “Programming Perl”. Here is a picture of it:

Oddly, O’Reilly kinda blew it with Ant: The Definitive Guide. It has a picture of a lizard on the front. What’s that about? Wouldn’t you put a picture of an Ant on the cover of this book?

Compare those three covers with these covers, from two of the most important and influential books in programming:

Boring! But again, these are two very important books based on their content. Care to wager how the relative sales numbers of the Camel Book and K&R look?

A long time ago I created an app that would post messages to the homepage in a ticker when site visitors would do stuff. It was for a liberal political action NGO. From the homepage of this NGO’s site the ticker would flash messages like “A member just sent a fax to Senator Jim Webb about Senate Bill 1022″ or “Bill Jones just became a new member. Welcome Bill!”

I like how they’ve taken that concept and put it on a map. Nice.

Funny how we forget cool ideas from long ago. And funny how we forget that there’s always a chance to build off of old ideas to create newer, better ones.

Great work, AngelSoft. I expect to see a lot of people follow suit.

This tactic is somewhat different. It patents an industry standard that has been in effect for a long time. 30 years ago, computers had page-up and page-down keys on their keyboards. It seems a little late to be seeking protection for such an innovation.

Anyone know the prior art backstory here?

From the FreePatentsOnline

A method and system in a document viewer for scrolling a substantially exact increment in a document, such as one page, regardless of whether the zoom is such that some, all or one page is currently being viewed. In one implementation, pressing a Page Down or Page Up keyboard key/button allows a user to begin at any starting vertical location within a page, and navigate to that same location on the next or previous page.

For example, if a user is viewing a page starting in a viewing area from the middle of that page and ending at the bottom, a Page Down command will cause the next page to be shown in the viewing area starting at the middle of the next page and ending at the bottom of the next page. Similar behavior occurs when there is more than one column of pages being displayed in a row.

1
2
3
4
5
6
7
8
9
10
11

class User 
  has_many :posts
  has_karma :posts
end
 
class Post
  acts_as_voteable
end
 
# in your view, you can then do this: 
Karma: <%= @user.karma %>

This feature is new and probably going to be enhanced significantly, but useful enough that I’m releasing it now.

These are the ones that I think are important, and common. If these things are happening on your team, UR DOIN IT WRONG.

1. Your Burndown Chart does not have an entry on it for every day’s remaining activity.
2. Someone asks you how your sprint velocity is changing over time and you answer, “It’s hard to compare sprints, because each one is a different length.”
3. You can’t tell me when the next Sprint Planning Meeting is, or what was agreed to at the last meeting.
4. You have no idea what you’ll be working on in 4 weeks. Not even a foggy notion.
5. When asked if you use scrum, you have to answer, “We use our own special flavor of scrum.” Seriously. There isn’t enough process involved in scrum to have seasonings added to it.
6. You are the product owner and the scrum master.
7. You are the scrum master and the boss of your scrum team members.
8. Your burndown chart goes up sharply at the beginning of each sprint (hint: play planning poker 2 days ahead of the sprint meeting).
9. Business stakeholders get mad at the engineering team when their feature isn’t scheduled for an upcoming milestone (hint: that’s the product owner’s baliwick.)
10. You have more than 3 or fewer than 1 sprint goals on the board.