Ruby on Bridge

Lone Star Ruby Conf 2013

Mon, 22 Jul 2013 00:00:00 +0000

This last weekend I went to the Lone Star Ruby Conference 2013. It was a good conf. Of course, there were some weak talks and bad wifi issues, but overall, it was the most enjoyable and useful conference I’ve been to.

Highlights

Sandi Metz’s keynote looking at the history of writing and tech - Always great to hear that you’re going to be obselete and thus, you need to remember what your priorities are.
Dave Thomas’s talk on Exlir - Showed off the power of the language by live-coding and having a good time doing it.
Brandon Hays’ talk on Ember.js and Rails - perhaps the best beginner talk I’ve ever seen. Great combo of funny, interesting, informative and technical enough to be useful.
Sarah Mei’s talk on fostering creativity and problem solving - Just a great talk–well delivered and interesting. Best soft talk of the conf.
Nell Shamrell’s talk on RegEx - Super informative, well delivered and highly technical without alientating anyone. 200 devs paying attention to every word she’s saying about how a RegEx parser works. That’s mad skills.
Sam Livingston-Gray’s talk on Refactoring - Wonderful talk that dove deep enough to give you an idea of HOW to refactor something. I always forget that it is one small thing at a time.
Getting to meet and visit with people I had only known on twitter before like @_zph and @avdi.
Getting to meet lots of people interesting in #pairwithme.
Bryan Helmkamp: “Your goal is to make refactoring invisible. It should happen every time you touch the code. Little improvements here and there.”
Getting to give my Lightning Talk on #pairwithme

Overall a great conf. It seemed like the best and most interesting talks weren’t focused on Ruby–with the exception of @geeksam’s talk on refactoring. Nearly every talk worth it’s salt was either talking about broadening your horizons or improving your code quality. That’s a tall order, and it’s a great thing that the Ruby community embraces it.

Pairing Post Mortem - @jnanney - OAuth

Thu, 18 Jul 2013 00:00:00 +0000

I finally got a chance to pair with @jnanney tonight. He had a project dealing with the OnStar API that needed OAuth Authentication, so we took a stab at implementing it.

Setup

Skype - TIL Skype 6.x turns off your video if you connect to a Skype 2.0 client–but the audio still works!
TMUX+VIM on a slice (not local)

Experience

We started by making some large, rough ideas about what we wanted to accomplish and then began looking up some things on OAuth2 to help us accomplish them. Pretty quickly we stopped driving everything via tests and started exploring via IRB.

Pairing Post Mortem - @willpragnell - Mute Pairing with VIM

Tue, 09 Jul 2013 00:00:00 +0000

Last week I had the opportunity to pair again with @willpragnell. He had just moved and didn’t have internet access, so I suggested that we try a “mute” pairing session from a coffee shop, where all our communication happened through VIM.

He was game, so we started off with a quick chat session on Google+ to get set up, and then switched to a VIM+TMUX setup for the rest of the time.

Pairing Post Mortem - @peter_v - Improving a Semantic Store

Wed, 03 Jul 2013 00:00:00 +0000

Today I got to pair with Peter Vanderabeele, who is a programmer from Belgium with a highly methodical bent. He has clearly had a lot of experience and it was neat to get to work on his project since it isn’t every day you get to work on a high performance fact storage system.

Peter is creating a data store meant to store semantic facts that have relationships to each other. It’s a very different project with a goal, he stated, to have data in this format and extractable for the next 50 years. To try to view code with that lens is very different from how most other Rubyists think. We tend to see our code dying in the next 5 years… max. So we make decisions with that timeline in mind. Thinking of a timeline longer than my own life has very different implications.

Pairing Post Mortem - @stuartrexking - Cane Extension

Mon, 24 Jun 2013 00:00:00 +0000

Last night’s pair session was with @stuartrexking - a very experienced developer and technologist currently working at a really neat company called Antipodean Labs. It seems like he’s got a great handle on solving problems and staying maintainable.

We started off by trying to decide what to do. I’m increasingly convinced this is the possibly the hardest part of remote pairing with people who aren’t part of your company. You don’t have a predefined complex project you both find interest in, so the most likely shared interests are either meta problems or highly common ones. Highly common ones are very visible and difficult to find low hanging fruit for. The meta problems are good to solve, but somehow feel like they are less valuable than the “real” problems. Maybe this is just a feeling I have.

