I know most people make resolutions to lose weight, to have a sunnier disposition, to not kill kittens, etc., but I think this year some technology resolutions are appropriate.

To wit . . . in no particular order. My goal is to accomplish 5 after the first one (which is mandatory!).

• Do my part to ensure the ongoing awesomeness of Iora Health’s technology!

1. Attend at least one European technology conference, and/or a medical technology conference.
2. Don’t do any non-Iora contracting or proprietary development for friends or former colleagues, no matter how interesting the project is; only open source, which should emerge from Iora. I’ll allow a couple of projects to be grandfathered-in to a small extent, but that’s it.
3. Freshen at least one legacy project with guidance from Working Effectively with Legacy Code.
4. Present at a Ruby conference.
5. Don’t let myself or others build in excess of the story.
6. Be more persuasive in opposition when I observe myself or others using APIs and/or techniques that are costly (in time or money) or inappropriate. I went down the rabbit hole a bit this year with Google Calendar integration, against my better judgement.
7. Tighten up my Linux/OS/X and vim dotfiles. I’ve never used a pre-fab dotfiles and have my own, but it’s time to look over what’s out there and integrate some new features. Bonus: Stop using the arrow keys in vim. Use standard vim movement bindings instead.
8. Sharpen up my Scheme. Be able to write the major combinators without consulting an authority.
9. Cover more “hard cases” for BDD. I allowed too many specs to be more shallow than I know is proper.
10. Think about how I can productively contribute to hacktivism and/or “digital humanities” — I have a lot of latent knowledge and experience in this area, and it’s time to revive it. Why should the kids have all the fun?

I haven’t touched a Windows computer in many years. OK, I have a virtual machine with XP installed, but it’s a clean install with no cruft and I basically only use it to verify browser stuff.

My dad, though, has two Windows computers, a laptop and a desktop, both running XP from, oh, six years ago. It is like the dark ages. In our house he needs to use wifi. That means that for his desktop, he needs to use a wireless USB adapter.

Among other things, you can’t just plug it in and expect it to work: You have to install with a CDROM. That’s WORNG #1.

Then you get this funky configuration screen just for that adapter, and it supplants your normal Windows settings. WORNG #2.

Then it belabors everything. The scan for SSID’s is amazingly slow. Then when you pick your network, it wants to show you every damn setting, and exposes the fact that it’s WPA, etc. A nightmare. WORNG #3.

Then it is so to get itself established after a reboot. WORNG #4.

So it’s just garbage. I guess I should count my blessings that I could but a device “Certified for Windows 7″ and see that it works on XP.

Meanwhile . . . email. Outlook Express, ZOMG!!

I’ve used a lot of awful consumer electronics products, but the ASUS AiGuru SV1T wins the “Worst Consumer Electronics Product of 2011″ Award. Oh, wait, you could buy one in 2010; maybe even in 2009. So it sweeps the award for three years running.

This is supposed to be an “appliance” Skype VideoPhone that makes it easy to make a call. We were told in the movie 2001 that this would be implemented in payphones by now. So payphones are obsolete, but we’re still waiting for a no-brainer video phone that your grandma can use.

We acquired this for office use, and found it lacking. I took it home and tried to dump it on Craig’s List – no takers. Then it languished in my home office, and just recently I decided to give it another assessment. It still sucks.

Before I begin, let me say that this is a prime example of a product that should be a one-button interface: Call my favorite number. Would that be asking too much?

But everything about this product is wrong.

When I tap the green “phone” icon, it does what? Suggests that I enter a phone number. Hello! I want to use Skype! Remember? Phone numbers are great, but secondary. Please let me just browse my Skype contacts. To be sure, I can tap the right arrow to get to my contacts, but then I have to select that user, then tap “Video call.” Tap tap tap. This is wrong.

Call quality: Terrible. The video is always grainy and the updates are slow. Additionally, I have this thing plugged in with an Ethernet cable to avoid the vagaries of wireless. It constantly (really: always) tells me that the network connection is lost and/or that the network connection has “changed” (no it hasn’t), and I lose my call or have to interact with the machine.

