Ryan McGeary

Proper Counter Cache Migrations in Rails

2016-02-04T17:00:00-07:00

This post is less about the basics of counter_cache support in Rails and more about best practices for introducing a new counter cache to an existing project. More specifically, the goal is to detail the most efficient way way to create an ActiveRecord migration to support a new counter cache column.

The Problem

You see, the interweb is currently filled with some poor advice about how to seed a counter cache column.

Now that you’ve clicked on those examples, please erase them from your memory. Iterating over the entire table, loading each record into ruby-space (without batching, mind you), and relying on either update_counters or reset_counters in your migration is a sure way for your next deployment to take minutes to finish. It doesn’t take millions of records to get hit with this pain either.

The Example

Let’s assume that we have some stereotypical tables named posts and comments. Let’s also assume that we decided to add a comments_count counter cache column to the posts table.

The Migration

Given this example, your migration should look something like this:

class AddCommentsCountToPosts < ActiveRecord::Migration
  def change
    change_table :posts do |t|
      t.integer :comments_count, default: 0
    end

    reversible do |dir|
      dir.up { data }
    end
  end

  def data
    execute <<-SQL.squish
        UPDATE posts
           SET comments_count = (SELECT count(1)
                                   FROM comments
                                  WHERE comments.post_id = posts.id)
    SQL
  end
end

The Results

With over to 25,000 posts and 100,000 comments, using SQL will take seconds instead of minutes.

-- execute("UPDATE posts SET comments_count = (SELECT count(1) FROM comments WHERE comments.post_id = posts.id)")
   -> 1.3197s
   -> 26900 rows

Let’s compare that with how long it would have taken if we used a Post.reset_counters approach:

-- Seeding posts.comments_count -- Better grab a coffee.
   -> ...........................
   -> 144.7302s
   -> 26900 rows

Here is the actual code used to run these two examples.

The Moral

Sometimes SQL can be straightforward and fun.

Reverse Engineering an American Express USB WebKey

2015-05-25T18:00:00-06:00

I received a strange piece of hardware in the mail the other day. American Express is piggy-backing on LegalZoom document deliveries with an interesting piece of marketing – a USB key-like device in the shape of a credit card.

Thinking it was a USB drive and one that I might be able to format and reuse for something else, I plugged it in to my Mac. To my surprise, it immediately opened Safari and a website pointing to an American Express credit card offer. Huh? I thought OS X didn’t have Autorun support. So, of course, I tried it again. This time, I noticed that the address bar in Safari scrolled as if someone was typing really fast.

Holy trickery, Batman. It’s mimicking a USB keyboard!

Here are the steps that it takes:

⌃F3 to focus the Dock
Types: Safari
return to launch Safari
⌘L to focus the address bar
Types: http://www262.americanexpress.com/landing-page/business-cards/sclp/bgold/aff0022/44460?PID=15&BUID=SBS&PSKU=BGR&CRTV=LZBGRLTOWBKYREF15
return to launch site

NOTE: If Safari isn’t running or pinned to your Dock, the entire process fails. They probably would have been better served to start with ⌘-space and a Spotlight search instead.

Digging In

My curiosity was piqued, and this reminded me of the USBdriveby project that Samy Kamkar discussed on a recent Tim Ferriss podcast.

I wondered if I could reprogram this American Express USB device to behave in a similar way as the Teensy USB Microcontroller that Samy used.

"AmEx USB Stick" snapped from it's marketing enclosure.

Teensy 3.1

Find the USB Device

First, let’s see what OS X thinks about this USB device. We’ll do that by inspecting all USB devices both before and after plugging in the USB key. The difference will help us find the device itself.

system_profiler SPUSBDataType > ~/usbout.txt
system_profiler SPUSBDataType > ~/usbin.txt
diff ~/usbout.txt ~/usbin.txt

This should yield a result like the following:

33a34,44
>         WEBKEY:
>
>           Product ID: 0x6662
>           Vendor ID: 0x05ac  (Apple Inc.)
>           Version: 8.15
>           Speed: Up to 12 Mb/sec
>           Manufacturer: TP6662
>           Location ID: 0x14500000 / 27
>           Current Available (mA): 500
>           Current Required (mA): 100

Note the Product ID and Vendor ID values. We’ll need those later.

I find it fairly suspicious that it mimics hardware from “Apple Inc.” Kinda sketchy.

Now What?

At this point, I was immediately stuck, but after some research, I found a superuser question on Stack Exchange titled Can I “reprogram” an American Express USB drive? No direct answers, but this answer gave me hope:

It consists of a Cypress PSoC controller, combined with a 24c02 serial eeprom … With a simple program called PonyProg you can read and modify the contents of the eeprom. http://superuser.com/a/216810/8424

I spun my wheels for a long while with no luck, but later, I found an article titled Hacking USB Webkeys. This looked promising.

Hardware Surgery (and Failure)

I slowly pried the chip from it’s plastic enclosure. It was attached with some glue.

"AmEx USB Chip" torn from it's plastic enclosure.

Sweet. Contact points that I should be able to use to access the EEPROM.

All seemed well, until I tested the webkey again. I must have damaged something, because it now skips every 5th to 8th character as it emulates a keyboard. Shoot. Maybe next time.