Steps for a Beginner to Learn Ruby

Thu, 20 Jun 2013 00:00:00 +0000

Ruby is not Rails. Learn Ruby first.

Get rbenv (preferred) or rvm installed with Ruby 1.8.7, 1.9.3 and 2.0
Write Hello World and run it

puts "Hello World"

Go through the Ruby Koans (simplest with 1.8.7)
Go through some TDD exercises
Code a simple ruby script that solves a problem you have, like…
- Add a TODO to a file
- Print out the date in another time zone
- Tell you how many days until…
- Perform some repetative task related to your environment
- Display something silly for your kids

Ruby is not Rails. You do not need to learn all the “magic” of Rails to learn the awesome of Ruby. Spend some time and get where you can really drive a script and solve a simple problem. Doing this will get you far beyond a beginning Rails developer. You simply have to learn the magic incantations of Rails to be able to develop web apps after that. And those incantations won’t be nearly as scary.

Pairing Post Mortem - @_zph - Meta Pull Requests

Wed, 19 Jun 2013 00:00:00 +0000

I had a great #pairwithme session with @_zph. Always a pleasure to talk to him and solve a problem together.

Setup

TMUX + VIM on a slice
github-auth gem

Experience

We wanted to add the feature to gh-auth so you could pass a –path or –user argument to it. Because we’re good developers, we started off by coding the acceptance test. We discussed the merits of how to write good tests and whether to follow convetions within a gem authored by someone else or do things ’the right way’ – according to whatever coding religion you follow. Eventually we decided on sticking to the conventions of the gem while trying to improve–but not radically change–the tests/testing that we touched. From there, we dove down into the implementation and unit tests and drove through until we had the –path argument working. Along the way we did a little refactoring to use the OptionParser instead of requiring a specific ordering of options.

Pairing Post Mortem - @Shicholas - String Calculator

Tue, 18 Jun 2013 00:00:00 +0000

Last night I had a great pairing with @Shicholas working on the String Calculator kata.

Setup

We again used TMUX + VIM, even though Nick wasn’t very familiar with VIM. Based on his experience, I think this might be the best way to learn VIM since you have someone guiding you through. You won’t pick up on everything, but you’ll learn a handful of new things each time.

Exercise

We went through each of the different rules and ping ponged back and forth. It was a struggle to do the simplest possible thing every time, and really let the tests DRIVE your development. Your developer brain wants to generalize the solution to a problem, but the strength of TDD is keeping your actual solution as simple as possible. Developers are notorious for over complicating things and over desigining.

Pairing Post Mortem - @willpragnell - Overseas TDD

Fri, 14 Jun 2013 00:00:00 +0000

I had my first pairing session with @willpragnell today. He’s a smart guy and my first European pair partner. It was a pleasure to talk to him about his iOS and Ruby experience and I picked up on a lot of little things from our pairing session together.

Setup

TMUX and VIM - (I got to use my newly revised pairing script to set up everything in seconds)
TicTacToe - RSpec

The Session

We set a couple of goals out for the beginning. We both wanted to learn more of RSpec’s new syntax and we wanted to really adhear to the TDD principle of doing the most simple thing next.

Pairing Post Mortem - @mattr_ - Pending Specs and Assertions First

Thu, 06 Jun 2013 00:00:00 +0000

Today I paired with @mattr_ and got quite a bit of good input regarding how to attack a problem and write tests. Matt is a super smart guy who has really absorbed some of the fundamentals of TDD and it shows through his ability to break down a problem.

Setup

TMUX & VIM on my box
Conway’s Game of Life as an exercise

Process

When implementing the game of life, we started off looking at the problem on Wikipedia and found the 4 rules. I immediately started writing the first test when Matt noted that he liked to write all the specs he knows of as pending specs right at the beginning. Then he can really plow forward and know what’s next. He also noted that he likes to be able to write the assertion first, based on the test, and then build the test up from there. I felt the lightbulb go off when he pointed these two things out. When I’ve struggled to find the test or figure out how to test something, usually it’s because I can’t figure out how to get to the assertion, and that really comes down to not testing the right thing.

