Looking For Engineers

We’re currently looking to hire two more experienced Ruby / JavaScript engineers here in the Sharethrough Austin office. This is one of the hardest parts of my job as an Engineering Manager. If you’re interested, I thought I’d offer a few tips to make it easier for recruiters and hiring managers to pick you out of the crowd of applicants.

After I look over an applicant’s resume or LinkedIn profile, the next place I go is their GitHub page. I have some advice about other parts of an engineering candidate’s application, and I’m already working on a few more posts like this one. Since GitHub is basically the first place I look, I’ll start here.

As someone looking for a job writing code, GitHub can be one of your most valuable assets. The most important question that a potential employer has about you is “can this person code?” If you can’t code, nothing else really matters. Even if you’re a perfect culture fit for the team, if you can’t contribute you won’t get the job.

Your GitHub profile and your code repositories should demonstrate your ability to get things done by writing code. The fastest way to learn programming is by doing. The best way to improve your ability is consistent practice. Write lots of code and share it publicly.

Your Profile

As with all profiles, I recommend you use your real, full name on GitHub. This isn’t required, of course, but be sure that your username is fairly easy to pronounce and remember. Imagine telling it to someone over the phone. Also, don’t use anything that someone might find offensive.

The same goes for your profile photo. A recent photo of yourself is best. It doesn’t have to be a professional headshot. A picture of you doing something you enjoy is fine. Almost anything is better than the default pixel art face.

Write a short bio about yourself. This doesn’t have to be anything fancy, just a few sentences about your interests and experiences. This could even be simply your job title and your current company. Add your real email address. This should be the same address you use on LinkedIn. If you have a personal website, link to it on your profile. If not, link to your profile on LinkedIn.

Your profile is also a great place to show off things that you’re passionate about other than coding. Maybe you’re on a mountain bike or climbing wall. If you’re wearing headphones in your photo, I might ask you about music. Feel free to show off your personality and interests, but do it in a way that still looks good to potential employers.

After the profile, I head over to the repositories tab next. I’ll finish up a post with my tips for polishing up your repositories in a few days.

Lone Star Ruby Conf 2013

Tickets are now on sale for the Lone Star Ruby Conference 2013 in Austin, TX from July 18-20. The speaker line-up this year looks amazing.

This will be my third year to attend and my second year to offer training. I am teaching two sessions on July 18.

My morning session is called From X to Ruby. It is designed for developers with experience in other languages who are looking to move to Ruby. I will cover the basics of Ruby syntax and idioms with an emphasis on things that are different from other languages.

My afternoon session is simply called Advanced Ruby. It is the perfect next step for people in my morning session, or anyone else who has some experience with Ruby, wanting to “level up” their skills. I will discuss Ruby’s object model, modules / mixins, and metaprogramming.

I’m looking forward to reconnecting with the community, both local and from around the world. If you’re at all interested in Ruby, I highly recommend this conference and I hope to see you there.

Upcoming Events

It’s a great time to be a Rubyist in Austin. There are several upcoming events that I’m looking forward to attending.

First, I’m giving a talk on Rails Application Security at the Austin on Rails meeting tomorrow evening. The meeting will also feature lightning talks covering a variety of beginner topics. Be sure to get there early.

Next, the second session of my GeekAustin Beginning Rails class starts August 4. The last class went really well and I’m looking forward to teaching it again. There are still seats available. For full details and to sign up, see the EventBright page at http://geekaustinrailsclass.eventbrite.com/.

Then, the Lone Star Ruby Conf starts on August 11 with a day of training. Followed by the conference proper on August 12 and 13. The keynote speakers and session topics are all outstanding this year. I am not speaking (this year), but I plan to be an active participant. Hopefully I’ll see you around town.

Your First Rails 3 Plugin

On several different projects I have needed to find the newest and oldest record in certain models. The code to do this is pretty simple (especially in Rails 3).

For example, here is a snippet to find the newest Post:

@post = Post.order('created_at DESC').first

We can make this even better by defining a method in the Post class like this:

def newest
  order('created_at DESC').first

With this new method our code becomes:

@post = Post.newest

But now we’re faced with having to add that method to lots of different models. This sounds like a perfect job for a simple Rails 3 plugin.

It’s Just a Gem

Plugins in Rails 3 are created just like any other Ruby gem. You can use whatever you like to create a new gem. Currently, I’m using Bundler:

