Nil, If and Collect in Ruby

18 Dec 2014

Ruby’s if statement returns the return value when matched. If it falls through, it returns nil. I sometimes forget this. It’s not a big deal until it bites you.

Here’s an overly simple example where this works very well.

numbers = [1,2,3,4,5].collect do |number|
  if number % 2 == 0
    "#{number}: even"
  else
    "#{number}: odd"
  end
end

numbers
# => ["1: odd", "2: even", "3: odd", "4: even", "5: odd"]

This is really handy because we don’t have to create like a temporary variable somewhere and use each. But this is also a really clean case because there’s only odd and even. In other words, our if statement never falls through to return nil. Nil is a pain in Ruby. Avdi’s book Confident Ruby is not just about nil but it talks about nil. Avdi’s screencasts about nil are a good place to learn more (and I often refer back to Avdi’s work).

Ok, back to our collect. When possible, I try to use collect to avoid mutation. Maybe it’s my concession to functional programming languages. Maybe it’s because state mutation in Ruby causes headaches. I think the most important reason for exploring this is so we know of one other way to skin a cat. So let’s look at a more real example.

users = [
  { name: "Jay", enabled: false },
  { name: "Joan", enabled: false },
  { name: "John", enabled: true }
]

# enable everyone!
users.each do |user|
  user[:enabled] = true if user[:enabled] == false
end

# users
# {:name=>"Jay", :enabled=>true}
# {:name=>"Joan", :enabled=>true}
# {:name=>"John", :enabled=>true}

Meh. Mutation. It’s good to know just one more way for us to do this. Return a new collection.

users = [
  { name: "Jay", enabled: false },
  { name: "Joan", enabled: false },
  { name: "John", enabled: true }
]

# enable everyone!
enabled = users.collect do |user|
  user.merge({enabled:true}) if user[:enabled] == false
end

# enabled
# {:name=>"Jay", :enabled=>true}
# {:name=>"Joan", :enabled=>true}

Whoops. Where did John go? Here’s that thing I was talking about. Our collect needs to handle the fallthrough from the if.

users = [
  { name: "Jay", enabled: false },
  { name: "Joan", enabled: false },
  { name: "John", enabled: true }
]

# enable everyone!
enabled = users.collect do |user|
  if user[:enabled] == false
    user.merge({enabled:true})
  else
    user
  end
end

# enabled
# {:name=>"Jay", :enabled=>true}
# {:name=>"Joan", :enabled=>true}
# {:name=>"John", :enabled=>true}#

# users
# {:name=>"Jay", :enabled=>false}
# {:name=>"Joan", :enabled=>false}
# {:name=>"John", :enabled=>true}#

Great! You can see we didn’t mutate state. Now the problem with doing this all the time in Ruby is tail call optimzation. If you go to the ends of the earth with this your stack will explode. But I still like this style when I can do it because I avoid changing state.

The end-game to this line of thinking is switching to or at least playing with a function language like Clojure, Rust or Scala.

Mocking in Golang

28 Nov 2014

This was originally a stackoverflow but it got down voted and suggested it be a blog post. Ok! Here’s my toy program. I had it separated into package files but I figured that would be harder for you guys to run it yourself. Please bear with me while I step through this.

The first iteration:

charge.go

package main

import "fmt"

type VisaGateway struct {
    Name string
    Url  string
}

func NewVisaGateway() *VisaGateway {
    return &VisaGateway{
        Name: "Visa",
        Url:  "visa.com...",
    }
}

func (v *VisaGateway) Charge() {
    fmt.Println("I am charging Visa -->")
}

type PaymentGateway interface {
    Charge()
}

func ChargeCustomer(g PaymentGateway) {
    g.Charge()
}

func main() {
    gateway := NewVisaGateway()
    ChargeCustomer(gateway)
}

Running it.

$ go run charge.go
I am charging Visa -->

So we can test this with a mocking library (separate question) maybe but for now let’s just use this interface and make a test that passes in a fake gateway so our test suite doesn’t hit a real system.

charge_test.go

package main

import (
    "fmt"
    "testing"
)

type MockGateway struct {
    Name string
    Url  string
}

func (m *MockGateway) Charge() {
    fmt.Println("This is a fake gateway.  --> [no-op] <---")
    fmt.Println("Yay!  :) ")
}

func TestCharging(t *testing.T) {
    m := MockGateway{}
    ChargeCustomer(m)
}

Great!

$ go test
This is a fake gateway.  --> [no-op] <---
Yay!  :)
PASS
ok      github.com/squarism/credit_card 0.010s