Let’s [Pretend to] Read all the EEPROM

Disclaimer: I wasn’t able to test any of this, because I damaged my hardware, but I encourage others to carry on where I left off and let me know if you have any success!

As it turns out, PonyProg (the program mentioned on the Stack Exchange post) doesn’t work on OS X, but I found a program called ch341eeprom that claimed to perform a similar task.

It depends on the WinChipHead CH341A.

WinChipHead CH341A

It also depends on libusb, so let’s install that using Homebrew and then clone the repository so we can compile ch341eeprom.

brew install libusb
git clone https://github.com/commandtab/ch341eeprom.git
cd ch341eeprom

Compile, and try to read the eeprom:

make
ch341eeprom -v -s 24c02 -r ~/eeprom.bin

Conclusion

While my attempt at hacking this hardware resulted in catastrophic failure, don’t let that stop you from trying something new or breaking down an unknown piece of tech. I learned a lot during this little investigative project, and if I find another free marketing webkey in the mail, I just might pick-up where I left off.

Rejuvenating My Piece of the Interwebs

2015-05-21T18:00:00-06:00

This is something that I’ve wanted to do for a long time, and I was finally able to get my site redesigned and relaunched this week. The old design made it 5 years.

New, Responsive, and Light:

Old, Rigid, and Dark:

The old design served me well, but it had a few problems. For one, it didn’t work well on small mobile browsers. Now, it’s much more responsive to all browser sizes. I also used to get complaints about my big headshot in the bottom right corner. While that self-promotion-marketing-hack helped people recognize me at conferences and events, I think it freaked out some of the more scopophobic readers amongst us. My headshot-hack remains, but I now hide away when you start scrolling. For what it’s worth, my 3-year-old daughter thinks it’s fun to play peek-a-boo with it, so there’s that.

I think the new site design still needs some extra work, but it’s good enough to launch and start gathering feedback for now.

What Changed?

This was basically a total rewrite. A lot has changed, but here are some of the key updates:

Responsiveness: Better views, font-sizes, and readability across all browser sizes.
No More Comments: Yup, I dropped all my disqus comments. This might upset some, but it is going to make my life just a little bit better. Instead, I’ve enabled Twitter’s Web Intents at the bottom of each page. You can now reply to me via Twitter. For old posts, I did my best to find my original tweet about the post. For new posts, I’ll do my best to keep everything synchronized.
Jekyll to Middleman: The original site was statically generated by Jekyll. Jekyll 2 made a lot of great improvements, and I’m sure Jekyll 3 will continue that trend, but Middleman has just always felt so much cleaner to me; it’s organized in a way that I like to work. Plus, it’s easier for me to standardize on one static site generator across the sites that I maintain, and I honed in on Middleman well before Jekyll v2 launched.
Twitter Card and Open Graph Support: You know those nice catchy pictures you get when you share a website on social media? Yeah, I got that. Learn more about Twitter Cards and Open Graph.

What’s Next?

I have a lot of little plans for this site, including doing a better job of promoting the things that I work on day-to-day, but in general, I hope the redesign also rejuvenates my desire to publish new relevant content about programming, the web, business, entrepreneurship, tech, etc. No promises, but that’s the goal.

Let me know what you think. Enjoy!

Talk: Cloud Services You Should Be Using To Build Your Startup

2015-05-11T18:00:00-06:00

BOULDER, CO — Boulder Ruby — I had the opportunity to present at Boulder Ruby during Boulder Startup Week 2015. I covered several online services that not only have excellent Ruby support, but also can help accelerate your MVP and/or product launch. The finale included a live demo of Cloudinary, Pusher, and Embed.ly services.

Recommended Services to Boost Development

Recommended Services to Boost Ops

Heroku
New Relic / AppSignal
Rollbar / Honeybadger
Papertrail
StatusPage.io
Pingdom / StatusCake / Uptime Robot / Monitority
DNSimple / DNS Made Easy / Dyn

HTML5 Autocomplete Cheatsheet

2014-08-19T18:00:00-06:00

I was recently frustrated with the documentation on the HTML5 autocomplete attributes and Chrome’s response with the x-autocompletetype vendor specific attribute.

These attributes are typically used on <input> elements to better signal to the browser the best way to “autofill” a form. The problem, however, is that there is no official standard yet, and there are mild differences between values used for autocomplete and values used for x-autocompletetype.

The best documentation I could find on autocomplete types was on whatwg.org, but the formatting made it a bit difficult to easily see what types were available/recommended.

Hence, this cheatsheet was born. Let me know if it helps.

Talk: The BusyConf Story

2014-02-18T17:00:00-07:00

ST PETERSBURG, FL — 1 Million Cups - STP — I had the chance to tell a bit of the story behind BusyConf while also gleaning some advice from fellow entrepreneurs.

More about 1 Millions Cups

Co-Hosting Ruby5 Episode 438

2014-02-06T17:00:00-07:00

As I’m planning to move my fmaily soon, this will probably be the last time I have the opportunity to co-host Ruby5 with Chris Mar.

Check out episode #438.

Interview with #EventTech Podcast

2013-12-19T17:00:00-07:00

In this episode, we talk with Ryan McGeary CEO & Founder of BusyConf about conference registration, mobile event apps, HTML vs. native event apps and more.