Pairing Post Mortem - @_zph - VIM and a Gem

Wed, 05 Jun 2013 00:00:00 +0000

Last night I had a great #pairwithme session with @_zph. He’s been doing Ruby on nights and weekends for the last few years and he’s been using VIM much longer than I have. I learned a lot of little tricks about VIM that I just hadn’t quite worked out before. We also refactored some of his Buff Gem.

Setup:

Zander had a VPS already provisioned with my ssh keys installed. Super Easy setup.
TMUX + VIM for our editors
RSpec for testing the Gem

We started off trying to think of what to pair on within Zander’s gem. He was concerned about the tests, so we actually spent a fair amount of time just looking at the WebMocked tests and discussing the pros and cons. Eventually we decided that WebMock might be a good way to start off your TDD of an API wrapper since you have complete control of the response, but VCR gives you the best long term support since you can both get fast tests and confirm that you’re still working with the API correctly and that you didn’t just magically stub out the wrong thing–just delete your cassette and you’ve got “free” real API tests, followed by nice fast tests.

Pairing Post Mortem - @Shicholas - Real World Lessons and Bowling

Tue, 04 Jun 2013 00:00:00 +0000

Last night I had my first pairing session with @shicholas. Nick recently graduated from law school and is looking to pass the bar, but somehow programming calls to him. It’s a good thing too, since he’s clearly gifted and a fast learner.

Setup:

ScreenHero
Sublime Text 2
shuhari by @jarhart

While we were kicking things off with the “get to know you” talk, I found that Nick had a Rails + Angular.js app he was working on. I’ve not done any work with Angular and asked him to show me what was going on. He pointed out the general structure as well as the custom directives that Angular.js allows you to create. I’ve watched the Ember.js Peepcode Intro, and found it difficult to get excited about it. Being introduced to Angular.js in this particular manner gave me real world applications and it seemed much more intriguing. No verdict yet on either, just initial impressions on both frameworks.

Pairing Post Mortem - @kmeister2000 - Refactoring and MiniTest

Wed, 29 May 2013 00:00:00 +0000

Had a great 4th pairing with @kmeister2000. Always a pleasure to work with him.

Interesting Parts of our session setup:

Worked on a real world app Karl was developing
Used MiniTest instead of RSpec
Refactored existing code

MiniTest Takeaways:

MiniTest expectations about method calls are not as clear as in Rspec and the documentation/examples aren’t as readily available.
MiniTest is a lot like RSpec in nearly every other way.
I’m not a fan of Mocha. I think it promotes antipatterns for how to really test.
I actually like the explicit mock.verify in MiniTest::Spec

General Takeaways:

Pairing Post Mortem : @hinbody - TicTacToe and TMUX

Wed, 29 May 2013 00:00:00 +0000

I just finished my first #pairwithme session with @hinbody. It was my first remote session to use TMUX+VIM instead of ScreenHero – I have to say, it was quite easy to use and given the fact that it’s free, fast, and cross-platform, I’ll be using it with any vim users I pair with who are willing. I’d love to get CoVim working since it allows you to use your own vim setup. I drool a little bit at all that. But I digress.

Pairing Post Mortem : @thecommongeek - Ruby Koans

Tue, 28 May 2013 00:00:00 +0000

I paired with @thecommongeek last night again. This time we were more prepared and I think the session went much better.

In our first session I misjudged where Dennis was as a coder and struggled a bit with how to pair with him effectively. This time we had him drive through ScreenHero and decided to start from the “basics” by doing the RubyKoans.

The RubyKoans are meant for Ruby 1.8.7, but 1.9.3 is commonplace now, so we struggled a bit at the beginning. For anyone going through the RubyKoans on 1.9.3 getting a value19 in nearly all your errors, I’d suggest making the following changes on neo.rb (starting on line 34):

Pairing Post Mortem - @javichitone - Improving a Gem

Wed, 22 May 2013 00:00:00 +0000

I had my first international pairing session with @javichitone tonight. He’s from Peru and will soon be graduating. He should have no trouble finding a job based on the code I got to read of his :)