What I’d probably want to do is use a library to help with the mocking setup. Previously I was trying to use a dependency injection style without interfaces and it didn’t work out.

Imagine that my Charge() method signature looks more like this (from joneisen.tumblr.com.

func ChargeCustomer(args ...interface{})
// code to init args and defaults -- see blog post linked above

This doesn’t work because type checking args breaks when you pass in a mock object with no interface. I’m not even sure if interfaces would fix this.

I was hoping to have a default value of the real type/struct and then in my test pass in a mock object. This is one nice side effect of default parameters and dependency injection. But that’s dynamic language style that I have to teach myself to let go of.

Ok. Let’s now using testify for mocking. Let’s add a return value so we can test something.

charge.go

...

func (v *VisaGateway) Charge() bool {
    fmt.Println("I am charging Visa -->")
    return true
}

type PaymentGateway interface {
    Charge() bool
}

func ChargeCustomer(g PaymentGateway) bool {
    return g.Charge()
}

func main() {
    gateway := NewVisaGateway()
    ChargeCustomer(gateway)
}

...
charge_test.go

package main

import (
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
    "testing"
)

type MockGateway struct {
    mock.Mock
}

func (m *MockGateway) Charge() bool {
    args := m.Mock.Called()
    return args.Bool(0)
}

func TestCharging(t *testing.T) {
    m := MockGateway{}
    m.On("Charge").Return(true)

    r := ChargeCustomer(m)
    m.Mock.AssertExpectations(t)

    assert := assert.New(t)
    assert.True(r, true)
}

The run result:

$ go test
PASS
ok      github.com/squarism/credit_card 0.018s

In the mocking example we also added m.Mock.AssertExpectations there. That is additional test that captures and remembers the calls. If the wiring is wrong and the expected call is not called, the test will fail. For a while I was not testing this and I would have had a test coverage gap. Another mistake I made while figuring out the AssertExpectations test was not passing by reference. I continue to make this mistake because I’m pointer-nooby. For more information on this see my question on stackoverflow.

Ok, so that’s my first foray with mocking in Go. So here are some questions:

  • Do you use a mocking library?
  • Do you see how default arguments wouldn’t work to help with mocking? You can’t really DI. I’m ok with this. I just need to learn.
  • Do you like interfaces for (not only) testing reasons?
  • Do you like the interfaces version more than the mocking version?
  • It seems that mocking really needs an interface somewhere? Otherwise won’t you get a cannot use gateway (type *VisaGateway) as type PaymentGateway in argument to ChargeCustomer. I might have gotten this wrong from the testify docs. It wasn’t obvious until I wrote this question.

If you have anything to say or answers to this question tweet me at @squarism.

… and once again, rubber ducking on stackoverflow. Writing the question made me figure it out.

Follow Through and Fundamental Immovables

15 Nov 2014

You can imagine an end result without knowing about fundamental problems. If those fundamentals are core to your business or idea and they are immovable then you probably can’t pivot without fudging what pivot means.

Stay with me for a second and take this lead and gold atom.

alchemy atoms

Now if we could just remove three protons from the lead nucleus then three electrons would just float away it would turn to gold. How useful! How wonderful! Gold has many industrial applications. Lead is poisonous although it also has industrial applications. We could create a lead recycling center! My imagination is running wild with ideas even before we’ve gotten anywhere!

Hmm. So what if we had tiny tweezers? Oops, there’s our tweezers.

alchemy tweezers

Oops! Our tweezers are made of atoms too!

Our tiniest breakthrough, patent winning, best mankind could produce tweezers. Imagine you haven’t gone through any class / book / information that would give you a keyword like “Alchemy” or chunked knowledge like “Alchemy is bogus”. Wouldn’t it seem tempting to try these tweezers? To build these tweezers? When the tweezers don’t work, try pliers?

alchemy pliers

Pliers aren’t the problem. We have an fundamental immovable.

Here’s a wall. You can imagine walking up it can’t you? Well, how would that work exactly? Do you put your first foot on the wall and now you feel like you are doing splits? Or can you remove your foot as easily as a handshake? See, in physics there’s something called perpendicular force (relative to gravity). If I push a car, it’s easy. If I lift a car it’s hard. So are you stepping onto the wall? How hard is it to step up on a table? What transition is there? If you don’t strain like stepping up on a table, could you fall off the wall onto the floor? If you could, wouldn’t that create energy?

walking up a wall

We don’t know. Let’s find out together. This is why I like the TDD loop. Not just testing or test-first but actual TDD. I feel that it guides me. It allows for team discovery. How many more complicated problems like this are there? TDD is a like a science that mitigates human fallacies. More than TDD. Many things do. Science, Agile (whatever that meant before it died), feedback loops, Kanban. They are feedback systems that correct human bias.

It’s not about testing really, it’s about iterating and least-complexity. I really like this picture of shipping a minimum viable product.

agile car

I think this is also a function of diversity. If our team is made up of pliers, we’re in a tight spot. And I don’t even mean racial or gender diversity specifically. Think of this like a portfolio. Don’t put all your eggs in one basket but also make your eggs happen fast while not caring about eggs.

Where Do You Put Your Go Code?

14 Nov 2014

One of the most confusing parts of starting Go was learning the project layout or what Go calls the workspace. It’s changed a little bit in past releases (eschewing $GOROOT etc) but the confusion I think remains if you come from other languages and tools.

Internalize these things:

  1. Your code will go in a folder next to all the libraries you download.
  2. You probably cannot put your Go code next to your Java/Python/Ruby/Javascript/… unless you luck out on naming conventions that you’ve already started.
  3. If you are starting out and you don’t put stuff in ~/bin then just set $GOPATH to your home.
  4. If you don’t like that last rule, just create ~/gocode and set $GOPATH to that.
  5. You probably should not put your Go code in Dropbox.

You also do not need to create a github.com account to put your projects in ~/gocode/src/github.com/{username}/hello_world. You can just go ahead and start your project. It’s just a namespace. If something else needs github.com/{username}/hello_world then it will import it. If it can find it in the GOPATH then it will work. That’s all this is.

When I started Go, I was worried that I was polluting system paths by starting projects in $GOPATH/src/github.com/{my_username}. You’re not. Don’t think about it.

I can’t put my crap code next to the likes of Docker!

It’s impostor syndrome. Just start your project. Just do it.

YAML and Maps in Go

13 Oct 2014

This wasn’t exactly clear. When using the gopkg.in/yaml.v2 (or gopkg.in/yaml.v1) packages, I was confused as to what to do with my data structure.

Let’s say we start off with this file.yml:

description: fruits are delicious
fruits:
  apple:
    - red
    - sweet
  lemon:
    - yellow
    - sour

Here’s a complete example to read this file in and you get a parsed data structure out of it:

package main

import (
  "fmt"
  "gopkg.in/yaml.v2"
  "io/ioutil"
  "path/filepath"
)

type Config struct {
  Description string
  Fruits map[string][]string
}

func main() {
  filename, _ := filepath.Abs("./file.yml")

  yamlFile, err := ioutil.ReadFile(filename)
  check(err)

  var config Config

  err = yaml.Unmarshal(yamlFile, &config)
  check(err)

  fmt.Printf("Description: %#v\n", config.Description)
  fmt.Printf("Fruits: %#+v\n", config.Fruits)
}

func check(e error) {
  if e != nil {
    panic(e)
  }
}

What is Fruits map[string][]string in the Config type? It’s foo: ['a', 'b', 'c'].

This is roughly equivalent to what I would do in Ruby. Of course the Ruby code is much shorter because in Ruby, typically we abuse hashes. :) The surprise I had is this: when the YAML changes, we have to update our type Config. I’m ok with this. I was just surprised by a few things.

