Ruby Culture at Retrocession

When I was at the Ruby Retrocession, I felt very welcome. That was great, obviously, and it’s not like I felt very unwelcome at previous conferences, but I want to talk for a second about why I felt so welcome at this Ruby event. If you organize, or even attend, tech events, making people welcome is pretty important. Making people feel extra welcome is a tool I didn’t know was missing, so I’m reporting it here in case someone else is missing it too. (Also, this post covers the “new concepts and terms” and the “impressions of the Ruby community” that I mentioned last time.)

Continue reading “Ruby Culture at Retrocession”

Ruby Retrocession Retrospective

On Saturday, I went to Ruby Retrocession, which is an unconference.

This was my first unconference, my first Ruby conference, and really my first programming event that was primarily in the open source space. That’s probably too much to go over in one post, so I’ll try to talk about the event over several posts with some logical division.

There seem to be four topics here:

  1. What an unconference even is
  2. My impressions of the Ruby community
  3. Terms and concepts I heard of for the first time
  4. Concrete advice and information that I got from the conference

I’m going to treat these topics in reverse order. There was a lot of good advice at the event, and I want to capture as much of that as I can. The book recommendations will probably be in separate posts.

Continue reading “Ruby Retrocession Retrospective”

A Little Bit of Magic

One of Ruby’s strengths as a language is that it allows a great deal of metaprogramming; that is, Ruby programs can modify themselves as they execute. Testing is a common place to see metaprogramming. Recently, I’ve been using Minitest, which is a testing library for Ruby. Minitest lets you mock methods fairly easily, but the way the syntax works feels pretty magical. I don’t like magic (at least not in software), so I wanted to try to dig into this metaprogramming a bit and understand how mocks work. Note, this post is not about when, or even whether, we should mock stuff in Ruby; I just want to understand how the testing libraries accomplish mocking, and specifically how they accomplish stubbing.

Continue reading “A Little Bit of Magic”

Running .NET DC

I’ve been privileged these past few months to run the .NET DC User Group. This post is about my experience doing so, in case someone out there is interested in running a user group.

First, a Thank You

I inherited this user group; I didn’t start it. The two previous organizers, @TashaEv and @justcallme98 re-started and grew the community. Before they moved away, they made sure that I had all the right accounts and passwords, and a bag of swag to give away, and a few months’ of speakers lined up. This post is about what it’s like to run a Meetup. @TashaEv and @justcallme98 did the hard part of actually building up the community. Thanks! Continue reading “Running .NET DC”

My GPS is Lost


The other day I was taking an Uber (though I’ve since switched to Lyft), and the driver told me that sometimes the GPS will admit that it’s lost. “Yeah,” she said, “sometimes it will say ‘GPS is lost’. Everyone thinks it’s funny when even the GPS is lost.” I realized that she was probably thinking about the message “GPS signal lost.” For me, hearing the message “GPS signal lost” is about signals. The app is telling me, “Hey! I depend on this particular type of signal, and right now I’m not receiving it.”


I heard signal as a central word in the GPS’s utterance. The way the driver spoke, though, it sounded as though what she heard when the GPS lost signal was that the GPS found the current directions too confusing. There’s a subtle type of miscommunication here: one person is automatically reading an utterance as a technical diagnosis, and the other is not inferring some piece of technical information. But both people were presented with the same exact utterance.

Continue reading “My GPS is Lost”

Early Observations on Ruby

I’ve been playing with Ruby for a few weeks now, and I have really enjoyed it so far. On the one hand, it’s a bit scary not to have the rich type checking and static analysis I’m used to from writing C# in Visual Studio. On the other hand, my source code feels a bit more concise, and I can’t paint myself into a corner with poor decisions about classes and interfaces. (I’m sure I can paint myself into a corner in other ways; I just haven’t found them yet.) Continue reading “Early Observations on Ruby”

Some Operator Names

I am a little behind right now, so this week’s post will be fairly short, and will also be a little bit reminiscent of something a high school Latin teacher would write. (Almost 2 years into full time programming, and I still think about Latin fairly often, and still miss my students.)

Anyway, today we’re going to explain unary, binary, and ternary. Every now and then I’ll be reading documentation and I’ll see a gem of a sentence about “ternary operators,” and I can’t help but think there’s a communication mismatch. When I imagine people reading through docs trying to figure out what a ? means in source code, I suspect that many of them do not find the phrase “ternary boolean operator” abundantly helpful. While we’re talking about ternary operators, we might as well cover unary operators and binary operators. Binary operators are extra confusing, because “binary” doesn’t seem to mean the same thing in the phrase “binary operator” that it means in phrases like “computers do math with binary numbers.” Continue reading “Some Operator Names”

TDD and Algorithms Class

As I mentioned in a previous post, I recently started taking a course on Coursera called “Discrete Optimization.” It’s hard, and I don’t have quite enough time in my schedule to finish everything, but I am learning a great deal.

My main concern with taking this course is to learn Ruby, and learn a little bit of test driven development. If I end up learning some cool algorithms along the way, I’ll take it. Continue reading “TDD and Algorithms Class”