loading...

re: "Learn at least one new language every year" is bad advice VIEW POST

FULL DISCUSSION
 

While learning a different language every year does not preclude you from being a good programmer, I think that not learning new languages whenever you can does make you less adaptable and more reactionary.

I have 10+ years of Java experience, but without learning other languages I would not have learned some key things about development: (Now please note, that I don't claim expert knowledge, but I know enough to follow along and google anything I'm missing.)

Here's a vague summary of what I gained from each (alphabetic, not timeline):

  • Bash: How to unix
  • C#: A view of what "might-have-been" for Java.
  • C++: Syntactic sugar is good, but sometimes it gives you cavities.
  • C: The bridge between assembly and higher order languages
  • Clojure: Immutability and functional composition. Monads. List comprehension
  • Erlang: Pattern matching (Finishing something begun in F#)
  • F#: Type inference.
  • Go: Dependency management is a must-have for me. Terseness can be taken too far.
  • Haskell: Brevity is the soul of wit.
  • Javascript (post-node): Promises
  • Javascript (pre-node): UI is difficult, but not impossible.
  • Perl: the power (and some of the traps) of regex.
  • Prolog: 🤯 (Difficult things can become easy/Easy things can become difficult)
  • Python: the value of unit testing.
  • Ruby: code should be readable (and that idioms are sometimes a barrier to understanding)
  • Rust: Sometimes typing systems can be TOO tight.
  • Scala: Paradigmatic boatcars are unsatisfying to me.

But the main thing I gained from all this is that the primary difficulty in learning new languages is changing paradigms the first time. Once you've done that, you realize that the Algol family tree is so similar as to be identical when compared with the LISP family. (And when you get a little comfortable with Prolog, you learn that there are still worlds to conquer and wilderness to explore!)

I understand that it's difficult to leave the comforts of familiarity, but I'm here to tell you that if you could do it once (to learn ANY programming language) you can do it again. If you "fail" to learn a language, you lose nothing! In fact, you probably will learn something about yourself if you are paying attention. And that's the key takeaway for "learn a new language every year". You don't have to reach the summit [of mastering a language], you just have to keep striving to learn new things.

Now I will suggest some baby steps to get you on your way to learning a new language:

  • Read language agnostic architecture books.
  • Learn a new framework that is at odds with how you do things now.
  • Take a college math class on graph theory.
  • Tackle a part of the stack that you hate. (If you're backend, then do some middle or frontend)
  • Learn a new sport.
  • Convert cool github ideas into your language of choice.
  • Take a mindfulness based stress reduction course.
  • Play a lot of system/engine-heavy boardgames that were produced in the last decade. (May I suggest Terra Mystica? Power Grid? Agricola? Concordia?)
  • Make progress on a "rage game" style videogame. (Dark Souls, Cuphead, Celeleste, Hollow Knight, Ikagaruga)

Anyone have any more ways to encourage getting used to slow progress and systems appreciation?

 

Nice comments, Jon.

I think that not learning new languages whenever you can does make you less adaptable and more reactionary

I think it really depends on what you did instead of learning that new language. That's was my whole point in writing this post. If you have x hours to learn something new, what's the thing that will give you the biggest bang for your investment? Maybe it's learning a new language but it just might be learning usability testing, or conversion optimization, or statistics, or any of a million other things.

code of conduct - report abuse