Ryan McGeary, CEO & Founder, BusyConf

Continuous Integration and Deployment with Middleman, Codeship, and GitHub Pages

2013-12-18T17:00:00-07:00

I use GitHub Pages for hosting some of my websites, and I use the Middleman static site generator as my content management system for some of these sites.

I like to run continuous integration for my projects whenever possible, and this goes for static site repositories as much as regular code repositories.

Recently, I started playing with Codeship. It’s a well-priced continuous integration and deployment service, and I wanted to be able to automatically deploy my middleman site upon successful builds to the master branch. It took a bit of trial and error, but I finally got something that works well.

Test Settings

After initializing a new GitHub repository in Codeship, you’ll need to define how tests are run. Under the Test project settings in Codeship, select Ruby as the language and define your Setup Commands and Test Commands.

Setup Commands:

bundle install

Test Commands:

bundle exec middleman build

Perfect. Now your site will run a test build upon every code push.

Deployment Settings

This is where I had some trouble, but I finally found a set of commands that correctly deloyed to our gh-pages branch in the repository. First, it’s worth mentioning that I use the middleman-gh-pages gem for deploying to the gh-pages branch. This gem gives you a rake publish task that handles most of the dirty work.

Under the Deployment project settings in Codeship, configure a deployment from the master branch using a Custom Script.

Custom Script:

git config --global user.email "robot@example.com"
git config --global user.name "Codeship Robot"
rm -rf build
git remote set-branches --add origin gh-pages
git fetch
bundle exec rake publish
sleep 30
wget --retry-connrefused --no-check-certificate -T 60 http://yoursite.com/

This configures a git user, removes the build directory that was left there from the test steps, adds a gh-pages remote branch (because Codeship only clones the relevant branch during setup), and runs the rake publish task to deploy the site to the gh-pages branch.

If all went well, your site will automatically deploy to GitHub Pages upon a push and successful build in the master branch.

GitHub Publishing Caveat

Make sure the email address that you use for this git user is a verified email address in your GitHub account. Otherwise, GitHub will accept the commit, but it will not publish the changes to your site. To fully make everything work, you will need to do one of two things: 1) Move the Codeship deploy key to an SSH key in your own GitHub account OR 2) Create a new machine user on GitHub and move the Codeship deploy key to an SSH key on that user account, give that machine user push/pull access to the repository, and make sure that machine user’s email address is fully verified by GitHub. I highly recommend going with option #2.

Extra Credit: Force Codeship to skip builds on the gh-pages branch.

Unfortunately, Codeship currently tries to run builds on all branches, including the gh-pages branch. This is undesirable for this setup, so to avoid this, we also need to add “–skip-ci” or “[skip ci]” to the commit message that is pushed to the gh-pages branch.

Fortunately, after this pull-request by yours truly, middleman-gh-pages can support that.

If using version >= 0.0.3 (or the master branch), you can add this to the bottom of your project’s Rakefile:

# Ensure builds are skipped when pushing to the gh-pages branch
ENV["COMMIT_MESSAGE_SUFFIX"] = "[skip ci]"

TEDx Talk: What makes someone Successful?

2013-12-04T17:00:00-07:00

LEESBERG, VA — TEDxBalchDriveWomen 2013 — Software — “Luck” is too often attributed to one’s success. Let’s cut the modesty and tell better stories about the good and bad decisions that got us where we are. No one can learn from your success if you merely attribute it to “luck.”

Disclaimer: I was asked to give this talk at the very last minute. I’m happy with the message, but I’m a little disappointed in the delivery. I wish I had more time to prep for my first TEDx presentation.

Co-Hosting Ruby5 Episode 389

2013-07-25T18:00:00-06:00

It was time to co-host Ruby5 again but this time with Chris Mar.

Check out episode #389.

Talk: Asynchronous Collaboration

2012-11-08T17:00:00-07:00

(video)

MALMÖ, SWEDEN — Øredev Developer Conference 2012 — Communicating Through Our Source Code. We hear a lot about how strong communication and collaboration are key to a successful project. We spend a lot of time focusing on stand-up meetings and pair programming, but there are potentially other very effective means of keeping the team on the same page that not only avoid daily interruptions but also provide long-term benefit.

The goal of this talk is to help your team improve its own collaboration and productivity with just a bit of discipline and relatively low overhead.

Watch the Video [vimeo]

Disable Chrome's Print Dialog and Use the OS X System Dialog Instead

2012-09-12T18:00:00-06:00

I really dislike the custom print dialog that ships with Google Chrome nowadays (Chrome is currently at v21 at the time of writing). By itself, it’s not terrible, but I want my print dialog to look like every other darn print dialong on OS X, gosh dammit.

When Google first introduced the new print dialog, Chrome also included a custom setting to disable it under about:flags, but in v20, Chrome removed the ability to disabled the print dialog.

There are a couple workarounds on the internet like starting Chrome with an --args --disable-print-preview, but that’s not too feasible under normal conditions. Other solutions recommend using ⌘⌥P or hold down Option (⌥) when accessing the File menu, but who wants to remember to use a different keyboard shortcut for just one application?

