Summary

Russel Winder emphasizes the importance of a programmer mastering more than two programming languages to avoid a one-dimensional approach to problem-solving and to embrace the challenges and learning opportunities presented by diverse computational models.

Abstract

In the 44th step of the "Programming Enlightenment" series, Russel Winder argues that proficiency in multiple programming languages is crucial for a programmer's growth. He suggests that while specialization in one language can streamline workflows, it may also limit problem-solving perspectives. Winder illustrates the progression from languages like C, Pascal, and Fortran, which share a fundamental computational model, to more complex ones like C++, Ada, Haskell, and Prolog, which introduce significant changes in programming paradigms. The shift towards polyglot programming is evident in the industry, with job descriptions reflecting this trend. Winder advises that learning new languages each year, as recommended by Hunt and Thomas in "The Pragmatic Programmer," is essential for expanding one's understanding of different computational paradigms, idioms, and use-cases. However, he cautions that this learning should be purposeful, with a focus on understanding the history, rationale, and problem-solving capabilities of each language. The article encourages programmers to embrace the challenge of learning new languages to enrich their approach to problem-solving, despite the potential overhead and steep learning curves.

Opinions

Mastering multiple programming languages is vital for broadening a programmer's problem-solving abilities.
Specialization in a single programming language can lead to a narrow approach to engineering problems.
Each programming language has its own set of paradigms, idioms, and use-cases that are valuable for a programmer to understand.
The transition from one language to another can range from relatively straightforward (e.g., C to Fortran) to significantly challenging (e.g., C++ to Haskell or Prolog), each offering unique learning opportunities.
Polyglot programming is becoming increasingly relevant in the industry, necessitating a diverse language skill set.
Programmers are encouraged to learn at least one new programming language annually to evolve and stay current in their field.
Learning should be intentional and include an understanding of the history and problem-solving contributions of each new language.
Despite the potential difficulties and time investment required to learn a new language, the benefits of expanded expertise outweigh these challenges.

Step 44: Know Well More Than Two Programming Languages ~Russel Winder

This is the 44th Step towards gaining the Programming Enlightenment series. If you didn’t learn the 43rd Step, read it.

Why learn a new programming language?

It may be wise to say being proficient in one domain will specialize you in that category. Similar, if we focus on one language for work than over time it will standardize the workflow and there will be no learning burden. Which is almost true.

On the contrary, what it also means is the more one is adept at doing things, s/he will be more one dimensional towards problem-solving. It constrains the way they try to solve engineering problems.

C, Pascal, Fortran, all have the same fundamental computational model.

Switching from Fortran to C introduces a few, but not many, challenges.

Moving from C or Fortran to C++ or Ada introduces fundamental challenges in the way programs behave.

Moving from C++ to Haskell is a significant change and hence a significant challenge.

Moving from C to Prolog is a very definite challenge.

Besides we are entering a period of Polyglot Programming, which can be easily understood by the job description published everywhere.

What really affects when we learn different languages?

Different languages surface out to solve numerous problems that their predecessors didn’t.

Moving between languages will teach us paradigms of computation: procedural, object-oriented, functional, logic, reactive-programming, lambdas, data-structures in each language etc.

These movements might be the greatest challenges of all. It might just change the way we approach the problem. Like doing Procedural — > Object-oriented — > Functional programming, it teaches the different approach to work the same problem.

How to do it?

“Although it is suggested that developers should learn at least one new programming language per year to evolve (Hunt and Thomas, 1999).”

Both the advice from “The Pragmatic Programmer” and the statement by Hunt and Thomas, suggests that for us to grow as a programmer, we should try to learn new programming language each year.

But beware, the learning shouldn’t be just for learning sake. We should try to understand the history behind it. Why people architected the new language? What problem did it solve? How did it solve the problem? Learn it’s idioms, it’s use-case. Try experimenting with a simple Calculator or ToDoList application.

Last but not the least, as an engineer, we try to solve a problem, we love solving the problem. There might be overhead that might deter us from learning a new language. And in some cases, huge learning curve even to understand the basics of it.

Keep in mind that 365 days is too long even one can travel around the world in 80 days.

TL;DR Learn a new thing every day. Learn a new programming language each year.

Go to the series.

97 Journey Every Programmer should Accomplish

“A journey of a thousand miles begins with a single step.”

medium.com

Go to 43rd Step

Step 43: Know How to Use Command-Line Tools ~ Carroll Robinson

This is the 43rd Step towards gaining the Programming Enlightenment series. If you didn’t learn the 42nd Step, read it.

medium.com

Go to the next path (Coming soon).

References:

97 things Every Programmer Should Know ~ Git Book
97 Things Every Programmer Should Know ~ Paperback
One Language ~ martinfowler.com
Being a developer after 40 ~ medium blog