First, the keys are significant. If we change the YAML to be:

description: fruits are delicious
tambourines:
  apple:
    - red
    - sweet
  lemon:
    - yellow
    - sour

It won’t work. But HOW it won’t work is confusing.

Description: "fruits are delicious"
Fruits: map[string][]string(nil)

You’ll get an empty map until you change your type to have Tambourines in it. You can’t just access .Tambourines either. The type/struct won’t have a method on it. So this is the trick and benefit the package gives you. You just model your YAML and it maps the keys for you. But you have to “know” what your YAML (dare I say schema?) is. So would you then validate that it loaded correctly by checking lengths etc?

Now what happens when you get it really wrong?

Continue Reading →

Ruby Slop Example

25 Sep 2014

One of my favorite features of slop is the automatic help generation. But it’s not intuitive. It doesn’t print out the help when the parsing fails. This isn’t very unix-y. So every time I want to use slop, I have to look up this snippet I saved for myself. So I’m posting it here. This is the only slop example you’ll ever need.

Unix style CLI program in Ruby

require 'slop'

opts = Slop.new(strict: true, help: true) do
  banner 'Usage: slop_test.rb [options]'

  on 'resume=', 'Your resume file', required: true
  on :s, :skill=, 'Skill Name', as: Array, arguments: :optional
  on 'v', 'verbose', 'Enable verbose mode'  # same as adding required: false