There are no options in the “Advanced” settings to probe connection quality, insist that the Ethernet connection be favored over wireless (or used alone).

Finally: The greatest sin: Some of these issues could be fixed with updated software. As of this writing (14-Dec-2011) I have the latest software, dated . . . well, I’d like to tell you, but to do that, the phone has to connect, and as of right now it’s “attempting” to connect. But not succeeding. Sheesh. Anyway, the date of last update was October, 2010. There is nothing I can find at ASUS Support with guidelines for troubleshooting, etc.

It is hard for me to imagine how ASUS screwed this up as badly as it did. All this thing is, is a repackaged laptop. The user interface gaffes I can forgive if the performance was great. But it isn’t.

Do not buy this product.

Meanwhile, someone should introduce an awesome Skype VideoPhone. I am sure you are saying: Use an iPad. But there are great use cases for a dedicated device, the chief one being that you want to use your iPad while on a call, or you want to share the call with others. Perhaps you’ll tell me just to buy a 2nd iPad. Yeah, I could do that, but where’s my “call my most frequently used number” button? And so on.

There has got to be any easier way.

require 'rubygems'
require 'tzinfo'
require 'active_support'
require 'active_support/values/time_zone'

time_zone_names = [ 'Eastern Time (US & Canada)', 'Central Time (US & Canada)', 'Paris' ]
abbrev_to_zone = time_zone_names.inject({}) do |map, name|
  map[ActiveSupport::TimeZone.find_tzinfo(name).current_period.abbreviation.to_s] = name; map
end

p Time.now.zone
p abbrev_to_zone[Time.now.zone]
p abbrev_to_zone['CET']

Ow.

In Rails 3.0, the default ActiveSupport::JSON backend is YAML.

In Rails 3.1, it’s YAJL.

They deserialize JSON times differently. In 3.0 . . .

ruby-1.9.2-p290 :001 > ActiveSupport::JSON.decode( '{"at": "2011-10-13T12:00:00+00:00"}' )
 => {"at"=>2011-10-13 07:00:00 -0500} 