We talked for a bit and settled into looking at a gem he recently published. Since it was his gem, I elected to drive. I’m familiar enough with gems that I’m comfortable in general, but he knew the specifics of his gem, so to get the most out of it, he needed to be commenting on the specifics he knew and I needed to be diving into figuring out those specifics.

Tic Tac Toe TDD

Thu, 25 Apr 2013 00:00:00 +0000

I spent a little (longer than I thought… maybe 2 hours?) implementing Tic-Tac-Toe in the TDD As If You Mean It style. Ended up with a VERY different implementation than I ever would have done if I just “started coding” – everything was only in one class, including the AI to “play” against itself.

Observations:

It was quite different to implement things inside the test method. I ended up coding like

it "does something..." do
player = Player.new
def player.something
# do work
end
player.something.should be_true
end

It was difficult to not refactor as I went. Many times I would see the duplication and want to refactor immediately. I resisted this urge until I felt the implementation was done, then refactored out duplication, ensuring that the tests continued to pass after each change.
I’m still not quite sure how you’re supposed to improve design without breaking the rules. Doing pure method move seems limiting and doesn’t allow for you to see duplication. The only thing I could think of is that there can be additional refactoring after you’re “done”

All in all, a very interesting exercise. I want to do it now on something broader, and eventually on something that has a core with a wrapper so that the core is purely TDD’d and the wrapper is thin, but swappable. I think Dominion is my next big attempt.

ImageMagick, JPEGs, and Orientation, Oh My

Wed, 13 Jun 2012 00:00:00 +0000

I’ve been working on a new project and decided to use CarrierWave to handle image uploads (and minor automatic manipulation). Everything looked great, but then my new boss, who has a penchant for finding the one or two things wrong with your latest well-tested feature uploaded a JPEG that looked fine in Preview, but automatically rotated on upload.

After checking through the directory, it seemed that only the processed images were getting rotated. Actually, ‘rotated’ is a misnomer, they were actually just losing their orientation. JPEGs have EXIF meta data that can contain the orientation of a picture, no matter how it’s stored. This allows cameras to store everything as a 640x480, but display some in the reverse (480x640). The only thing different when the camera writes the image is what orientation the gyroscope adds to the meta data.

DCI Generators in Rails

Tue, 22 May 2012 00:00:00 +0000

Recently, in my new project, I decided to take the DCI approach that Mike Pack outlined, which has been really cool. I’ve been able to keep my tests fast, and have very distinct buckets to put data (models), specific roles of that data (rather than cluttering up the models), and an easy way to take a use case and map it out programatically (contexts).

I noticed that I was generating roles and contexts regularly and copying from previously written code examples so I decided to make role and context generators. The process wasn’t bad, but it did take a couple of steps that took a little digging to understand.

Best Way to Bundle

Wed, 14 Mar 2012 00:00:00 +0000

Thanks to the RubyRogues Episode on Bundler, I learned the best way to use bundler.

You want to always use the “pessemistic” version numbers for a handful of reasons.

gem 'rails', '~> 3.0.3'
gem 'rspec', '~> 2.7.0'

This allows the most efficient resolution of gem dependencies (in this case, any version of rails from 3.0.3 up to and not including 3.1, and any version of rspec from 2.7.0 up to and not including 2.8) and the added benefit of allowing you to easily patch everything safely using only bundle update.

Don't Use DateTime in Rails 3

Tue, 29 Nov 2011 00:00:00 +0000

Rails 3 has good TimeZone support built in, but you have to use the right Date and Time classes to get full support.

If you have this set in your application.rb config.active_record.default_timezone = :local, then you really need to use Time so that it properly identifies itself as being in the local timezone and not in UTC when passing to the database insert.

ree-1.8.7-2011.03 :001 > DateTime.parse('2011-11-27 12:00:00 +0000')
=> Sun, 27 Nov 2011 12:00:00 +0000
ree-1.8.7-2011.03 :002 > DateTime.parse('2011-11-27 12:00:00')
=> Sun, 27 Nov 2011 12:00:00 +0000
ree-1.8.7-2011.03 :003 > Time.parse('2011-11-27 12:00:00 +0000')
=> Sun Nov 27 06:00:00 -0600 2011
ree-1.8.7-2011.03 :004 > Time.parse('2011-11-27 12:00:00')
=> Sun Nov 27 12:00:00 -0600 2011