end

begin
  opts.parse

  # validation passed
  puts "Here's the data"
  puts opts.to_hash
rescue Slop::Error => e
  puts e.message
  puts opts
end

Calling it like this will fail:

$ ruby ./slop_test.rb
Missing required option(s): resume
Usage: slop_test.rb [options]
        --resume       Your resume file
    -s, --skill        Skill Name
    -v, --verbose      Enable verbose mode
    -h, --help         Display this help message.

Great! Then using it correctly will do this:

$ ruby slop_test.rb --resume hechicero-del-relámpago.doc
Here's the data
{:resume=>"hechicero-del-relámpago.doc", :skill=>nil, :verbose=>nil, :help=>nil}

The resume flag is the only required one, so in this case that’s how it’s run correctly.

Update: I was very happy that @lee_jarvis (the slop author) accepted my pull request to put this example into the README.

Redis and 595 Timer States

24 Sep 2014

I wanted to learn about how a 595 timer chip works. I’m a code dude. So when I see this integrated chip and all its pins, it’s scary. I’m sure an EE major is giggling right now but that’s just Impostor Syndrome. For no reason beyond this, I wanted to visualize and grok a 595 timer’s state at any given point by having it’s pins mapped to Redis key/value pairs.

Here’s a quick video explanation of the project.

Continue Reading →

Positive Change

17 Aug 2014

I’ve been in Portland for a week. So far, it’s amazing. I really don’t want to blather on about how great it is because, to be honest, I’m afraid of boyish optimism. This town, like college, will probably give back whatever I put into it. So I’m pacing myself. I think it will be good though.

Our house is completely empty while we wait for our movers to arrive and that’s ok. I’ve been getting a lot done without all the distractions. One of my favorite pictures of Steve Jobs is where he is sitting in an almost empty room with nothing but books. I’m not trying to be Steve Jobs but I appreciate the minimalism because my house looks very similar to this picture right now.

Continue Reading →

Default DC Tech is Just Bad

06 Jun 2014

The opinions of this blog, but especially this post are mine and not my employers’.

I’m done with DC. I need to archive the reasons why for myself. I hope this serves as a free field trip to the DC area for anyone outside the beltway.

TL;DR

If you move to DC for the tech jobs, you are going to have to prune a lot of C-minus government work if you are good. All the while, you will be paying for local benefits you are not taking advantage of. This is the land of politics, military, intelligence, big government and lobbyists. I tried to influence from within but now it's time for me to GTFO and move to Portland to try to find "actual reality" jobs.

Continue Reading →

Passion

19 May 2014

On a Ruby Rogues podcast about Passion, Avdi continued to enlighten and entertain me with his insights. I’ve really been enjoying his speaking style and voice lately through tapas and talks. If he reads this, I hope he understands I don’t disagree with what he is saying; I thought he would enjoy a related story.

Honestly, this topic is so massive I don’t think I can really offer too much more than the Rogues did on the podcast so I encourage you to listen to the episode yourself. It has almost nothing to do with programming or Ruby. I feel that philosophies and stories about passion are so close to the difficult and inevitable goal of “master yourself”, which is both complicated and personal, I can just barely approach the topic and then a rat’s nest of anecdotes and advice explodes all around us.

With that context laid out, here are a few stories.

Continue Reading →

DRY up Methods with Ruby Blocks

14 Sep 2013

Let’s do something terrible by hand. First, here’s our data. It comes from a database.

db_results = [
  { id: 1, login: 'mjay', roles: ['user'], projects: ['muffins'] },
  { id: 2, login: 'rroke', roles: ['admin', 'user'], projects: ['security'] },
  { id: 3, login: 'tpain', roles: ['user'], projects: ['muffins'] },
  { id: 4, login: 'ghaz', roles: ['admin', 'user'], projects: ['muffins', 'cakes'] },
  { id: 5, login: 'bbarker', roles: ['user'], projects: ['pies'] }
]

Now when working with these people, we probably could get away with doing something like this for a while:

# find all admins
admins = db_results.select {|user| user[:roles].include? 'admin' }

Which is fine. Until you want to find out what people are on the Muffin Project:

# find all people working on the muffins project
people_on_muffins = db_results.select {|user| user[:projects].include? 'muffins' }

But as you keep working, you might be getting a feeling of deja-vu. The two methods above are very similar. You might be inspired by other Ruby libraries which give you a tiny DSL or at least allow you to pass blocks into methods to be more expressive.