See the lack of quotation marks around what “at” points to? It’s not a String. YAML converts the value to an actual DateTime. (There a DATE_REGEX defined in ActiveSupport::JSON that does the matching.

But in 3.1:

ruby-1.9.2-p290 :001 > ActiveSupport::JSON.decode( '{"at": "2011-10-13T12:00:00+00:00"}' )
 => {"at"=>"2011-10-13T12:00:00+00:00"} 

We had the yajl-ruby gem installed for development, so were getting the the Strings. Then on our staging server, we were getting the already-parsed time value, and were getting errors.

This strikes me as a substantive change. I’m not sure I’d call it a bug, but it was unexpected.

So here’s a good one. We had a spec that looked something like this:

require 'time'

class SomeModel
  def self.all
    @all ||= []
  end
  def self.create!(time)
   all << new
  end
end

describe "surprise" do
  subject { SomeModel }
  let!(:now) { Time.now }
  ['9 AM', '10 AM', '11 AM'].each do |hour|
    let!(:time) { Time.mktime(now.year, now.month, now.day, Time.parse(hour).hour) }
    let!(:some_model) { SomeModel.create!(time) }
  end
  its(:all) { should have(3).items }
end

(In the original code, rather than check that the .all method returned a enumeration with 3 items, we were describing the behavior of a different object to see if it could do something when three collaborating objects had already been created via factories.)

The spec told us this:

     Failure/Error: its(:all) { should have(3).items }
       expected 3 items, got 1

That’s funny. How come we don’t have three items? Let’s try a bit of puts debugging. We’ll dump the value of hour just inside the block passed to #each. And we get:

hour: 9 AM
hour: 10 AM
hour: 11 AM

Well that’s expected. Gee, maybe our collaborator is buggy (and maybe we should be mocking it anyway, but let that pass). Let’s show the hour inside of what the let defines:

  ['9 AM', '10 AM', '11 AM'].each do |hour|
    puts "hour: #{hour}"
    let!(:time) { puts "hour inside time: #{hour}"; Time.mktime(now.year, now.month, now.day, Time.parse(hour).hour) }
    let!(:some_model) { SomeModel.create!(time) }
  end

What do we get?

hour: 9 AM
hour: 10 AM
hour: 11 AM
hour inside time: 11 AM
F

Interesting.

The problem is that we hadn’t internalized properly the documentation for the RSpec let (and let!) helper. The documentation says: “Use let to define a memoized helper method. The value will be cached across multiple calls in the same example but not across examples. Note that let is lazy-evaluated: it is not evaluated until the first time the method it defines is invoked. You can use let! to force the method’s invocation before each example” (https://www.relishapp.com/rspec/rspec-core/docs/helper-methods/let-and-let).

The key phrase is “define a . . . method.” So what our code is doing above is simply redefining the #time and #some_model methods over and over. Then, since the execution is deferred, we would get the #time method returning ‘11 AM’ and the #some_model method instantiating only one SomeModel.

Before we touch on one way to fix this, let’s look at some of the implications of what let does. For one thing, let’s remember that the method will only be executed once (since it’s memoized). For example:

describe "no surprise" do
  let(:x) { puts "x defined to return 'a'"; "a" }
  let(:x) { puts "x defined to return 'b'"; "b" }
  it "should have the expected setup value" do
    x.should == "b"
    x.should == "b"
  end
end

When this spec is run, we are going to see “x defined to return ‘b’” once. We don’t see “x defined to return ‘a’” because the execution is deferred, and the second let(:x) wipes out the first. Since the result is memoized, we only see “x defined to return ‘b’” get printed out once:

$ rspec spec/example2_spec.rb
x defined to return 'b'
.

Finished in 0.00034 seconds
1 example, 0 failures

Additionally, since let defines methods, and since execution of the methods is deferred until after they have all been defined, you can have earlier methods depend on later methods:

describe "no surprise" do
  let(:x) { y + 1 }
  let(:y) { 1 }
  it "should not matter in what order these methods are defined" do
    x.should == 2
  end
end

So why the confusion? I think there are a couple of reasons. The main thing is that word “let.” It sounds as though we are assigning a value to a key. It is not uncommon to see sequences of lets like so:

let!(:last) { Factory(:user, last_name: 'zzz', first_name: 'aaa') }
let!(:center) { Factory(:user, last_name: 'aaa', first_name: 'abc') }
let!(:first) { Factory(:user, last_name: 'aaa', first_name: 'aabc') }

So let looks something like an assignment. Why is it called let? I don’t know. Maybe it’s supposed to feel a bit like Common Lisp where let is a stand-in for lambda. Maybe the thought was that if “assigns” or “set” was used, it would be ambiguous given how these terms are used elsewhere in Ruby and Rails.

If you ask me, a name such as “dm” (for define_method) would have been more appropriate. Then noobs (like me — I’ve always used Test::Unit) would wonder what it stands for, look it up in the documentation, and get some insight. “let” is just too abstract.

The original problem? If we must use let, perhaps define an Array with the let:

describe "surprise" do
  subject { SomeModel }
  let!(:now) { Time.now }
  let!(:some_models) do
    ['9 AM', '10 AM', '11 AM'].map do |hour|
      SomeModel.create!(Time.mktime(now.year, now.month, now.day, Time.parse(hour).hour))
    end
  end
  its(:all) { should have(3).items }
end

One last thing. Discussions in books are a bit misleading, or don’t tell the truth soon enough. For instance, in Noel Rappin’s book Rails Test Prescriptions (which is not only excellent but actually funny), he introduces let by saying: “Using let(), you can make a variable available within the current example group[.] . . . The symbol can then be called as if it was a local variable” (p. 193). Well, this is true, but by saying that “you can make a variable available,” it sounds like variable assignment — which it just isn’t. Among other things, just saying that makes one thing that the order of the let’s is important in terms of the values that will eventually be assigned. Thankfully he says just a wee bit later, “a let() call is syntactic sugar for defining a method and memoizing the the result.” Yes. But this is one of those cases where easing into the truth can be harmful.

The RSpec Book (Chelimsky, et al.) does a similar thing, rhetorically: “When the code in a before block is only creating instance variables and assigning them values, which is most of the time, we can use RSpec’s let() method instead” (p. 55). Again, this is a bit slippery. It’s not like creating instance variables at all. It’s like calling a method. Which, of course, Chelimsky immediately explains.

The upshot:

1. Don’t put your calls to let inside of loops! (If you must, have the calls to let define different symbols.)
2. Don’t assume that the methods will run in the order of the lets.

At the beginning of the summer, I had numerous reboots of my cable modem. Typically this would happen when I was making heavy use of the network. It could happen 5 times an hour. Of course I called Comcast. They had a lot of suggestions: Let’s re-flash your modem; upgrade the software on your router; try a different router. I suggested: Maybe it’s the link from my house to upstream? Comcast: No, we’ve checked that. They were responsive (good response from one of their Twitter helpers) . . . but couldn’t make it work.

Then about 3 weeks ago (unbidden from me), Comcast told me that I wouldn’t have service for a couple of days. They did something.

Now? The network runs like a charm. I had switched routers somewhere back in there, so, cautiously, I put my fastest router back on, and it’s worked like a charm. The reboot after Sept. 20 was from a manual reboot.

Comcast! What is wrong with you? Why is it always like this?

You’re going to get disintermediated, Comcast!

One of the worse credit card sites on the Internet. How ’bout this? I would guess that “1-1027″ is an error number you report to an operator, rather than a suggested value range.

Let’s say that we have a Ruby object with some class methods. In my case, we want to be able to inject a driver at the class level that all instances will use:

class Mod::Thingy
  def self.driver
  end
  def self.driver=(d)
  end
end

And let’s say that .driver has a default value. So the class looks more like this:

class Mod::Thingy
  def self.driver
    @driver || DefaultDriver
  end
  def self.driver=(d)
    @driver = d
  end
end

Now here’s the dealio. Let’s say that we test for the default value first. So we check Mod::Thingy.driver == DefaultDriver. Then we test the setter. We do Mod::Thingy.driver = OtherDriver, and then check the return value of Mod::Thingy.driver. Fair enough.

But what if we ran the examples in reverse? Now we do Mod::Thingy.driver = OtherDriver first, check it; but now in our second test, we can’t test the default value, because the state of Mod::Thingy has been changed.

Strategies:

1. We might use RSpec’s around feature to save the state of Mod::Thingy.driver and restore it afterwards. What I don’t like about this is that now the around method has to know all about all of the setters at the class level. Meanwhile, it is possible to imagine objects that are difficult to set back to their default state: Perhaps the class methods have order dependencies themselves. This would make the test need to know a lot about the inner state of the object.
2. We might provide a .reset! method on the object. But this seems a bit nutty: Add a method just to make testing easier?
3. What about this in an RSpec before(:each) block:

   
       Mod.send(:remove_const, 'Thingy')
       load "#{PROJECT_ROOT}/lib/mod/thingy.rb"
   

   Now we’re getting a nice clean class. To me, (3) is more parallel to the testing convention of new’ing up an object instance for the test.

Thoughts?

I’ve heard two people complain that they can’t see OAuth HTTP behavior and get unexpected 401s. If you want to see what’s going on at the transport level, here’s a monkeypatch (depends on ActiveSupport for the alias_method_chain) just for you:

class Net::HTTP

  def initialize_with_debug(*args, &block)
    initialize_without_debug(*args, &block)
    set_debug_output $stderr
  end

  alias_method_chain :initialize, :debug
end