Fortunately, OS X comes with a relatively simple way to override keyboard shortcuts in specific Applications. Go to System Preferences -> Keyboard -> Keyboard Shortcuts. Once there, select Application Shortcuts and add a new shortcut for Google Chrome.

Make sure the Menu Title reads Print Using System Dialog... exactly, and give it the standard print shortcut (⌘P).

Enjoy! Happy Printing!

UPDATE: There’s another workaround that’s relatively painless and works well. Open up Terminal and override the setting at the command line:

defaults write com.google.Chrome DisablePrintPreview -boolean true

This works, but also completely disables the Chrome print dialog altogether, so there’s no way to use it with a different keyboard shortcut in case you want to test the default behavior that most others experience.

Co-Hosting Ruby5 Episode 290

2012-07-19T18:00:00-06:00

I was fortunate to have another opportunity to co-host Ruby5 with David Bock this week.

Check out episode #290.

MongoDB Schema Design at BusyConf

2012-06-04T18:00:00-06:00

This post is in response to the 10gen MongoDB Schema Design Contest. It was also extracted from talks that I’ve given on the subject.

UPDATE: MongoDB awarded this entry the grand prize in the design contest.

Obligatory Plug

BusyConf currently handles 4 major pieces of conference planning – it collects speaker proposals, allows the review committee to rate speaker proposals, builds an offline-enabled and archived HTML5 schedule (iPhone, Android, iPad, Desktop), and handles attendee ticket registration including payments, refunds, etc.

We attend conferences, and as attendees, the schedule at the conference is often lacking. It’s poorly organized, lacks information, and requires Internet access. This makes it hard as an attendee to choose the talks that you want to go to. BusyConf is an attempt to solve that problem while also making it easier for conference organizers to run a conference. We handle the calls for proposal, we allow organizers to rate proposals, we give them an interface to turn activities into a schedule, and we publish that schedule in many formats. We also handle ticket registration and credit card payments.

Why MongoDB?

MongoDB was a huge win for us while designing our application. The goal of this post is to explain why we chose MongoDB, how we use it at BusyConf, what design decisions we considered, and what the alternatives might have been.

Here’s a common myth that I’ve heard before: “MongoDB design is easy because its schema-less.” I disagree with this. It’s true that a thoughtful design will yield a longer term gain in easier development, but it can be tricky to conjure up with such a design. I find it much easier to get a relational design right the first time, but the costs of maintaining a relational design can sometimes be higher.

“You could use a relational database for that! Why use a document store?”

MongoDB’s speed and scalability are wins, but for us, it’s not as important as the win we get from rapid development. Rapid development comes from the ability to represent richer data models that more closely match the business problems and the patterns of access.

Many people say things like: “You could use a relational database for that! Why use a document store?” MongoDB has become our default database for greenfield development. We now make ourselves justify the use of relational. Instead of, “Why MongoDB?” we ask, “Why NOT MongoDB?”

The Logical Model

This post only covers the design of our database that represents a conference schedule. The data model that represents a conference schedule is roughly a tree – very nested. Imagine a typical conference or convention that you attended in the past. Events have days, days have tracks, tracks have time slots, time slots have activities, and activities have speakers. In addition, days can also have global time slots (like Lunches, Breaks, and Keynotes).

When we access our data for rendering a schedule, we need to pull all of this at once, because we want a seamless, cached experience for the conference attendee.

The Relational Option

What might the above logical model look like in a relational database? The nice thing about a relational model is that they are fairly easy to design. This is how we might have modeled our data given a relational database.

What kind of queries would be required to pull all the data from this design?

It looks pretty straight forward until you imagine having to pull all this data at once to render a full schedule. What kind of query or queries would be required from a relational database? Would you use one big nasty join, or lots of individual queries? Neither seem like a great option.

To add to the problem, little things like the position of tracks are not easily represented. Neither is the potential explosion of meta data that could come from each object.

First Attempt with MongoDB

Representing our logical model directly within MongoDB was our first instinct, BUT putting this into practice actually led us down a road of unnecessary complexities:

This first attempt was a mistake.

While we solved the problem of quickly accessing the entire event, we no longer have an easy way of accessing an individual activity or speaker. We can quickly see the complexities in the drawing above.

Current Design with MongoDB

We iterated on the design many times, but in the end, we took a fairly unique approach.

Instead of one collection, we broke out Activities and Speakers.¹ This matched our patterns of access much better. Instead of deeply nesting every object, we chose to embed arrays of days, tracks, and time slots immediately under the event document.

Each object has a unique ID. Everything is more easily addressable, because we have less nesting. The logical model is represented with pointers from one nested document to another. Of course, we don’t actually see our logical model until we piece it together on the client side, but that is okay because we don’t need the full logical model until until we put the leg work in to render the schedules in the browser.

Conclusion

MongoDB can be somewhat tricky when it comes to the up front design, but if done right, it has some great benefits both in defining and matching your unique access patterns along with fairly decent long-term maintenance benefits.

Later, we decided to embed Speakers under Activities to improve our patterns of access, but ironically, we plan to switch Speakers back out to their own collection again to provide cleaner normalization. ↩

Reserving Subdomains in Your Multi-Tenant Web Application

2012-05-06T18:00:00-06:00

