The Debian project has a whole page of their wiki dedicated to ways to avoid breaking a Debian installation. One of those points is “don’t suffer from Shiny New Stuff Syndrome”. For me, that’s something I seem to run into a lot, though not in the same way that Debian warns against. In my case, it’s usually about finding something new and wanting to try it out. It’s the reason I’ve played around with so many different Linux distros, BSDs, and other operating systems (in fact, my love of computing can be traced back to a time in which I wanted to run Mac OS X on a family HP TouchSmart). Nowadays, especially as I do more software engineering work, I find that this trait manifests itself as a desire to try out different programming languages.

In high school I learned to program in Java. When I started at university, I learned to use MATLAB, Python, and ArduinoC. Once I finally settled into my major of computer engineering, I worked almost exclusively with C++ and later pure C. At some point along the way I wanted to pick up a new programming language to add to my repertoire. My choice came down to two languages that seemed pretty popular on the internet: Go and Rust. Rust seemed to be more at the level of C/C++, and at the time I was taking systems courses and getting very into that kind of programming. Ultimately, though I settled on Go because I could get going with it much faster due to the lower barrier of entry.

Outside of my systems courses, I found myself mostly using Python for work. For open ended projects in my coursework (and later at my research job), I started to use Go more often.

So now I had two go-to languages for new projects: Go and Python. I still found myself drawn to trying Rust, and eventually I decided to try rewriting a Go project in Rust (see RepoMill). This was a very interesting project, though neither are complete and the Rust version still is behind in feature parity.

Most recently I’ve started working on a new project where I’ve probably spent more time trying to use different programming languages to implement the client program. For the server, the choice was pretty clear. I went with Go for familiarity, but more importantly for the existing Docker API. I decided to try and challenge myself with the client, though. I started with Rust, but then Zig caught my eye. Personally, Rust is my only exposure to functional programming. When working on the rewrite for RepoMill, I found that I was spending so much time trying to sort through the borrow checker’s issues that I wasn’t really enjoying the work as much. I did give Zig an honest try, but right now the ecosystem is in a bit of disarray. I understand this is just a byproduct of the language still being in development, so I’ll reserve judgement until things stabilise a bit (looking forward to when a proper package management solution exists and the community can release popular libraries and tools that don’t depend on always using the bleeding edge of the compiler).

So now I’m back to go Go. In just a couple days, I managed to get so much more done. I managed to not only set up the subcommands (something that I unsuccessfully tried to set up with the other two languages for weeks), but also got one of those subcommands implemented.

None of this is to say that it’s bad to try new things, particularly when programming. As I was working on this most recent project I found myself starting to get burnt out pretty quick. I didn’t feel like I was making much progress and I really wanted to get it finished so I could start using it as a interesting piece of my homelab. Since my goal was building a functional tool that I could start using soon, I should have stuck with tools I already knew how to use in order to be most productive.

Thanks for reading. I’d like to use this space as both a place to share interesting things I’ve learned as well as journal thoughts and experiences. It’s my corner of the Internet, so why not, right?