Slides for Writing Clean, Concise, and Confident Ruby Code

Today I will be giving a talk at NET/WORK called Writing Clean, Concise, and Confident Ruby Code. Since it's very code-focused, I once again used Stefan Otte's presenting.vim. The slides (which include links to all of my references) are all up on Github.

I'm indebted to Avdi Grimm for providing much of the inspiration for this approach to Ruby, and to my Staq colleagues for letting me try out my armchair programming philosophy on them!

Web programming notes newsletter

I'm a voracious reader and student of programming. Being mostly self-trained, I consider myself very much a life-long journeyman programmer. So every week I send the dev team at Staq a few links I've come across in my researches along with a few links here and there that inform my leadership philosophy. I also throw in occasional commentary.

I decided to create a mailing list where anyone else who is interested in these links and thoughts could signup. The content will mostly involve web programming and startup life, with a focus on Ruby, JavaScript, and cloud-based services.

I promise you'll get one email per week, at most, usually on a Friday, and I'll never do anything with this list other than send you web programming notes. (My first startup was after all an email overload management company!) You can signup using this form:

Enter your email address


powered by TinyLetter

I will also occasionally post the links to this blog (easy to do since TinyLetter makes a nice archive page of past emails). Below is a collection of the links I've sent to the team over the past year.

• The Twelve-Factor App
• Hexagonal architecture
• The Importance of One-on-One Meetings
• Getting Sikuli Script working with JRuby on the Mac
• The Clean Architecture
• AWS Redshift: How Amazon Changed The Game
• Mob Refactoring
• Yes, You Should Write Controller Tests!
• Your test suite is trying to tell you something
• Incremental Redesign with Rails
• BohConf 2013
• How to Write Good Error Messages
• 5 architecture anti-patterns and solutions for large Rails apps
• The value of Rails worst practices
• Principle of least privilege
• spin.js
• Writing Sensible Tests for Happiness
• 6 Ways to Remove Pain From Feature Testing in Ruby on Rails
• Moving Files from one Git Repository to Another, Preserving History
• Ruby Refactoring Cheatsheet
• Why cards are the future of the web
• How does Bundler do its magic?
• Michael Feathers: Avoid Null Checks by Replacing Finders with Tellers
• Tech companies: open allocation is your only real option.
• Programmers don’t need a union. We need a profession.
• Reading Rails - Concern
• Reading Rails - Migrations
• Life is a game. This is your strategy guide.
• Object Oriented Rails - Writing better controllers
• How Setting Aside Rails and Picking Up Padrino Might Make You a Better Ruby Developer
• Pry
• The Narcissism of Small Code Differences
• #275 How I Test - RailsCasts
• Slow Tests are the Symptom, not the Cause
• Back to Basics: HTTP Requests in Rails Apps
• Don't Stub the System Under Test
• Handling Associations on Null Objects
• Anti-Pattern: Iteratively Building a Collection
• Renderable Null Objects
• Why is it bad style to `rescue Exception => e` in Ruby?
• Comparing image with a capture with CasperJS
• Simple, Secure File Transmission
• PostgreSQL awesomeness for Rails developers
• HTTP and REST and Hypermedia
• Why I Did Not Go to Jail
• How to make your code imply responsibilities
• Rails Security Pitfalls
• Automating Flash, AJAX, Popups and more using Ruby, Watir and Sikuli
• propublica/upton
• rtomayko/replicate
• topfunky/gruff

Staq's Ruby Apprentice Program Was a Great Success!

Back in September 2013 we announced Staq's apprentice program, where we offered paid work to novice Ruby programmers. Today we're announcing that we just completed the program by hiring four of the apprentices who went through the program as full-time software developers at Staq!

Me, my partner James (2nd from left) and the new developers

Over the fall and winter we fielded many questions about how the training went, whether we will do it again, and so on, so I thought the Internet might like to find out how everything worked out.

We received over 100 applications from around the world, many of which were from very well-qualified candidates. I was very surprised at the number of people who had a strong computer science and engineering backgrounds, who saw this a chance to jumpstart their careers or re-engage with programming after a period of time doing something else.

We selected 12 candidates to attend in-person training sessions at our office in Hampden. We conducted four sessions of two hours each where we dived right in and showed the students the guts of how Staq's data extraction technology works, along with the basics of Ruby and rspec. In retrospect, our syllabus was far too ambitious; the next time we do this we will just focus on using Ruby to write web-and-API scrapers using mechanize and typhoeus, along with a gentle introduction to CasperJS. I should have introduced Staq's proprietary framework later in the process.

This experience also opened my eyes to the importance of good documentation: we have written a lot of specialty code that would be a lot easier to understand with good in-line documentation. So now everything we write includes extensive YARD annotations.

I regret not having more resources and time to devote to the training, since we're still a small company at this point. The next time we do this, I want to involve a professional Ruby trainer who could give more structure and rigor to the program (are you reading this, Jeff Casimir?). It would also be cool to coordinate our efforts with Betamore Academy. I wish I had been able to prepare a more thoughtful syllabus, or present in a less harried, rapid-fire manner, but such are the exigencies of startup life.

We chose five students to become Ruby apprentices, based on their performance during the training classes. The apprentices started out as hourly, part-time employees, who scheduled their work hours around other commitments. We started weekly training sessions for them (which every programmer in the company began attending), but most of the training was hands-on. The apprentices made many heroic contributions to our company, cleaning up messes, digging into details, writing critical revenue-generating code, and exhibiting great professionalism in a demanding, low-supervision work environment.

The apprentices graduated in January and we made full-time job offers to all five of them. One graduate decided to move to New York, and got a great job offer with a well-known, successful software company.  The other four accepted.

We absolutely will do this again, but we've got to grow the business some more first. Watch this space for details!