My main point in the previous post was about finding the tools that worked best for you, and ignoring the FUD from everyone else.

So with that, I spent a week with vim, watched several screencasts, pulled in several plugins, and gave it a solid week of not using emacs and resisting TextMate. At the end of that week, I’ve decided I’m more at home in emacs.

The reasons are basically mute, especially since I’m trying to push for people to find out for themselves. It is counter intuitive to give a now slanted opinion while telling you to ignore it.

One of the things I found so refreshing about Ruby/Rails when I first started using it was the simplicity of the tooling. Just use a text editor, no monolithic IDE with large memory footprints, slow load times, and a panache for crashing.

Visual Studio certainly is a great tool, and provides some powerful tools to .NET. But I doubt anyone would disagree with me that Visual Studio often feels like a 500lb gorilla. Especially when you add in the plugins so many use, like CodeRush or ReSharper. Simply opening TextMate was rather refreshing when coming from that kind of environment.

A few weeks ago, I had the chance to go to GoGaRuCo and they had a workflow panel where they got some of the well known developers up on the stage, and discussed some of the tools and arrangements they use. It was a little superficial, where it was “I have an editor with 3 panes and 2 terminals open”. But there were some interesting observations. First of all, everyone on the panel was using either Emacs or Vim. After the talk, they polled the audience what they use. The overwhelming majority of the audience was using either RubyMine or TextMate.

The surface argument you could make is that all the “hackers” are using Emacs/Vim and aren’t representative of the population. Sure, I looked at it that way too. But a few things started to peak my interest, particularly when I’d talk to an Emacs or Vim user. You will almost always hear them say they’ve been using it for 10 years, 15 years, or sometimes even longer.

Think about your toolset today and your toolset 10 years ago. Is there anything that you’re still using? If so many people will stick with the same tool for 10 years, spanning technology bubbles, and crossing over to new languages, there must be something that tool is doing right. These are tools whose users invest in them. They’re like marriages.

So my journey to enlightenment has begun with looking at Emacs, however I’m not just playing eenie-meenie-miney-moe. Both Emacs and Vim have large followings are both excellent choices. The way I see it, I can’t chose which direction to go without looking both ways. So, I’m trying both for 1-2 weeks each, play around with building my .emacs and vimrc, and see where it leads.

I’ve been using Emacs for almost 2 weeks now, and find myself opening stuff up in TextMate less and less. Next week, I plan to focus more on Vim and try it out.

But I think the true enlightenment that can be found is… the elite tools are not what the “hacker” portion of a community use. Use what fits your style best, understand why you’ve chosen your tools, and recognize those same decisions in the tools used by those around you.

One of the great question after the presentation was someone asking him what it is like having, basically, changed development and how it felt when he first realized it was catching on. Matz said that time was around when the first picaxe book came out. It was having someone other than himself writing an English book about Ruby and it selling well. But his general answer to what it was like was “its nice”.

The Involver team had the opportunity to take a bit of a team photo with him. This represents about a quarter of the total Involver Engineering team. Here we have @zedlander, Jaime our System Overlord, myself, Nina our QA queen, and @zquestz (aka Josh) who just started this week. @nolman was also there, but had to take off right after the talk.

Ruby 2.0 will have a number of small but very nice language improvements, such as keyword arguments (similar to what .NET 4.0 added), as well as the ability to namespace things, including monkey patching that is scoped to only the namespace. That there is something that seems like it will bring a lot of power. Use two libraries that use two different versions of a gem? What if you could load them in separate namepaces, each utilizing the separate gem versions. Perhaps you could get really crazy and have a Rails 2 and Rails 3 app running together using separate namespaces. I don’t know why anyone would do that, but you could, and that I like.

Ruby 2.0 will see a large emphasis on embedded and an alternative VM/interpretter for more targeted implementations. I would love it if we could have a setup similar to the Arudio or Neturdio that ran Ruby. Matz was talking about bringing Ruby to places like digital appliances, more RTOS environments focusing on latency instead of throughput. Or having Ruby implementations for the cloud that utilized a smaller subset of the language to run on more targeted hardware. Distributed processing where perhaps computational power is more important than IO or what not.

My first thought… in a few years, could my DVR be running a Rails web interface?

Zsh is the best shell. If you don’t know, now you know.

One thing that is a nice convenience is to setup the command prompt to include your current Ruby implementation, RVM gemset, and which branch of the git repository you are in. In our main codebase at Involver, my prompt looks like this:

From this, I can tell I’m using JRuby 1.5.1, the “involver” gemset. I’m in the “topsecret” project folder (I just have the current directory, not the full path), and the “git:master” indicates its a git repository and I’m in the master branch.

To achieve that, add the following into your .zshrc or one of the files you source into it.

parse_git_branch() {
  git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/\/git:\1/'
}

rvm_prompt() {
  $HOME/.rvm/bin/rvm-prompt v g
}

export PS1='%{$reset_color$fg[blue]%}$(rvm_prompt)%{$reset_color$fg[gray]%}:%1~%{$reset_color$bold_color$fg[green]%}%{$reset_color$fg[green]%}$(parse_git_branch)>%{$reset_color%} '

There are of course many more things you can do with zsh. I have this and other tidbits in my dotfiles repo on Github. And now that I think of it, have some stuff I haven’t checked in since I’m not in TextMate/Ruby/zsh all day.

Papercut isn’t really a large codebase and doesn’t have a laundry list of problems or anything, but it does have a list of feature requests that I know I won’t have the time to get to. So I am looking for someone to take over maintenance of it.

