R

R was my first programming language, but honestly it’s better thought of as statistical software than a real language. If you are using it for anything that’s not statistics, you should probably choose something like Python. That said, R is really good for statistics. The best feature is the |> pipe operator, which allows you to manipulate data in a really natural way without dealing with a lot of nested functions. R also comes with a lot of statistical tools you need without needing to install further packages. The ggplot2 package is hands down the best way to make graphs. Being able to pipe data and easily extend graphs makes it much better than any other way.

Python

The biggest strength of Python is its huge community and the packages that you can easily import and use, along with its extremely simple syntax. Specifically, the scientific python packages like numpy, sympy, and matplotlib are extremely powerful for working with large datasets and fast computations. Python’s syntax is so simple it allows you to make a working program very quickly, although this comes at the cost of computation speed.

Rust

I’m still very new to Rust, but it showed me how fast computers really could be. I never understood why people complain about Python being slow, but after seeing how fast compiled languages like Rust are, I see why. It can do massive calculations so quick I couldn’t believe it coming from R and Python. Rust’s biggest quirk is its memory management rules, specifically the borrow checker. Basically, only one variable can change each object in memory at a time, and the Rust compiler checks these rules before your program can even run. This can make writing a program much harder, but with the benefit that when it finally compiles, you can be pretty sure it won’t crash due to memory issues. I like writing Rust programs, and then comparing my solution to other people’s to see what further optimizations I can make. In my experience, Rust has a “correct from the start” approach where it forces you to be explicit at every step. For example, to find the length of a string in Rust, you have to specify whether you want the length in bytes, characters, or grapheme clusters. Other languages manage this for you behind the scenes. While this can be annoying to learn at first, and can slow down the writing process when compared to something like Python, I do like this philosophy and approach.

Haskell

Haskell is maybe one of the quirkiest programming languages I know of. It has no “if” statements, for/while loops, and applies functions with spaces instead of parentheses. Everything is lazy by default, meaning that it only computes things at the last moment when it really needs to. Furthermore, everything in Haskell is a “pure” function, meaning that the same input will always give the same output. This makes generating random numbers very different from other languages. Haskell encourages recursive functions, which is contrary to most languages where recursive solutions are generally avoided when possible. I find that Haskell encourages my natural way of thinking and problem solving the most. The feature that sold me on learning Haskell the most, and what is still my favorite feature of any programming language, is the list comprehensions. In math, you can define sets like $\{x\in \mathbb{N}:x^{2}<100\}$ with set-builder notation. Haskell follows this notation exactly, allowing you to write

[x | x <- [1..], x^2 < 100]

to easily generate the same set. This can be extended in so many ways, but I find it so amazing that it supports it.

Conclusion

I am by no means an expert computer programmer, but I love seeing how these different languages were developed to solve different problems, and how the same problem can be solved in different ways. My favorite language right now is Haskell because of the highly mathematical nature of it. It has so many features that support the problem solving process I learned through mathematics.