3.months.from.now

The 3months.com development team blog.

[threemonths-dev]

10 Rules for Dating my Daughter

During recent internal dev discussions we were debating Sandi Metz' four rules from Ruby Rogues episode 87 - summary and further linkage here. It got me thinking how would that apply to legacy projects, or as I prefer to call them "heritage" projects? So after a quick review of one of our older Rails projects I came up with the following adjustments:

Your class can be no longer than 2200 lines of code.

Your methods can be no longer than three hundred lines of code.

You can pass no more than seventeen parameters and please use multiple hashes.

When a call comes into your Rails controller, you can only instantiate twenty three objects to do whatever it is that needs to be done.

You can break these rules if "it works on your dev machine".

- Jon Waghorn

[threemonths-dev]

New books!

3months has recently refreshed its library, getting rid of some (really) old books and buying a bunch of new ones. When we need books about specific technologies, we prefer to buy an eBook for the office kindle. Some books, though, deserve to be owned in physical form.

If you are going to buy a dead-wood version of a book, you really do want it to be a long-term investment. No cutting-edge technology books, no mediocre or unproven books, if you can help it. To that end, we ordered the following:

The Elements of Style - Strunk & White

Our jobs involve a lot of written communication. S&W is considered one of the best guides to writing well.

Design Patterns: Elements of Reusable Object-Oriented Software - Gamma, Helm, Johnson, Vlissides

One of the standard books. Everyone knows they should have read it, few have. It can be a dry read, but the material is worth the investment. There has been a lot of competition in the office for this book!

Practical Object-Oriented Design in Ruby: An Agile Primer - Sandi Metz

This book is deceptively slim and basic, but the core concepts it imparts about OO design are great. Another book in high demand around here.

Working Effectively with Legacy Code - Michael Feathers

I've being going through this book and I've found it packed with practical, pragmatic advice for dealing with the horror of untested, hard-to-maintain code. I highly recommend this book.

Code Complete: A Practical Handbook of Software Construction - Steve McConnell

The heaviest of our books, Code Complete covers an enormous range of topics and comes highly recommended. No-one has yet been brave enough to crack it open, but we'll get there.

Growing Object-Oriented Software, Guided by Tests - Steve Freeman

Covers TDD and emergent OO design in a practical way. Another book that hasn't yet had too many hands on it, but that's bound to change soon!

3months already has a decent library of real and electronic books, but I'm quite pleased that we've added this set. One of the hardest things to pick up is the craft of programming, and a well-written book will add a lot of tools to a developer's toolbox.

We've already started compiling a list for the next refresh. Let us know if you have any recommendations!

- Daniel Zollinger

[threemonths-dev]

A concise way to create BigDecimals

Decimals are an important tool if you want reliable values to use in e.g. financial software. Ruby provides a BigDecimal class that you can use for this sort of thing. The normal way is to initialise it in the traditional manner:

BigDecimal.new("0.5")

But the most concise way to do it is with good, old-fashioned type coercion:

"0.5".to_d

You'll need to require BigDecimal before you can do this, but you were going to be doing that anyway, right? Hat tip to Daniel Sherson for the idea! - Daniel Zollinger

[threemonths-dev]

Ruby ranges are cool

We've probably all used or seen ranges in ruby, like these simple examples from the ruby docs:

(1..5).to_a #=> [1, 2, 3, 4, 5] ('a'..'e').to_a #=> ["a", "b", "c", "d", "e"]

And the three dots inclusive range variant:

('a'...'e').to_a #=> ["a", "b", "c", "d"]

But I recently discovered some other cool things, like strings that behave like numbers when I wanted a simple array of 2-digit month numbers:

('01'..'12').to_a #=> ["01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"]

And this from Ruby Inside, using ranges instead of complex comparisons for numbers. No more if x >= 1970 && x <= 1979 nonsense, instead:

case year when 1970..1979 "Seventies" when 1980..1989 "Eighties" when 1990..1999 "Nineties" end

Cool!

- Jon Waghorn

[threemonths-dev]

Use performed? to avoid double renders

This little titbit is surely not news to many Rails developers, but it certainly has proved handy for me.

Render or redirect must be called exactly once in a controller action. This makes sense as each action represents a single server response.

Normally your controllers will be simple enough that this is trivial to verify. Occasionally, though, you may need to have a relatively complex selection of renders or redirect commands such that you can't guarantee a render has been performed or not by the time you get to the end of the method.

Often this is a sign that you are asking your controller to do too much. Sometimes, however, knowing this can be really handy.

The performed? method returns true if a render has already been called for the request.

Easy.

- Daniel Zollinger

[threemonths-dev]

Useful SASS tidbits

I've been working a lot lately with SASS (or SCSS whatever) and there are some pretty neat tricks that make writing CSS seem almost programatic (we all know it's not).

For example it's possible to check the lightness of an elements background, then dictate the text colour depending on that outcome (example sourced from Foundation).

@mixin button($bg:$default-bg) { $bg-lightness: lightness($bg); @if $bg-lightness > 70% { color: $button-font-color-dark; &:hover, &:focus { color: $button-font-color-dark; } } @else { color: $button-font-color-light; &:hover, &:focus { color: $button-font-color-light; } } }

Another useful tidbit is using the for loop.

@for $i from 0 through 2 { .item-#{$i} { border: 1px solid gold; } } @for $i from 3 through 5 { .item-#{$i} { border: 1px solid silver; } } @for $i from 6 through 8 { .item-#{$i} { border: 1px solid bronzw; } }

Which then compiles into:

.item-0, .item-1. .item-2 { border: 1px solid gold; } .item-3, .item-4. .item-5 { border: 1px solid silver; } .item-6, .item-7. .item-8 { border: 1px solid bronze; }

There are a lot more useful tools within the SASS DSL, I'd suggest spending 15 minutes or so just reading through the docs.

Written by Jack Callister

[threemonths-dev]

Method delegation

Here's a sweet trick avoid lengthy chaining in your method calls. An example of where this comes in handy is a product model I was working on recently. The relationships looked like this.

class ProductType < ActiveRecord::Base has_many :products has_many :fields, class_name: "Product::Field" end

class Product < ActiveRecord::Base has_many :properties belongs_to :product_type end

class Product::Property < ActiveRecord::Base belongs_to :product belongs_to :field, class_name: 'Product::Field' has_one :product_type, :through => :field end

class Product::Property < ActiveRecord::Base belongs_to :product_type end

Here's brief run down of the relationships starting at the top. A product type has many fields. Fields on a product type are like the blue print of the attributes that make up that product type. A product belongs to the product type and also has many properties. Properties are the model that actually hold the values for each field so it belongs to a field.

With such closely nit correlation between fields and properties this type of thing happens quite often.

property.field.datatype property.field.key property.field.label

By adding a few delegate methods on properties we can make life much easier!

class Product::Property < ActiveRecord::Base # Omitted model stuff with_options allow_nil: true do |field_delegate| field_delegate.delegate :datatype, to: :field field_delegate.delegate :key, to: :field field_delegate.delegate :label, to: :field end

Now I can call the fields methods with ease. A small but useful and clean change.

property.datatype property.key property.label

Written by Jack Callister