logoalt Hacker News

bryanlarsen • yesterday at 9:12 PM • 14 replies • view on HN

A standard piece of advice is that every developer should do a major project in every big language family. A Lisp, an OO language, a functional language, Prolog, VHDL or Verilog, a Forth, et cetera. They'll all make you think differently and teach you lessons you will use outside of the family.


Replies

nomel • yesterday at 9:47 PM

> Verilog

My favorite side quest that I definitely recommend. Physical parallelism is so fun to reason about.

I had the advantage of sitting next to a proper professional to bounces questions off of, so I was able to get an SPDIF decoder to work in about a week! It was a very interesting lesson in the costs of abstraction, and why you will never really find abstraction layers in hardware.

➕ show 2 replies
democracy • today at 12:01 AM

lisp, prolog, forth, etc - no such standard piece of advice

brightball • yesterday at 9:44 PM

100% agree with this.

Elixir was somewhere between my 12th-14th language and nothing changed my perspective so much as understanding why the BEAM works the way it does.

➕ show 1 reply
ivanjermakov • yesterday at 10:45 PM

Advent of Code is coming in two weeks, I highly recommend completing 12 challenges in 12 different languages!

forinti • yesterday at 10:28 PM

I had so much fun with Lisp and Scheme at uni that it makes me sad to have never coded professionally with them. On the other hand, I have written PostScript for money, which was completely unexpected.

➕ show 1 reply
MomsAVoxell • yesterday at 9:52 PM

I have applied this for decades, with multiple languages under my belt, and multiple million-dollar projects on my CV, and meanwhile I have found another similar rule that I think also sharpens a developers mind:

Put Lua in things.

Now, before you anti-Lua types start jumping on that 0-indexed down-vote, let me explain. Its not just about the language, its about the "thing" you're putting it in, its about using the VM effectively, its about planning and using the stack properly. It's about using one language to leverage the strengths - and discover the weaknesses - of other languages, runtimes, ABI's.

Putting Lua in things is easy - and it is hard. It teaches you how to treat other things with respect, and it teaches you how to disregard other things and "Just Use Lua™".

You can learn the language - multiple variants of it. You can learn the 'things' you're putting it in. You can learn how a VM works, what byte code is, how it can be used effectively - and how it can be used counter-productively, too.

It will teach you the limits of a language - Lua, and C - and it will teach you the strengths of both (as well as Rust, and all the other things you can get an FFI scaffolding built around).

You can use Lua to produce your own domain specific language. You can use it to (almost, or indeed completely) replace whatever other language the "thing" is using. You can use it to minimize the impact of a VM and scripting and byte code - you can learn how to maximize these things as well. You can learn byte code and you can leverage that understanding to learn machine language - two ends of a very similar (yet vastly different) spectrum.

You can learn how slow/fast pieces of the system interact productively and effectively - you can learn how things get mightily messed up, also, if you use the wrong lubricant.

In the end, you may not even end up using it for productive things - but you might also do something extremely powerful. (I have.) Either way, by applying this maxim and applying the skills needed to master doing it (or screw it up entirely), you can learn pretty much everything interesting there is to learn about software (besides LLM's) in today's modern stack madness .. and then some.

Seriously, give it a try.

The other one of these developer-tuning activities (there are a few), is to do a Linux From Scratch session at least twice a year. Do it this year, but plan on doing it again next year as well. Do it a few more times this decade.

Iterate. Extend. Ignite.

➕ show 1 reply
agumonkey • yesterday at 11:28 PM

but then you suffer from working in places where people only knew one language, because they won't grasp your code or ideas and you will have to live in their limited conventions

➕ show 1 reply
jghn • yesterday at 9:17 PM

This. It's not Rust in the author's case. It's being exposed to a language that's enough different from what they're used to that it affects their big picture.

➕ show 2 replies
sedatk • yesterday at 10:48 PM

Even minor projects can have great impact when developed using different paradigms.

➕ show 1 reply
lnenad • yesterday at 9:31 PM

Agreed 100%. This is the single most useful thing I experienced in my career.

jahnu • yesterday at 9:29 PM

What counts as a major project?

➕ show 7 replies
harveymadeunico • yesterday at 9:53 PM

If you could maybe reduce that down a bit that would be great. No one in their right mind has the time for major projects in all of those.

Another way to do it would be the standard low->high level and then one based on lambda calculus. Von Neumann and Church.

Assembly, C, Java, Clojure.

Assembly, C, C#, F#.

Assembly, Fortran, Rust, Rust, Brainf*ck.

➕ show 1 reply
begueradj • yesterday at 9:49 PM

It's like saying a novelist should write a major novel in every important spoken language.

➕ show 5 replies