It’s fairly common to segment the accounts in your multi-tenant application with subdomains. GitHub gives you a subdomain that matches your username (e.g. rmm5t.github.io). Freshbooks gives you a subdomain that matches your company name (e.g. busyconf.freshbooks.com). At BusyConf, we give you a subdomain that matches your conference name (e.g. railsconf2012.busyconf.com).

Your customers usually get to choose their own subdomain during account sign-up, and when developing a subdomain-based multi-tenant application, it easy to forget to reserve some common subdomains for your own use and future growth. There’s nothing like trying to register a new service only to realize that one of your customers already has the subdomain that you had hoped to use.

It’s a good idea to make a list of subdomains that you don’t want your customers to use. Here’s a list of subdomains that I like to reserve in my multi-tenant applications:

admin, api, assets, blog, calendar, camo, dashboard, demo, developer, developers, docs, files, ftp, git, imap, lab, m, mail, manage, mx, pages, pop, sites, smtp, ssl, staging, status, support, www

What subdomains are missing from this list?

In terms of an ActiveModel validation in Rails, that looks something like this:

RESERVED_SUBDOMAINS = %w(
  admin api assets blog calendar camo dashboard demo developer developers docs files ftp git imap lab m mail manage mx pages pop sites smtp ssl staging status support www
)
validates_exclusion_of :subdomain, :in => RESERVED_SUBDOMAINS,
                       :message => "Subdomain %{value} is reserved."

Talk: Just In Time Inventory with Spree

2012-02-15T17:00:00-07:00

NEW YORK, NY — SpreeConf 2012 — In this talk, we will not only explore what it takes to extend Spree, but we will also experiment with the notion of using it to build our products on demand. We will take Spree, slap a MakerBot on the backend, build some extensions, and build a store that automatically prints products only after an order is placed.

Were you there? Please rate my talk.

Here’s the montage video that was shown during the presentation.

Talk: HTML5 Application Caching

2012-02-01T17:00:00-07:00

MCLEAN, VA — MoDevDC — At BusyConf, we leverage offline application caching so your schedule is available even after losing an internet connection.

Caching can be hard, and the application cache can be a bit confusing to wrap your head around. This talk tries to bring a little bit of sanity to that area.

How To Add a DNSimple SSL Certificate to Heroku

2011-09-15T18:00:00-06:00

DNSimple has some of the best prices on SSL certificates. If you have a DNSimple account, perfect, you already know how useful it is. If not, go sign up now, and then come back.

1. Buy an SSL Cert from DNSimple

The first thing to do is to buy an SSL cert from DNSimple (I usually only buy wildcard certs nowadays). Go to the manage interface for the domain that you want to buy the SSL cert, and click “Buy an SSL Certificate.” The interface will walk you through the rest of the steps. As long as you’re not super paranoid, you can even let DNSimple generate the private key and certificate signing request for you. Don’t worry, you can delete the private key from the DNSimple servers immediately after you save it to a secure place.

After a few minutes, you should receive some emails with your new SSL cert (a resulting wildcard certificate will actually come from Comodo).

2. Build the Public Certificate Chain PEM file

UPDATE: If you downloaded the certificate chain directly from Comodo, the steps below are necessary; however, now if you log back into DNSimple, they now perform this nonsense for you automatically. Just download the pre-concatenated certificate bundle and private key directly from DNSimple and follow the instructions for adding or updating your cert (i.e. Skip to step 3). Thanks DNSimple!

Along with your SSL certificate, Comodo will send a zip file containing the Root CA Certificate and some Intermediate CA Certificates. Before we can upload our certificate to Heroku, we need to concatenate these files together to form the certificate chain.

cat STAR_yourdomain_com.crt EssentialSSLCA_2.crt   \
    ComodoUTNSGCCA.crt UTNAddTrustSGCCA.crt        \
    AddTrustExternalCARoot.crt > STAR_yourdomain_com.pem

Make sure you concatenate these files in the correct order, starting with your cert and ending at the root cert; otherwise, Heroku will not be able to recognize the result as a public key certificate.

This example shows the chain for a wildcard certificate (from Comodo). Your chain might be different if you purchased a single subdomain certificate from DNSimple (I think those come from RapidSSL, which might deliver root certs).

Note: To make sure Heroku can automatically start your server, you must not have a passphrase assigned to the certficate. If you let DNSimple do all the work for you, you should already have a passphrase-free cert.

3. Add the SSL Endpoint Add-on to Your App

heroku addons:add ssl:endpoint

Read more about the SSL Endpoint Add-on.

4. Upload your SSL Cert and Private Key to Heroku

heroku certs:add STAR_yourdomain_com.pem STAR_yourdomain_com.key

That’s it! You can find more information and instructions on what to do after this from the Heroku Dev Center.

If you instead need to update an existing cert, use the cert:update command. This prevents you from having to update your DNS settings:

heroku certs:update STAR_yourdomain_com-bundle.pem STAR_yourdomain_com.key

Lightning Talk: Do Your Commit Messages Suck?

2011-09-01T18:00:00-06:00

BOULDER, CO — Rocky Mountain Ruby 2011 — Software projects are collaborative. They usually encompass many months or years and are touched by several developers along the way.

Communication is key to any good software project. Strong, well written, commit messages are one way to increase communication and documentation with very little overhead.