bundle gem date_filter

This will create several files for you. The most important are the gemspec file and the contents of the lib directory.

The gemspec

Your gemspec file tells the world about your gem. The first thing you’ll want to do is edit this file and fill in the information marked with TODO – your name, e-mail address, gem summary, and gem description.

The rest of the file should take care of itself. Note that the gem version is stored in date_filter/version.rb. Also, the list of files, test files, and executables is filled in automatically with git commands.

The lib directory

Inside the lib directory you’ll find a file called date_filter.rb and a directory called date_filter. A common practice is to keep the contents of date_filter.rb pretty minimal.

Most of your actual code should go in separate files inside the date_filter
directory. For example, here is my date_filter.rb file in its entirety:

require 'active_record'
require File.expand_path('../date_filter/base', __FILE__)

ActiveRecord::Base.class_eval { include DateFilter::Base }

Note that I am requiring ActiveRecord here. This is based on wycats advice – If You Override Something, Require It

Next I require base.rb inside the date_filter directory. This contains the source for the plugin.

The last line actually includes my code into ActiveRecord::Base. Since I am adding class methods, I use class_eval.


Finally, here is the code for the plugin. It’s common practice to separate class methods from instance methods in Rails plugins. In this case I have a separate module for the class methods.

When DateFilter::Base is included into ActiveRecord::Base the method included is called. This method then extends ActiveRecord::Base with the methods in the ClassMethods module.

module DateFilter
  module Base
    def self.included(base)
      base.send :extend, ClassMethods

    module ClassMethods
      def newest
        order('created_at DESC').first

      def oldest
        order('created_at ASC').first

Building and Installing

If you made it this far, you’re ready to build and install your new plugin. Bundler includes some rake tasks to help with this
automatically. You can see these by running rake -T

rake build
rake install
rake release

rake build will create a directory called pkg and build your new gem into this directory. You can then install it with the gem command.

rake install will build and install your new gem. To use it in a Rails project, you will need to add it to your Gemfile and run bundle install.


If you have an account at RubyGems.org you can also release your new gem. Check your profile page for your API key. Include your API key in ~/.gem/credentials as instructed, then run rake release to build and upload your gem to the site.

This should get you started building your own Rails 3 plugins. There are still a couple of pretty important things missing from this process – tests and documentation. I plan to cover both of these in a future post.

The complete source for this plugin is up at github. The gem is also available at RubyGems.org.

GeekAustin Rails Class

Starting on May 26 I will be teaching a beginning Ruby on Rails class for GeekAustin. The class will meet every Thursday from 7:00 PM – 9:00 PM at Cospace. I have developed a pretty ambitious course outline that I hope to cover in just 8 weeks.

The class is only $120 for 16 hours of training. The demand for Rails developers is so high right now, this is a tiny investment to get started in a very hot market. Someone who understands Rails inside and out can make that money back in a couple of hours (or less).

You will need to know some HTML and CSS. Previous programming experience would also be helpful, but is not required. Prior experience with Ruby or Rails is also not required. I’m going to cover everything you need to know and provide plenty of references to other materials to fill in any gaps in your knowledge.

I have really missed teaching, and I am so thankful for this opportunity. Developing the course outline and working on materials has been great. It seems like I’m exercising a part of my brain I haven’t used in a while. I honestly can’t wait to get started teaching this.

This class will fill up fast. For full details and to sign up, see the EventBright page at http://geekaustinrailsclass.eventbrite.com/

Editing Multiple Records in Rails

I recently had a requirement to create a single form with data from more than one record. This is a simple request, but I had never done it before in Rails.

After experimenting for a while (and reading quite a few forum posts and StackOverflow answers) I came up with a working solution. Hopefully this will save someone a little time in the future.

First, let’s create a simple Rails app for managing users. Each user will have a first name, last name, and e-mail address. I’m using scaffolding to generate the code.

rails new multi_edit
cd multi_edit
bundle install
rails g scaffold User first_name:string last_name:string email:string
rake db:migrate

Next, add the new routes for editing all users. I tried to stick to the RESTful convention with these. I’m just using the word ‘all’ in place of the :id.

match 'users/all/edit' => 'users#edit_all', :as => :edit_all, :via => :get
match 'users/all' => 'users#update_all', :as => :update_all, :via => :put