With open source, it is easy enough for anyone to fork the code and run with it, but people still tend to be drawn to the official codebase and site for the latest updates. The problem with looking for people to take over is that you can’t necessarily hand it off to just anyone. In many ways, it is like applying for a job. You can’t just say “ohh, I’ll do it!” since the bigger question is are you capable of doing it.

The ideal person would be someone who:

• Has experience with .NET socket development.
• Understands the SMTP protocol, or can read and make sense of protocol RFCs.
• Understands MIME format enough to work with it.
• Be good to have a basic understanding of asynchronous IO and threading/managed thread pools.

This isn’t an absolute list, but more of a wish list or a list of what you should expect. Most of the feature requests for Papercut involve extending it to support more MIME functionality and bugs will often require troubleshooting the networking code or threading, which can be very different than traditional web or GUI apps.

Anyone who is interested, please email me at ken@invalidlogic.com.

The idea is simple. Get away from distractions for a while. Grab a whiteboard, piece of paper, or whatever you have. Mark out three columns. In the first, list the things that have been going well or that you like about where you are in life. In the second, list the things you don’t like. And in the final, come up with a resolution or first action item for each of the things you don’t like.

The goal of it is to acknowledge what has been going well, figure out what hasn’t, and get the ball rolling on tackling those. Just like you do with your projects!

I am by no means an agile expert, or a super organized, together person. But I was thinking about how it has been 3 months since making a rather big career change and wanted to take stock of how things have gone, but personally and not just professionally.

Try it for yourself and see how it goes. For me, I think a 3 month rotation is about right.

If you are in the area, please stop by! Pizza and refreshments are normally available.

Meetup details: http://www.meetup.com/sacruby/calendar/14122667/
Date: Thursday, August 19th
Time: 7:30pm til we go home
Location: 10911 White Rock Road, Rancho Cordova, CA 95670 (see details for number to call to get building access)

The main talk starts at 7:30, however we will also have a Ruby Clinic starting at 6:30. Bring your questions, problems, or other issues in and we’ll try to help you out.

Luckily adding an alias to Capistrano is pretty easy!

class Capistrano::ServerDefinition
  def to_s
    @to_s ||= begin
      s = @options[:alias] || host
      s = "#{user}@#{s}" if user
      s = "#{s}:#{port}" if port && port != 22
      s
    end
  end
end

Simply add that to your deploy.rb, or another file that is included with your recipes for utility methods. It works simply by overriding the ServerDefinition.to_s method, which is used for the logger output. The only change to the default method is line 4.

Then for your role definitions:

role :app, 'ec2-123-123-123-123.compute-1.amazonaws.com', :alias => 'app10'

Then you see much better output:

 ** [out :: app10] Alive

One thing I was kind of surprised that New Relic didn’t already have instrumentation around out of the box was controller filters. We had noticed some occasional gaps after the main processing of an action, where all the templates would be rendered, but the execution still went on for a few hundred milliseconds (or sometimes more). Finally, it dawned that it is probably one of the after_filters.

So we aded tracing around filter execution, and lo and behold, we had one that from time to time would misbehave and execute slow.

To instrument the filters, the simplest way seemed to be by tacking on to the ‘call’ method of each filter type.

::ActionController::Filters::BeforeFilter.class_eval do
  add_method_tracer :call, 'Custom/BeforeFilter/#{method.to_s}'
end

::ActionController::Filters::AfterFilter.class_eval do
  add_method_tracer :call, 'Custom/AfterFilter/#{method.to_s}'
end

::ActionController::Filters::AroundFilter.class_eval do
  add_method_tracer :call, 'Custom/AroundFilter/#{method.to_s}'
end

And one more goodie while I’m looking at my list of New Relic tracers… ActionMailer. Have seen this time and time again, that sending email synchronously with the HTTP request can drastically slow down performance. SMTP server can be slow, can be mailing a number of recipients, submission fails, etc. For us, most email delivery is asynchronous in the background, but one or two are triggered in line.

To trace ActionMailer delivery:

::ActionMailer::Base.class_eval do
  add_method_tracer :deliver!, 'Custom/ActionMailer/deliver!'
end

Will maybe sometime look at email processing more, but email templates are often far simpler and their action methods do less loading.

We use Cache Money, a gem that helps transparently cache models in Memcached. Out of the box, New Relic supports tracing calls for Memcached, however on traces we’d see a long list of Memcached calls but no information as to which request they were associated with.

For a lot of our additional traces, we’ve added an rpm_extras.rb file. To include tracing for Cache Money, just need to define it as follows:

::ActiveRecord::Base.class_eval do
  class << self
    add_method_tracer :transaction, 'Custom/CacheMoney/transaction'
    add_method_tracer :find_every, 'Custom/CacheMoney/find_every'
    add_method_tracer :find_from_ids, 'Custom/CacheMoney/find_from_ids'
  end
end

New Relic itself uses add_method_tracer around transaction and find_by_sql, however Cache Money works by alias_method_chaining transaction, find_every, and find_from_ids.

One thing worth noting is that since both New Relic and Cache Money make use of transaction, order of loading could be important. In our environment.rb, we load our rpm_extras.rb in the after_initialize block. When RPM is loaded, it wraps the actual ActiveRecord#transaction call, then Cache Money chains it, and our own tracer wraps the chained call.

Initially, I tried putting the tracer around Cache Money’s own transaction_with_cache_transaction, however that didn’t show up in traces.