Continue Reading →

Problems with "The Cloud"

27 Aug 2013

I've been thinking about the problems with The Cloud outside it being a raging buzzword. It really comes down to Control and Connectivity. That's the problem but allow me to elaborate.

Control

Google Wave is a great example of control loss. If you really put a lot of energy, stock and trust into Google Wave as a content store for your team, brain or idea then you might feel deflated by its cancellation. Even as an idea and a disruptive alternative to E-mail or SMTP crappiness, it's a shame it had to die. So what now? Wait for an open source version? Host your own?

The idea was to "put it in the cloud" and forget about it. But when the cloud changes outside your control, you have to be aware of it again. Now you really have to think about the cloud itself. It's not such a vague black box which is what the cloud diagram really means.

Another example of control is YouTube. I use YouTube favorites as a persistent list. I see a cool video, I favorite it and I feel like I sort of own it, or at least it's in a list that I can refer to later. But take a look at this:

youtube_whoops

What were those things? Who knows! Now, I have to think about "the cloud" again. These are temporary videos that someone else ultimately controls. I'm just adding references to a list. I don't own the clips. They are transient. They are ephemeral. I'm out of control again. I don't even know what media I've lost. Do I mitigate again? Do I suck down a list periodically and do a diff?

Connectivity

I recently got a Roku box for my TV. It's a great box. During registration it does a bunch of sign up and account creation. But it doesn't work without uPNP enabled on the router. This isn't even a connectivity outage thing, it's a connectivity assumption that I have a certain kind of firewall that can't have holes punched in it ... or that I'm not capable of punching the holes myself. I don't even really know why Roku does this uPNP thing. All I know is, it wouldn't even finish the setup until I made this change. Now here's a device that doesn't work without connectivity or a clear path to connectivity.

Think about how picky that is for a second. If it's not picky then think about how many technical barriers there are to pure or uniform Internet. Everyone brings their own quilted environment and it's a mess.

IPv6 Spike

28 Jul 2013

A spike is when you play around with something and then throw it away for the purposes of learning. So, let’s play around with IPv6. I had read a little bit about it but essentially my working experience with IPv6 was nothing except for disabling it. Let’s learn some stuff!

I'm going to skip over all the history of IPv6 and assume that you agree with me and think that this is important and relevant to the future of the Internet.

Setup

First, build 4 Ubuntu VMs. I'm using 13.04 but any current Linux distro should work, just the packages and paths will change. I found the best way is to build a simple VM and then clone it 3 more times (in Fusion this is copy/paste and resetting the MAC address). You'll need four machines to simulate a local network. You won't need any network hardware and VMware will be able to simulate everything we need. You can actually do this whole experiment on one real box (cool stuff)!

The goal of this spike is:

  • Build 4 VMs
  • Make a router, a web server, a dns server and a client
  • Hit a web page between two network boundaries over IPv6 only

Continue Reading →

The Best Way to Read CSV in Ruby

16 Jun 2013

CSV is awful. CSV isn't well formed. It isn't hard to use because it's bloated and slow. CSV is hard to use because it's just a dumb data format. However, sometimes all you have is stupid data and who cares, let's do this thing and blot out the memories.

I assume you know how to use the CSV module that's built into Ruby. It's pretty easy. You just read a file in and you get some 2D array back. It usually comes out pretty horrible with long methods and little room for nice abstractions.

So what if you want to polish it up a little bit? Maybe you aren't just going to kludge this thing again and hate yourself later? What if you aren't just going to load this into a database? What if you want to do some quick CSV analysis but at the same time make it come out sort of readable?

Let's take a look at an abstraction layer and see how we could write a CSV loader for a guest list. We're going to have a dinner party and evite gave us a crappy CSV dump of who's responded so far. Well, it's what we have. But how many people are coming and how many groups aren't allergic to peanuts? We want to know how many peanut M&Ms to buy.

Here's our data:

Name, Plus, RSVP'd, Peanut Allergies
Tom DeLuise, 1, No, Yes
Mel Brooks, 3, Yes, Yes
Lewis Black, 5, Yes, No
Jon Stewart, 3, Yes, Yes
Jim Gaffigan, 0, Yes, No

Continue Reading →

Rails Dev Shops in Washington DC

10 Jun 2013

What shops, companies, consultants, startups or other folks are using Ruby or Rails (on any level)? Contact me on twitter if you want to be added or you have corrections: @squarism or leave a comment below.

Continue Reading →

Hi, I am
Chris Dillon