Now, let’s add the edit_all method to our UsersController to get started. The only thing it needs to do is get all users.

def edit_all
  @users = User.all

Next, we build the form for editing all users.

<%= form_for :user, :url => update_all_path, :html => { :method => :put } do %>
      <th>First Name</th>
      <th>Last Name</th>
    <% @users.each do |user| %>
      <%= fields_for "user[]", user do |user_fields| %>
      <td><%= user_fields.text_field :first_name %></td>
      <td><%= user_fields.text_field :last_name %></td>
      <td><%= user_fields.email_field :email %></td>
      <% end %>
    <% end %>

  <div class="actions">
    <%= submit_tag %>
<% end %>

The interesting part of this code starts around line 9. As expected, we iterate over the users with @users.each.

The next line tells Rails to name the fields for each user with array notation. For example, user_fields.text_field :first_name will output a text field named user[1][first_name].

The params hash will include a ‘user’ key that contains a hash of information for each user. The key for each of these hashes will be the user id.

Now that we know what the params will look like, it’s pretty straight-forward to write the update_all method.

def update_all
  params['user'].keys.each do |id|
    @user = User.find(id.to_i)

We iterate over each key in params['user'], then find and update the user associated with that id. I am leaving error checking as an exercise for the reader…

The complete source code for this simple application is on my GitHub page at https://github.com/anthonylewis/multi_edit

A Better Looking Terminal

I spend a lot of time in the Mac OS X Terminal.app. Unfortunately, the built-in color schemes are all pretty terrible. I can’t stand to look at any of them for more than a few minutes.

So, one of the first changes I make on a new Mac is to update the default color scheme. It’s surprisingly easy to make something much easier on the eyes than the Basic theme. Here’s how I do it.

  • On the Terminal menu, click Preferences
  • Click Settings on the toolbar

  • Make sure the Basic theme is selected
  • Now click the Gear, then Duplicate Settings
  • Type the name Metal

  • On the Text tab, change the Text and Bold Text colors to Mercury and the Selection color to Steel

  • On the Window tab, change the Background Color to Lead

  • Finally, click the Default button

When you open a new terminal, you should see something that looks
more like this:

Now that is something I can work with for a while.

Rails on Rackspace Cloud – Part 2

Part one covered setting up a new Ubuntu server and getting Ruby 1.9.2 up and running with rvm.

Now we will finish the setup with a Firewall, MySQL, Apache2, and Phusion Passenger.

Setting Up the Firewall

Before we install the database and other services, lets get the firewall set up. On Ubuntu, I like to
use the Uncomplicated Firewall – UFW.

sudo apt-get install ufw

That will install the firewall. Now set the defaults, add some rules, and enable the firewall.

sudo ufw default deny
sudo ufw allow ssh
sudo ufw allow http
sudo ufw enable

To see the current rules, you can check the status.

sudo ufw status

Now the only ports open to the internet are SSH (22) and HTTP (80).

Installing MySQL

Now that we’re a little more protected from the outside world, lets install the database.

sudo apt-get install mysql-server mysql-client libmysqlclient-dev

And install the mysql2 gem.

gem install mysql2

Remember to ‘rvm use 1.9.2’ if you didn’t set it as the default.

Installing Apache and Passenger

The database is ready to go at this point, now we need a web server.

sudo apt-get install apache2 libcurl4-openssl-dev apache2-prefork-dev \
                     libapr1-dev libaprutil1-dev

That will install Apache2 and the extra development packages needed by Passenger. Now install the Passenger gem.

gem install passenger

Now we’re ready to install the Passenger Apache2 module. Note, this doesn’t actually install anything. It just builds the module and gives instructions for updating the configuration.


Now we need to create a new module load file to tell Apache about Passenger.

sudo vim /etc/apache2/mods-available/passenger.load

Here are the contents of passenger.load. The first two lines should be all on one line.

LoadModule passenger_module /home/testapp/.rvm/gems/ruby-1.9.2-p180/gems/
PassengerRoot /home/testapp/.rvm/gems/ruby-1.9.2-p180/gems/passenger-3.0.5
PassengerRuby /home/testapp/.rvm/wrappers/ruby-1.9.2-p180/ruby

If we did everything right, we can enable the Passenger module now.

sudo a2enmod passenger

