Adventures in the World of Programming Languages

I've got a Hot Take: All popular programming languages nowadays are basically the same. If you squint hard enough Python, C, Rust, Javascript, Go, they all kinda look similar. Ya ya ya there are differences in how memory is managed, or if its array.append or array.push, but these are implementation details. Really, the way you solve problems between these languages is the same. I can take a function or an algorithm in one language and translate it to another with little difficulty.

We live in the country of Clandia, and all languages must conform to its laws.

But there are other places. Countries where Languages look weird and foreign. Places where your Clandia algorithms would not be easily rewritten. Places where you have to learn to think differently than before!

Years ago I set off from Clandia in search of different programming languages, these are my adventures and lessons so far.

The first Country was really only a half day's journey away, the Land of Lisp. I was first introduced to Lisp by a coworker, and evangelist missionary of Emacs. He promised a truly flexible text editor built on a truly flexible language.

At first the deluge of parentheses blinded me, and I had to relearn to read. But over time the parentheses faded away, and with them many false walls I had believed existed.

In boring Clandia programming languages, Expressions evaluates to something, where statements do something. This distinction is important because there are rules for where and how you can use expression vs statements. You can't just put anything in an if statement...

Except you totally can. 

# if you're used to something like python this should look insane
(if (do (while (!= 200 (http-status (api-request "http://google.com")))
  	(sleep 1))
	(do-some-side-effect)
	(= "good result" (check-some-status))) # finally evaluates to a bool
	(print "hello world"))

In the Land of Lisp Everying is an expression, since you're writing in the Abstract Syntax Tree.

All this extra syntax is an illusion.

This is a fundamental truth I will take with me on all my future travels. Lisp has taught me to look at running code as something that changes and morphs. A function doesn't return a value, it turns into that value! My brain has been trained to internally do these replacement transformations and it's made me a better programmer. 

# consider this function and a call of it
(defn hotdog [name]
  (+ "eat a hotdog " name))
(+ "eat a pizza, then " (hotdog "reader"))

# you can inline the function call
(+ "eat a pizza, then " "eat a hotdog" "reader")

# Do this same thing when tracing the execution of ANY CODE IN ANY LANGUAGE

Another illusion I used to believe was that there was some deep difference between Code and Data. In Lisp however the addition/removal of a single quote you can effortlessly treat a block as data or evaluate it as code. 

(print '(+ 1 2 3)) # prints out "(+ 1 2 3)"
(print (+ 1 2 3)) # prints out "6"

Really, Code and data are just a matter of perspective. Lisp macros remove any doubt of this by letting you easily write code that writes code. This is a dangerous super power that changes how you approach problems.

There is still much to explore in the land of lisp, but in many ways it has become a second home. I often wish this universe had won and lisp was the dominant language. Sadly most humans can only handle so many nested ((((((((((parens))))))))))

The Land of Lips looks much more different to Clandia than it really is. However the place I'm currently exploring, the Fjords of Forth, is a truly exotic place. I learned of it through hushed whispers and rumours.

The best way to understand Forth is to compare how it does addition.

  1. In Clandia the plus sign is a special case that expects numbers to the left and right of it 1 + 2
  2. in the Land of Lisp you treat addition like any other function and do + 1 2
  3. in Forth you must first stack 2 numbers on top of eachother, then the plus sign "picks up" those numbers, adds them, then drops the result back down 1 2 +

Everything, and I mean everything, in the Fjords of Forth builds on the concept of the Stack. There are no variables, only the stack. There are also no functions. Instead "words" just define a set of instructions which manipulate the stack. The concepts of "arguments" or "return values" are, you guessed it, just manipulations of the stack. 

\ this is how you define a word
: add-2 2 +

\ this will result in 5
3 add-2

One truth to pull from this is that your data model permeates every part of your system. (This is true with lisp as well with its choice of the s-expression & cons-cells, though it took forth for me to realize it.)

But that's basically all there is to Forth... the rules are simple. However simple and easy are not the same thing. Forth gives you a basic system that is incredibly hard to master, especially coming from Clandia. I understand the rules, but they're all backwards from how I was trained to think and keeping track of the stack is mentally taxing. Forth demands I think differently.

dont be fooled into thinking this is some joke language that is impossible to write "real" code in. Very smart people live in Forth and create complex programs in an amazingly concise amount of code.

In my short amount of time in this country I have learned that Forth masters are masters of naming. What you choose to name things in your code is incredibly important. When good names for forth words are chosen, one is able to build up good layers of abstraction very quickly. Good names are really all that's needed.

The Fjords of Forth are still new to me, so I have relatively little to talk about. Expect more as I learn more.

The world of programming languages is large and diverse. Learning languages that are similar to ones you already know is a trap. Instead choose languages that look weird to you. Look for places that make unique & odd choices. And more than anything else try and find languages that make you think differently, because that's how you really grow.

For me I think that means hanging out in Forth for a little longer. But who knows where I'll end up?