The project history plus a strong blame engine give us the power to answer future questions about what we were thinking at the time something was added or changed.

Watch the Talk

Download the Slides [PDF 7.8 MB]

Were you there? Please rate my talk.

Co-Hosting Ruby5 Episode 186

2011-06-23T18:00:00-06:00

I had the opportunity to co-host Ruby5 with David Bock this week. It was a fun time.

Check out episode #186.

Keep Your Hostname on Public WiFi Networks

2011-04-21T18:00:00-06:00

Have you ever joined a public WiFi network only to have your hostname change to something seemingly random? While hacking with Wayne Seguin last night on a hotel network, he ran into this exact problem on OS X, and it reminded me of a workaround that I learned about a few years ago.

Some networks have their DHCP server configured to assign hostnames for all machines that connect to it. OS X respects this and will reassign your hostname automatically. I suspect this is to help avoid name collisions on the network, but if you want to prevent OS X from doing this, there is a workaround.

Open /etc/hostconfig and add the following line:

HOSTNAME=<your-preferred-hostname>.local

Afterwards, OS X will no longer respect the DHCP command to reassign the hostname. This is especially helpful if you have scripts that rely on your hostname being set to something specific.

Talk: Introduction to CoffeeScript at Red Dirt RubyConf

2011-04-20T18:00:00-06:00

OKLAHOMA CITY — Red Dirt RubyConf — I discovered CoffeeScript during a recent project that Jim Garvin and I were working on. We knew the app was going to be heavy on the JavaScript, and that’s how we started – writing straight JavaScript. Even though I have written JavaScript for years, this time, the JavaScript syntax itself got in the way. CoffeeScript’s elegant syntax relieved the burden.

I quickly fell so in love with CoffeeScript that I have since sworn off writing raw JavaScript directly ever again. The goal of this talk is to convince the audience to try CoffeeScript in hopes that they too will find it as valuable as I did.

Download the Slides [PDF 29.0 MB]

Were you there? Please rate my talk.

Talk: One Man Lightning Talks

2011-04-01T18:00:00-06:00

RESTON, VA — RubyNation 2011 — To celebrate the NovaRUG’s 50th meeting, they opened the floor to lightning talks. As an added incentive, the highest voted lightning talk was to be given a speaking slot at RubyNation 2011. I guess bringing my friends and family paid off that day. In the spirit of that event, I gave back-to-back lightning talks on a wide range of topics, including:

Do Your Commit Messages Suck?
“Vendor Everything” Still Applies
CoffeeScript: Exposing the Good Parts of JavaScript with Better Syntax
How We Use MongoDB at BusyConf
HTML5 Application Caching

Download the Slides [PDF 25 MB]

Watch the Video [blip.tv]

Were you there? Please rate my talk.

Interview with IBM developerWorks

2011-02-23T17:00:00-07:00

In December, I was interviewed by Andy Glover for the IBM developerWorks podcast. Today, that interview was published.

I talked about CoffeeScript, JavaScript, jQuery, Sencha Touch, QUnit, Jasmine, node.js, MongoDB, and my new venture BusyConf.

Ryan McGeary on CoffeeScript

“Vendor Everything” Still Applies

2011-02-08T17:00:00-07:00

UPDATE: Since writing this post, I have since switched to using rbenv for my ruby version management. I no longer use RVM. Rbenv lends itself nicely to the workflow described here, and some of the workflow below has been modified to reflect that. RVM instructions are still included though.

That’s right. The title is a homage to the (now defunkt) err the blog, and keeping your application dependencies with your application is still a very good thing.

As a consultant, I jump between a lot of different Ruby projects from day to day. Some are my own; some are owned by others. Some are greenfield; some are legacy. Sometimes, I’m the sole developer; sometimes, I’m working with a team.

There’s nothing more frustrating than jumping on an existing project only to fall into dependency hell when your first goal is just a passing test suite. Dependencies can be quite difficult to manage, and fortunately, we have some great tools like Bundler and rbenv to help out. The problem, however, is that we as a community have not fully standardized on the best set of conventions surrounding these tools.

Disclaimer: The set of conventions described here apply to Ruby applications only. This includes Rails apps, Sinatra apps, or other Ruby applications that aren’t deployed in the form of a gem.

Do Check Your `.ruby-version` into Version Control

Your .ruby-version file is an important piece of documentation.

For applications, your .ruby-version file is an important piece of documentation. I think this is the best way to communicate the Ruby version dependency to other team members. This is especially true given that these files at the root of your project will make rbenv or RVM automatically use that version of Ruby when you’re in that project directory.

I recently inherited a project that had a test suite with very little coverage and no documentation as to which version of Ruby was required. I could tell the project wasn’t on Ruby 1.9 yet, so I guessed at Ruby 1.8.7. It wasn’t until much later that I realized Ruby 1.8.6 was actually required. For another legacy project that I worked on, we guessed correctly at Ruby 1.8.7, but it wasn’t until we went to deploy and took a look at the production environment that we realized we should have been developing against Ruby Enterprise Edition (REE) instead of MRI.

Note: When this post was first written, I advocated checking in your .rvmrc file, because at the time, that was the only way to specify your ruby version. That was controversial, because an .rvmrc could potentially contain personal preferences (that I didn’t think belonged in that file). Things have changed, and .ruby-version is the way to go regardless of your chosen ruby version manager.

