Get Stronger With Geek’s Night Out

Make Testable Link

HOT TIP: Ted Young’s "Make Your Code More Testable" class is coming up August 23rd. The class is excellent (and covers much of what I talk about below), Ted is a wonderful teacher – and I scored you a discount code. Go to and use code GEEPAW when you sign up to get $75 off!

Programmers will ask me how they can become stronger at programming.

A very good way, one I use currently, is to get together once a week with a handful of geek friends of varying talents, interests, and projects, for a casual geekery-sharing session.

As ever, these long threads are just geek comfort food for me, and I hope for some of you, too. Changing code matters to me far less than changing the world does.

So stay safe, stay strong, stay angry, and stay kind. Black Lives Matter.

So let me lay this out for you.

That one-sentence opener actually has a couple of moving parts in it that I want to call out separately, and then, there’s a little more to say at the end, connected to my rants about the thinness of geek culture.

Notice that I am talking here about a group of friends, and a small one at that. My own group has six of us, and the world being what it is, often enough only four of us make it. These are not teammates, they’re my friends who happen to be geeks.

Friendship matters in this, because it lends the confidence that the space is safe. Safety is not only important for simple community, it’s also critically important for sharing our creations and our whacked-out ideas, which is one of the things we do.

A key phrase is "varying talents, interests, and projects".

The code we share isn’t in a project we share. It isn’t even in a language we share: my own group shows code from all over the place, in, over the past few months, C#, Java, Python, Swift, Lua, and Kotlin.

(It’s not that we’re all rock-stars in all these languages. Rather, it’s that, to an extent most juniors don’t really get yet, ya seen one language, ya kinda seen’em all. That’s not universally true, of course, but it is broadly so.)

The variation in project is especially cool, because it means that, most geek-night-outs, at least one of us will have something very cool or very annoying to show around the room.

Next, casual is very important.

There’s no agenda. Just a time and a zoom link. Whoever shows up shows up, though we do periodically poke the ones of us who haven’t been there for a while.

What we do when we’re not doing anything geeky: hang out, joke, gossip, talk trash, share our non-geek stories (and our very different interests.) The discourse goes all over the place.

But, we’re geeks, don’tcha know, we like code and coding. So nearly every time, sooner or later, one of us will show all of us some code. Maybe there’s a question, or maybe it’s just an ordinary show and tell. We also have a text channel just for us, and use that some.

When we do look at code, it’s not like an ensemble session. We don’t swap-off or anything. Rather, the presenter drives, and the rest of us offer commentary and advice and support, and a certain amount of snark, of course.

There’s a lot, "it feels like…" or "what if you…" or even just "oh! cool." We’ve found bugs for each other, proposed tests, presented refactoring ideas, all kinds of stuff.

An interesting aspect: it’s not at all uncommon for several of us to get sucked in to thinking and toying with some aspect of someone else’s project.

This is especially true when the code touches on some "data structures & algorithms" thing.

At one point, I was messing with the idea of a game that was about gerrymandering, and it led us to the question of tiling a grid plane with an arbitrary set of orthogonally connected shapes.

It turns out there are a lot of ways one can approach the problem of taking fixed pentominos (look it up) and using them to tile a 5×5 grid. We wound up with three different implementations in three different languages. all correct and all different. 🙂

The reason is because DS&A problems have solutions that can be implemented in any Turing complete environment we have laying around. And their essential nature can be quickly sketched or spoken of. If they’re fancy, they even get us into computational complexity theory.

Anyway, the thing about this practice is that it involves a great deal of relaxed fun, and a surprising amount of learning from each other.

We learn about languages, projects, vocabulary, patterns, idioms, and even syntax sometimes.

We draw pictures of problems, and hold them up to the camera. We write psuedo-code in a text editor. And what we get, I think, the biggest thing we get, is how many different ways there are to do the work of being a geek.

I have rants all over the place about the thinness of geek culture. And part of what I see as that thinness is a belief that geekery is about knowing everything about one subject, one domain, one language, one way of working. But it isn’t.

Geekery isn’t a scholarly pursuit for academics to know more and more about less and less, it’s a festival of creativity and ingenuity.

It’s not finding the one best way, it’s about knowing there are lots of ways, and how they relate to one another.

So think about it. Got some friends who are geeks? Call a geek’s night out, a couple of hours, once a week or so. Set up a zoom link and an async channel, and try it. Doing this is fun for me, and it also has made and continues to make me a stronger programmer.

Do you love the GeePaw Podcast?

If so, consider a monthly donation to help keep the content flowing. You can also subscribe for free to get weekly posts sent straight to your inbox. And to get more involved in the conversation, jump into the Camerata and start talking to other like-minded Change-Harvesters today.

Want new posts straight to your inbox once-a-week?
Scroll to Top