Pregnant Fist

mumbling through the doors of space and time...

[pregnantfist]

rubyism: splatting for the good of mankind

In the midst of writing some ever expanding SQL queries I found places where I was passing the same variable to multiple conditions so I ended up with this:

[user.id, user.id, user.id, user.id]

Not the prettiest girl at the dance but she can shake her hips when she has to. Still I think we can make it smaller and more Ruby-ish.

ids = [user.id] * 4

Better, now only an integer has to change if we need to add or remove one of the id variables.

Here is a better representation of this thinking in code:

https://gist.github.com/bjh/5637436

Is it better or worse? not sure but it is certainly much more fun...

[pregnantfist]

rubyism: are my array items unique?

I was wandering around StackOverflow the other day asking the question: how can I tell if my array only contains unique items? and I ended up with walking away with something that looks like this:

There are other solutions that involve monkey patching. Also you could wrap that up in a function but I just wanted to show the general idea.

[pregnantfist]

railsisms: Return to Forever

I am a fan of leaving controller actions as quickly as possible. I like to avoid nested if/else orgies whenever I can so I was very happy when I stumbled across this lovely shortcut that I can use to leave actions early.

The magic here is putting and return in the if blocks.

Technically putting return at the beginning of the line is shorter but I find this more readable since we don't really return stuff from actions...

[pregnantfist]

Rubyism: Bruce Banner gem

Wrote a gem to enable some of my coding laziness

code on github

rubygems

I am still pretty old school when I debug my code as I use gratuitous puts statements everywhere. I usually have a pattern like this:

So I basically wrapped that all up in a little gem...there are more examples on the github page

[pregnantfist]

this dude just saved my life a/k/a how to stop ack from searching your compressed rails assets.

I have this in an .ackrc in a rails project directory:

--ignore-dir=public/assets --ignore-dir=log

note: if you cut/copy/paste this, the lines start with two dashes - - not the stylized HTML entity that might get copied

[pregnantfist]

Code Katas: Data Munging

Kata Four: Data Munging

kata is here

code here

Questions asked for the kata...

To what extent did the design decisions you made when writing the original programs make it easier or harder to factor out common code?

The design decisions made it much easier; mostly because parsing formatted data files is fairly repetitive. Especially when the data formats are so similar.

Was the way you wrote the second program influenced by writing the first?

Absolutely, I literally copied the first program, emptied out a couple of methods and started again with the new data set.

Is factoring out as much common code as possible always a good thing? Did the readability of the programs suffer because of this requirement? How about the maintainability?

Factoring out common code is usually a good thing but I believe there are cases where specialization over generalization can lead to better code.

The readability did not suffer, both versions looked almost exactly the same and I think I did a good job keeping the parsing algorithm(s) fairly obvious.

As for maintainability: that is for the future to unfold isn't it?

[pregnantfist]

Code Kata: Karate Chop

Code Katas - Binary Chop

The kata rules are here

I tried a few attempts at this kata. I ended up using a mish-mash of code from different attempts and a sprinkle of googling...

I was really hoping to only need to keep track of one number (the pivot) instead of the left/right partitions...alas is was not to be this time

code here...

[pregnantfist]

wait a minute...did you just say you don't like The Princess Bride movie? this relationship is not going to work out...

unicorn hammer

[pregnantfist]

Rubyism: blowing the stack for fun and profit

Creating an Array from a Range can blow the stack.

Using the Array [] constructor and splatting a Range can blow the stack

data = (0...1000000) haystack = Array[*data] #=> stack level too deep (SystemStackError)

Splatting a Range on its own does not blow the stack

data = (0...1000000) haystack = *data #=> all good in the hood

tested with ruby 1.9.3p374

[pregnantfist]

where sysadmins go to die?

[pregnantfist]

railsisms: vertical controller methods

TL;DR

Refactoring code can be just as fun as writing it.

What is a vertical controller method?

A controller method that tries to avoid nested if statements with the result that it looks more linear instead of nested. The goal is hopefully easier to read, change and generally reason about.

This is a small example: it goes three if's deep, has the same render action in two places and other assorted code gaffs.

Refactor phase one: try to remove at least one level of nesting.

Tools used - Arrow Anti-Pattern, Guard Clause, Extract Method

This is not so bad, it read a bit better and does not look as complicated since it is not so deeply nested. I also use the return statement gratuitously, I know some people frown on it but in a controller action I find it helps keep the code cleaner.

Can we do better?

Refactor phase two: I really just wanted to see if I could remove the remaining nested if statement. It looks something like this.

Better of worse? As most things it is up for debate. For now only the first refactoring made it into development branch. The second was really for my own edification.

[pregnantfist]

you decide....

[pregnantfist]

It looks like a unicorn riding ninja snuck into our code repository and performed a reverse liposuction on this class.

unicorn hammer

[pregnantfist]

Rubyisms: they grow up so fast...

TL;DR

The story of a simple class that exploded into an if statement absorbing monster that started to wreak such havoc it had to be put down.

The newborn class, fairly simple and innocuous was birthed looking something like this:

Not the prettiest newborn the world has ever seen but certainly no mirror breaker.

Now as this class grew it started to take on more responsibility and therefore started to gain a little weight. Not enough to have a Weight Watchers intervention but we did have to let his pants out a few times. Of course before anyone knew it our little bambino looked like this:

Wow, what happened? it looks like a unicorn riding ninja snuck into our code repository and performed a reverse liposuction on our adolescent class. Now it is time for an intervention!

Question: How can we give this class a better body image?

Step one: remove anything that looks like a question or a decision and see what the class could look like with some new clothes and a lot of exercise.

Nice, much slimmer and the class just look happier doesn't it?

Step 2: Now what about all those decisions we removed? Let's see what that looks like if we factor it all out to a class:

Not to shabby, we now have a nice skinny class that does the bare minimum it needs to to get the job done and more importantly it defers any questions it has to someone more suited to the task.

[pregnantfist]

Rubyisms: when to send the collection agency

Array#collect

I love finding ways to make my code more obvious and (hopefully) more understandable.

Recently I have been finding bits of code I wrote that iterate over a collection of things and just "collect" one thing from each item. I tend to initially do this with a 'collectee' outside of the loop and just append/add to it in an each block. Not the best habit in the world but easily refactorable.

Before:

def all_fields fields = [] @snappables.each do |snappable| fields += snappable.fields end fields end

After

def all_fields @snappables.collect(&:fields).flatten end

So much simpler, obvious and it feels so much more Ruby-like.

[pregnantfist]

generate grid based CSS layouts painlessly, worked like a charm

[pregnantfist]

if none of these images make you laugh you are dead inside.