Stop Using RVM Gemsets For Your Applications

Please stop using RVM gemsets for your applications. Seriously. The original title of this post was going to be, “RVM Gemsets are overrated,” but that seemed too much like flamebait, and I didn’t want anyone to miscontrue my overall point.

RVM is absolutely one of the best things that has hit the Ruby community in recent history, and RVM gemsets are a great tool. It’s just that I see too many applications rely on the use of gemsets when it yields no added benefit. I understand why people do it; they don’t want to pollute their default gemset, but this reliance on gemsets for applications is totally unnecessary. It also seems to be a common point of confusion amongst teams.

There is a better way, that still doesn’t pollute the default gemset, and it includes a lesser known feature of Bundler.

Let Bundler Follow the `--path`

Bundler alleviates the need for different gemsets per project.

It is possible to install application dependencies cleanly without relying on an RVM gemset. I like to install all application dependencies into a gitignored directory within the application itself. This not only alleviates the need for different gemsets per project, but it also gives us a quick and easy way to jump into the source code of any one of our gem dependencies. We can do this with the --path option passed to bundle install. Here’s the convention I like to use:

bundle install --path vendor
echo 'vendor/ruby' >> .gitignore

After running this, all gems (and gems pulled directly from git repositories) will be unpacked into the vendor/ruby directory of your project. It’s a good idea to ignore this directory from version control.

This one step removes the need to create a custom RVM gemset for any of your applications, and it ensures that your default gemset is never polluted by application dependencies. This way, Bundler completely isolates the gems from the system, guaranteeing a clear set of dependencies.

Package Your Gems in `vendor/cache`

For applications, I cannot emphasize enough how beneficial it is to keep all of your gem dependencies with your application. I’m not just talking about a Gemfile and Gemfile.lock¹, but I’m also talking about the gems themselves. Bundler allows you to save all of your gems in a vendor/cache directory after running bundle package. It ensures the gems are available without having to sync with a gem server.

bundle package

I’ve seen resistance to this practice, but the only arguments against it usually refer to taking up too much space in version control. That argument is poppycock. Storage is cheap. You’ll thank me later when your deployments run smoothly, and when several years from now, an otherwise missing gem is at your fingertips. Not to mention, having all your gems in vendor/cache makes bundle install run faster both for new team members and in your continuous integration environment. Deployment environments like Heroku really benefit from this practice too.

How Can I Remember All of This?

Here are some command line aliases that help me:

alias b="bundle"
alias bi="b install --path vendor"
alias bil="bi --local"
alias bu="b update"
alias be="b exec"
alias binit="bi && b package && echo 'vendor/ruby' >> .gitignore"

Any time I jump into a new project that already has a Gemfile, I merely need to run bi and the gems are installed in an application specific location (vendor/ruby) without the need for a custom RVM gemset. Anytime I’m starting a new project or trying to convert an old project to these new conventions, I just run binit, which installs and packages the gems within the application while also gitignoring the vendor/ruby directory.

TL;DR

Check your .ruby-version file into version control; it’s a form of documentation.
Avoid RVM gemsets for your applications; Bundler solves the same problem in a better way (bundle install --path vendor).
Keep a cache of your gem dependencies in version control using bundle package.
This only applies to Ruby applications; gem development is a different beast.

bundle install --path vendor
bundle package
echo 'vendor/ruby' >> .gitignore

By the way, for applications, please do check your Gemfile.lock into version control. For libraries/gems, please do not check it in, and please add Gemfile.lock to your .gitignore file for the project. ↩

Interview with Life of the Freelancer

2011-01-03T17:00:00-07:00

A couple months ago, I was interviewed by Robert Dempsey at LifeOfTheFreelancer.com. I almost missed it, but that interview was published last week.

I talk about my past experiences, lessons learned, successes, failures, and things I’m focussing on now.

Transform Ideas into Software Reality

Working with OS X and Emacs

2011-01-02T17:00:00-07:00

</param></param></param></embed>

I’m being featured this week on a new site called How I Work. The site is about letting developers watch screencasts to see how other people work and improve their productivity by learning about new tools and practices. Given the interest in how focused work in an all inclusive environment can help productivity, they contacted me about putting up a workbench on how I use Emacs and how it fits into my overall OS X workflow.

They’ve also got some other cool featured content. Zach Holman who works at github and is known for lots of cool hacks like facelette, boom, etc talks about Automating Inefficiencies. The guys from thoughtbot demo Hoptoad and explain how it can help your development team stay on top of production problems.

Please check it out and vote up my video so other people learn about me and McGeary Consulting Group.

Talk: How we use MongoDB at BusyConf

2010-12-13T17:00:00-07:00

WASHINGTON, DC — MongoDB Users Group — Jim Garvin and I attend conferences, and as attendees, the schedule at the conference is often lacking. It’s poorly organized, lacks information, and requires Internet access. This makes it hard as an attendee to choose the talks you want to go to. BusyConf is an attempt to solve that problem while also making it easier for conference organizers to run a conference. We handle the calls for proposal, we allow organizers to rate proposals, we give them an interface to drag-n-drop activities onto a schedule, and we publish that schedule in many formats.

