Going all in on GoLang

I’ve been a jack of all trades and a master of none when it comes to code.

Over the years, I have written Java and robotc, coached people in basic Python, troubleshot Javascript and all sorts of websites. Despite that, I feel that I have never dove deep enough to really establish fluency in (or perhaps what I am looking for mastery of) a language. Even using Java for ACM challenges, i never felt i sunk my teeth in enough to really grok the end to end process of Writing A Program, although many of the style conventions are stuck in my head to this day. I want to start really understanding the depth of a single language.

A language that works everywhere I need to work.

Golang was a natural choice for me to focus on for a deeper dive. Already familiar with the existence of TUI tools like BubbleTea, mux for networking and the power of goroutines, and SSG with the help of Hugo or HUGE, it rang all the bells I needed it to when it came to projects I was looking to build.

The people always matter.

What got me to look at Golang to start with was the people. Those I saw using it were people who worked like I want to work: focused on functional, efficient, iterative. Rob Pike’s posts on the Go blog, especially “Strings, bytes, runes and characters in Go”, exemplify what I mean. Created with an eye to understanding that is built on small enlightenments.

Almost everything is asked and answered.

Go being the recent brainchild of Ken Thompson and co alone is a great reason to engage with it. Not because they are infallible, but because go is a response to over 30 years of language design experience. As a result, both the language itself and the discourse surrounding it are a constant education in software design. Learning the language in the 2020s is a great time to explore and understand hot topics as they bubble up in the community, with the context of old vs new always bubbling up thanks to the newness of go. It creates an environment where it is impossible to avoid gaining insight on design problems, (why are iterators and generics in Go so often considered a mistake? How does garbage collection really affect the performance and programmer experience?)

All of that, without getting into the robust typing, error handling, a strong standard library, or its ability to be compared effectively to predecessors for similar uses.

Project paradigms.

As Go is adopted and projects move forward, some beautiful learning opportunities have presented themselves. One of the most obvious has been in Hugo. As Hugo has iterated upon itself, I have found adapting to differences of theme installation, from manually installed or git submodules to Hugo modules, and transitioning between to be a wonderful learning opportunity. Working between the three has been a great way to get comfortable with all three paradigms, and familiarize myself with managing them all from the command line.

Getting to work.

Slowly but surely, I am working through Go by Example, typing each out and ensuring I understand the principles. I’ve found typing them out best, not only for cementing them in my memory, but also in catching stray Java-style habits and capitalizations that are sure to be a thorn in the side of later projects.

My current most-worked-on project is sb. Built with BubbleTea, it is on its way to becoming a MVP for making notes in a CLI tool. If it progresses past that point, I want to add support for recfiles and TaskWarrior integration. One of my next planned projects is a fork of an older hugo theme, to align it with different content organization best practices and get some extra practice with modules. If I continue on the web side of things, I’d love to jump into Hokus CMS or other young projects in the space.

After those, there are many options to choose from- but I am happy with where I am starting.