On Learning Different Programming Languages

Note: This is a presentation I gave at Optibus in 2024. The content was adapted to work as standalone blog post.

Over the course of my career i’ve learned multiple programing languages. Some of them were forced on me by outside circumstances, and some of them were chosen based on my own interests.

In the beginning i saw them as means to an end, where the real objective was to get the job done.

But as i’ve grown as a developer, i’ve started to enjoy the journey of learning something new, and the process of understanding the philosophy behind it.

Why Learn New Programming Languages?

Learning new languages is not about chasing trends. It’s about discovering new ways of solving problems and expanding your mindset. As Alan J. Perlis famously said [ ¹ ]:

“A language that doesn’t affect the way you think about programming is not worth knowing.”

Understanding multiple paradigms sharpens your skills, helps you write better code, and makes you a more flexible developer.

Things to Keep in Mind

It is important to remember though that knowing only a few languages doesn’t make you a bad developer. Some of the brightest minds of our industry programmed in few languages in their career

Also, some languages are just…bad. Some were created without much thought or evolved to something completely different from what they were intended to be. (hello, Javascript, i’m looking at you).

The successful languages last long for a reason, and the newer ones are usually created to solve problems in a different way or to address some of the pains of that ones that came before them.

Examples From My Journey

Ruby

Ruby taught me that code can be beautiful. It prioritizes developer happiness and expressiveness. With its powerful metaprogramming capabilities, it allows developers to create DSLs for their own needs.

set :haml, :format => :html5

get '/' do
  haml :index
end

Shoes.app do
    background "#EFC"
    border("#BE8",
           strokewidth: 6)

    stack(margin: 12) do
      para "Enter your name"
      flow do
        edit_line
        button "OK"
      end
    end
  end

(Examples of DSLs built with Ruby)

Go

With Go i’ve learned about the importance of good tooling. I love how minimalist it is and how, with the help of tools like gofmt, goimports and the lack of abstractions, every code written in it is easy to read and understand.

Go was also the first language that i learned that was actually fast, with a powerful multi-architecture compiler. Even though I had experience high speed with Java, i never felt that i was in control of the performance of my code like i do with Go.

Clojure

Clojure was my first functional programming language. It was a great way to learn about the power of immutability and how to write code that is easy to reason about. Also, the fact that it was a Lisp dialect, it introduced me to the power of macros and the REPL-driven development.

Building a Developer Toolset

Overtime I came to realize that as a good developer, it is important to maintain a well-rounded toolset, so we can use the best tool for the job.

When assembling my toolset I look for languages that would fit in the following categories:

• All-rounded: Are easy to pick up and good for fast prototyping
• For web: Run in the browser
• Functional: Support functional paradigms for correctness and fewer side-effects
• High-performance: For resource-intensive tasks

Here’s how I currently approach language selection:

• All-rounded: Ruby - A joy to work with, simple and efficient.
• For the Web: TypeScript — Helps maintain sanity in the JavaScript ecosystem.
• Functional: Clojure — Elegant and expressive functional programming.
• Fast: Go (?) — High performance, but portability has trade-offs.

The language of choice in each category might change over time, but i believe that this balance has been a good one for me. I had for a while Clojure, Go, and even Python, as my all-rounded language, for example, but settled back to Ruby do its powerful scripting capabilities.

How I Evaluate a Language

All modern languages have a reason to exist, and their mission is quite often summarized in their homepage. Let’s take a look at some examples:

Ruby is… A dynamic, open source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write. [ ² ]

Rust: A language empowering everyone to build reliable and efficient software. [ ³ ]

Clojure is a robust, practical, and fast programming language with a set of useful features that together form a simple, coherent, and powerful tool. [ ⁴ ]

So, before picking a language, it is important to understand what it is trying to solve, and how it does it.

The Language “Skill Points”

If you ever played a role-playing game, you might be familiar with the concept of “skill points”, where you have a limited number of points to distribute between different traits of your character.

In the same way, when picking a language, we can assign “skill points” to different traits of the language, and see how it compares to the others. The number of points available is the same for all languages. Don’t fool yourself into thinking that you can have a language that aces all traits.

These are the traits I consider important in a language:

• Ease of use
• Safety
• Performance
• Ecosystem
• Adoption
• Design & Ergonomics

I visualize this as assigning “skill points” to each trait, almost like building a character in an RPG.

Conclusion

Learning new languages improves your problem-solving toolkit and deepens your understanding of programming. Even if you don’t use a language every day, the perspective it brings can transform how you write code in your primary language.

Embrace the challenge — your future self will thank you.