MongoDB was a huge win for us while designing our application. The goal of this talk is to explain why we chose MongoDB, how we use it at Busyconf, what design decisions we considered, and what the alternatives might have been.

Download the Slides [PDF 2.2 MB]

Were you there? Please rate my talk.

Talk: CoffeeScript at DCRUG

2010-12-08T17:00:00-07:00

WASHINGTON, DC — DCRUG — I discovered CoffeeScript during a recent project that Jim Garvin and I were working on. We knew the app was going to be heavy on the JavaScript, and that’s how we started – writing straight JavaScript. Even though I have written JavaScript for years, this time, the JavaScript syntax itself got in the way. CoffeeScript’s elegant syntax relieved the burden.

Download the Slides [PDF 23.0 MB]

Were you there? Please rate my talk.

Talk: CoffeeScript at 757rb

2010-10-31T18:00:00-06:00

NORFOLK, VIRGINIA — 757rb — I discovered CoffeeScript during a recent project that Jim Garvin and I were working on. We knew the app was going to be heavy on the JavaScript, and that’s how we started – writing straight JavaScript. Even though I have written JavaScript for years, this time, the JavaScript syntax itself got in the way. CoffeeScript’s elegant syntax relieved the burden.

Download the Slides [PDF 24.6 MB]

Were you there? Please rate my talk.

Lightning Talk: CoffeeScript at NovaRUG

2010-10-20T18:00:00-06:00

RESTON, VIRGINIA — NovaRUG — I discovered CoffeeScript during a recent project that Jim Garvin and I were working on. We knew the app was going to be heavy on the JavaScript, and that’s how we started – writing straight JavaScript. Even though I have written JavaScript for years, this time, the JavaScript syntax itself got in the way. CoffeeScript’s elegant syntax relieved the burden.

Download the Slides [PDF 17.8 MB]

Were you there? Please rate my talk.

My Remember The Milk Conventions

2008-01-01T17:00:00-07:00

UPDATE (late 2008): I no longer use Remember The Milk as my GTD tool, but I still recommend similar types of conventions that were applied here. I leave this screencast here in hopes that others still find it valuable.

I’m often asked about the conventions I use to Get Things Done with RememberTheMilk.com. I found it a little too difficult to put into words, so I took a stab at this screencast instead.

Watch the full res version instead.

Ryan McGeary

Proper Counter Cache Migrations in Rails

The Problem

The Example

The Migration

The Results

The Moral

Reverse Engineering an American Express USB WebKey

Digging In

Find the USB Device

Now What?

Hardware Surgery (and Failure)

Let’s [Pretend to] Read all the EEPROM

Conclusion

Rejuvenating My Piece of the Interwebs

New, Responsive, and Light:

Old, Rigid, and Dark:

What Changed?

What’s Next?

Talk: Cloud Services You Should Be Using To Build Your Startup

Recommended Services to Boost Development

Recommended Services to Boost Ops

HTML5 Autocomplete Cheatsheet

Talk: The BusyConf Story

Co-Hosting Ruby5 Episode 438

Interview with #EventTech Podcast

Continuous Integration and Deployment with Middleman, Codeship, and GitHub Pages

Test Settings

Setup Commands:

Test Commands:

Deployment Settings

Custom Script:

GitHub Publishing Caveat

Extra Credit: Force Codeship to skip builds on the gh-pages branch.

TEDx Talk: What makes someone Successful?

Co-Hosting Ruby5 Episode 389

Talk: Asynchronous Collaboration

Disable Chrome's Print Dialog and Use the OS X System Dialog Instead

Co-Hosting Ruby5 Episode 290

MongoDB Schema Design at BusyConf

Obligatory Plug

Why MongoDB?

The Logical Model

The Relational Option

First Attempt with MongoDB

Current Design with MongoDB

Conclusion

Reserving Subdomains in Your Multi-Tenant Web Application

Talk: Just In Time Inventory with Spree

Talk: HTML5 Application Caching

How To Add a DNSimple SSL Certificate to Heroku

1. Buy an SSL Cert from DNSimple

2. Build the Public Certificate Chain PEM file

3. Add the SSL Endpoint Add-on to Your App

4. Upload your SSL Cert and Private Key to Heroku

Lightning Talk: Do Your Commit Messages Suck?

Co-Hosting Ruby5 Episode 186

Keep Your Hostname on Public WiFi Networks

Talk: Introduction to CoffeeScript at Red Dirt RubyConf

Talk: One Man Lightning Talks

Interview with IBM developerWorks

“Vendor Everything” Still Applies

Do Check Your .ruby-version into Version Control

Stop Using RVM Gemsets For Your Applications

Let Bundler Follow the --path

Package Your Gems in vendor/cache

How Can I Remember All of This?

TL;DR

Interview with Life of the Freelancer

Working with OS X and Emacs

Talk: How we use MongoDB at BusyConf

Talk: CoffeeScript at DCRUG

Talk: CoffeeScript at 757rb

Lightning Talk: CoffeeScript at NovaRUG

My Remember The Milk Conventions

Do Check Your `.ruby-version` into Version Control

Let Bundler Follow the `--path`

Package Your Gems in `vendor/cache`