Menu Sidebar
Menu

Avdi Grimm

Hacker; code documentarian.

In which I make you hate Ruby in 7 minutes

Per the roadmap I laid out the other day, I’m making a concerted effort to work on my meager Smalltalk knowledge. One of the best ways to cement knowledge is to pass it on, so I thought I’d make a little video showing some of the stuff I’ve been impressed with so far. In this video I TDD a method, with an emphasis on some of the development aids that the Pharo environment is able to offer.

For more on Pharo Smalltalk, check out:

 

A personal programming language roadmap

Lately I’ve become increasingly sensitive to how little time I have left to learn new technologies. It’s not that I’m nearing death: I’m not, at least not by 21st century baseline human standards. It’s more a matter of the impossible and ever-expanding variety of tech that is out there to be learned. That, coupled with the limited time that that my work commitments and my family commitments leave me with; a spare few hours a week at most.

There are lots of reasons to learn new technologies.  Probably the most common reason is job-related necessity: land a C# gig, learn C#. I’m fortunate in that I don’t have to let work dictate what I learn at this point. I get to pick and choose how I will fill my limited research time based on other criteria.

I’ve always been a programming language hobbyist. I’ve always kept lists in my head, lists of languages that I “totally want to play around with one of these days”. Long lists. But it’s time to get realistic about what I can actually accomplish in the time I have.

Since time is precious, I don’t want to be haphazard. I don’t want to dabble. I have some vague ideas about how I’d like to contribute to the field of software development, and toward that end I want to maximize the utility of the time I spend in study.

So today I sat down, and took a look at my bookshelf. I thought about all the programming languages I have queued up in my mental “it would be fun to learn…” or “it would be fun to spend more time with…” lists. And I did some painful triage.

I came up with a list of programming languages I want to make a concerted to learn, because I think they will expand my skill and understanding in important ways. Ways that will hopefully equip me to explore some new directions I’ve been thinking about.

Here’s the list:

  • Smalltalk (in the form of Pharo) because I need to understand Alan Kay’s ideas better.
  • Elixir/Erlang, because I need to grok using agents and CSP in practice
  • Rust, because I need a better C++ for certain plans, and one finally exists.
  • Clojure, because I need to have hands-on experience with an industrial-strength lisp, persistent data structures, property testing, and the various asynchrony facilities it offers.
  • Elm, because I need to understand the reactive model better.
  • Emacs Lisp, because for greater efficiency I need to become more fluent in reworking my programming environment.
  • Io, because I need to understand how prototype-based objects influence program design.
  • Scheme, because I still want to work my way through SICP some day. Also, Chicken looks like fun.

This implicitly means there is a much longer list of languages that are off the table for now. It was tough letting go of some of these. A few notables include:

  • Node.js, because it offers nothing new.
  • Dart, TypeScript: Because as interesting as they are, they just aren’t relevant to what I’m doing.
  • Go, because I don’t need a better C.
  • Haskell: this hurts, because I badly want to do more with Haskell. But Haskell already expanded my brain once, and I need to expand my brain in different directions now.
  • Common Lisp: I really want to be able to say that I know Common Lisp. But realistically, modern lisp projects are going to be started in Clojure, not CL. The only reason I might go back on this is to understand CLOS better, so I can steal ideas from it.
  • Idris: there’s a future in stronger static analysis, but I don’t think it’s my future. I’m more interested in improving dynamic analysis.
  • Java 8: There’s nothing there for me that I don’t already have.
  • C# 6: A lot of neat ideas here, but none that will expand my horizons substantially.
  • C++11/14: Too little, too late, with too much baggage. Especially now that Rust is stable.
  • Scala: Mainly of interest from a Functional and Reactive point of view, and I think I have that covered between Clojure and Elm.
  • TCL: Part of me still wants to return to TCL and have some more fun with it. But it’s not going to move me forward in any meaningful way.
  • Modern Perl: Same discussion as TCL.
  • Python: a fine language, but too similar to Ruby to be worth re-acquainting myself at this point.
  • UPDATE: Factor, because unique as it is I haven’t seen anything to suggest that it will teach me things I need to know. I might be persuaded otherwise, however.
  • UPDATE: Julia, for the same reasons and with the same caveat as Factor.
  • UPDATE: Prolog, because I’m not solving that sort of problem. I may revisit this one.
  • UPDATE: Lua, because I don’t need to embed a super fast and simple scripting language in anything just now.

Of course, there’s a lot more to programming technology than just languages. But that’s a list for another day.

This is my roadmap, defined by some very particular and personal forces. It should not be your roadmap. But I thought I’d share it, as a source of ideas.

If there is a programming language whose designers took into account the fact that humans would have to use fingers to type it onto keyboards for multiple hours a day, I have yet to encounter it.

I say this after investing a fair amount of time on typing.io, which treats programming languages purely as typing exercises. If you told a stenographer they had to take notes in Haskell, you would shortly find a typewriter-shaped indentation impressed upon your forehead. Lisp is probably the only language that comes remotely close to finger-friendly, and even then only if you are using an editor clever enough to remove the need to type Shift-9/Shift-0 every few milliseconds.

I realize that if you’re typing code so fast that finger-stamina is your principle limiter, you’re probably doing something wrong. But still. It is strange that this is not even a consideration.

Newer Posts
Older Posts

Virtuous Code

"The three virtues of a programmer: laziness, impatience, and hubris" — Larry Wall

Books and Screencasts

RubyTapas Screencasts

RubyTapas Screencasts

Small plates of gourmet Ruby code.

Confident Ruby

Confident Ruby cover

32 Patterns for joyful coding.

The Making of Cowsays.com

Confident Ruby cover

Watch me build an app in Sinatra and Rails

Objects on Rails

Objects on Rails

A developer notebook on applying classic Object-Oriented principles to Ruby on Rails projects.

Exceptional Ruby

Exceptional Ruby

The definitive guide to exceptions and failure handling in Ruby.

Archives

Categories