Now we need to set up our virtual host under sites-available.

sudo vim /etc/apache2/sites-available/testapp

Here are the contents of that file. You will obviously need to replace the xx.xx.xx.xx with the IP address of your server.

<VirtualHost *:80>
  ServerName xx.xx.xx.xx
  DocumentRoot /home/testapp/testapp/public
  <Directory /home/testapp/testapp/public>
    AllowOverride all
    Options -MultiViews

Disable the default web site and enable our new test application.

sudo a2dissite default
sudo a2ensite testapp

Setup a simple Rails App

Create a simple Rails application in your home directory just to make sure everything is working.

rails new ~/testapp
cd ~/testapp
bundle install
rake db:migrate RAILS_ENV=production

Finally, reload the Apache2 configuration.

sudo /etc/init.d/apache2 reload

Go to your server’s IP address in your browser and you should see the default Ruby on Rails index page.

Rails on Rackspace Cloud – Part 1

This is my recipe for starting up a new Rackspace Cloud Server and getting it set up for hosting Ruby on Rails applications.

Part one will take you from a new server to a working installation of RVM and Ruby. Part two will cover installing MySQL, Apache and Phusion Passenger.

If you don’t already have an account with Rackspace, I encourage you to go over to
http://www.rackspace.com/cloud/ and check them out.

I prefer Ubuntu Linux, so let’s start with that.

Starting a New Server

First, sign in to your Cloud Control Panel, then click Hosting, Cloud Servers.

Click the Add Server button, scroll down to Ubuntu 10.10 (Maverick Meerkat), then click the Select button.

Now type in a server name and select how much RAM you’ll need, then click the Create Server button.

After a short wait, your new server should be ready to go. You will receive an e-mail with your new server’s IP address and root password.

Connect to the IP Address with SSH, log in as root with the password provided, and lets get started.

Initial Login

The first thing you should do at this point is change the root password.


Type in your new root password twice. Now let’s add a new user account.

adduser testapp

Type in the information for your new user. Add the new user to the sudo group so you can execute commands as root.

adduser testapp sudo

Now that we have a new account to use, we need to deny the root user access via ssh. This will stop people trying to brute-force our root password.

vim /etc/ssh/sshd_config

Find the line that contains “PermitRootLogin” and change the value from “yes” to “no”. Restart the ssh server when you’re done.

/etc/init.d/ssh restart

We have set up a new user account with sudo access and denied root login via ssh, so let’s log out for now.


New User Login

Now reconnect with your new user account and let’s make sure all of our software is up to date.

sudo apt-get update
sudo apt-get upgrade

This should be really fast. Rackspace’s internet connection puts mine to shame.

Installing RVM

Next, we’ll install git so we can install rvm.

sudo apt-get install git-core

Now copy and paste the command below to install rvm:

bash < <(curl -s https://rvm.beginrescueend.com/install/rvm)

Once this finishes, you will see a lot of instructions for setting up rvm as well as a nice “Thank you” from Wayne.

rvm automatically creates a file called .bash_profile in our home directory. This causes bash to skip loading
the regular .profile.

The only thing in .bash_profile is rvm configuration, so let’s just delete it…

rm .bash_profile

and add the configuration to .profile instead.

vim ~/.profile

Add this line at the very bottom:

[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm"

Finally “source” your .profile file so the change will take effect.

source ~/.profile

Installing Dependencies

Now we’ll install the rest of the packages we need to build ruby. RVM can provide us a list of needed software.

rvm notes

Look at the line starting with “For Ruby” to get a list of dependencies.

sudo apt-get install build-essential bison openssl libreadline6 \
                     libreadline6-dev curl git-core zlib1g zlib1g-dev \
                     libssl-dev libyaml-dev libsqlite3-0 libsqlite3-dev \
                     sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev \

Again, this shouldn’t take long.

Installing Ruby

We’re finally ready to install Ruby.

rvm install 1.9.2

We have Ruby 1.9.2 now, let’s use it.

rvm --default use 1.9.2

Installing Rails

Now that we have Ruby set up, we’re ready to install Rails. It should be as simple as this:

gem install rails

Note that when you’re using RVM, you do not have to precede this with “sudo”.

After another short wait, you should be all set.

Verify that the ruby and rails commands work as expected. In part 2 we’ll setup MySQL, Apache and Passenger.