So basically, Time.parse always returns the value in the local timezone, DateTime.parse always returns the value in UTC. To get complete compatibility, always use Time.parse. Trust me, I learned the hard way :)

Code Kata #1 - Supermarket Pricing

Fri, 14 Oct 2011 00:00:00 +0000

Taken from Code Kata’s by Dave Thomas

The basic premise of this Kata is asking how you would model super market pricing. What is the price of an item? What is the cost? How do you handle price-per-pound? Buy 2 get one free? What’s the value of stock? It’s interesting, and I thought I’d take the time to blog through my thought process.

I’d like to iterate over the design and see where it takes me. First task is to represent a product.

A Ruby Scoping Gotcha?

Fri, 27 Aug 2010 00:00:00 +0000

Let’s take this basic class:

class TestClass
 attr_accessor :one

 def my_method(branch=true)
 if branch
 puts "Do nothing to modify `one`"
 else
 puts "Modify `one` but it's a local variable"
 one = "test"
 end

 one # local variable
 end

 def my_non_modifying_method(branch=true)
 if branch
 puts "Do nothing to modify `one`"
 else
 puts "Do nothing to modify `one` either"
 end

 one #method call
 end
end

o = TestClass.new
o.one = "Value"

puts o.my_method
 => nil #might expect 'Value' if you're not paying attention
puts o.my_non_modifying_method #expects "Value"
 => "Value"
puts o.my_method(false)
 => "test"
puts o.my_non_modifying_method(false) #expects "Value"
 => "Value"

So remember, if you create any local variables anywhere in your method, even if they’re not called, they override the accessor methods and will give you results you’re not expecting. To get around it, make sure you always use self.accessor= to assign values when there is ambiguity.

Optional Heirarchal Checkbox Selection with Nested Attributes in Rails

Fri, 04 Jun 2010 00:00:00 +0000

I had a process where I wanted users to fill out a survey which had hierarchal categories AND be able to specify some additional data for specific capabilities that the user had.

Now, you could easily do this for a small subset and hand-code every item, but I wanted a flexible survey system that allowed true hierarchy and generalized code.

Let’s start off with the basic survey and capabilities models and relationships:

Python vs. Ruby - A Fight To The Death

Sun, 21 Feb 2010 00:00:00 +0000

When you’re discussing efficiency, a lot of what comes up is the details. There is something to be said for the “beauty” of limitation and the “efficiency” of beautiful things–especially the efficiency of our brains processing it.

A talk about the Zen of Python, monkey patching (several times), the Ruby community's reckless hastiness, the syntax of RSpec and cucumber, beauty and ugliness in languages and testing tools, the complexity of the languages' grammars, syntactic vs. semantic complexity, the relative taste of grasshoppers and tree bark, etc., etc.

Python vs. Ruby: A Battle to The Death from Gary Bernhardt on Vimeo.

PDF Generation in Rails... The Right Way

Fri, 12 Feb 2010 00:00:00 +0000

As long as we’re talking about efficiency here, one of the ways to be more efficient is to use the right tool for the job. I’ve done PDF generation on 3 different projects but the PDF generation I did yesterday was by far the easiest. What I thought would take me 2 days ended up taking about 3 hours (with research, etc).

If you’re not using Ruby to automate some part of your job or life, I feel sad for you (at least a little). The next time you need to generate PDFs, why not try out the excellent Prawn library? Not familiar, you say? Well, let’s dive right in, shall we?

The Building Blocks of Ruby

Mon, 08 Feb 2010 00:00:00 +0000

While the Python version may not be quite as pretty, nothing about them screams “Ruby has much stronger capabilities here”. Instead, by using examples like Sinatra, Rubyists trade in an argument about great semantic power for one about superficial beauty.

Rubyists, Pythonistas and others working on web development share a common language in JavaScript. When describing blocks to “outsiders” who share a common knowledge of JavaScript, we tend to point at JavaScript functions as a close analogue. Unfortunately, this only furthers the confusion.