My GO LANG Journey

I’m Back, Powered by Go (and a Typhoon)

Hey fellow devs! I’m back with a fresh post after a quick break last week—thanks to a surprisingly fierce typhoon that knocked the power out of my office (and the internet out of most of the city). It was a perfect reminder that even the most meticulously plotted sprint plans can be derailed by Mother Nature. Luckily, my server survived the storm, and all my online apps and services are still humming along.

Before I get carried away with storm‑related rambling, let’s dive into the real topic.

One Year in Go‑land

It’s been almost a year since I switched my primary backend language to Go (or “Golang,” if you want to go pun‑full). My latest engagement demanded it, but I’ve been blown away by how much smoother backend dev feels compared to Node‑JS/TS. I wish I’d discovered this language earlier—it feels like finding a secret shortcut in a maze.

Why Go? The Back‑to‑Basics Story

Back when I was building decentralized apps for the blockchain, the smart contracts did most of the heavy lifting. I didn’t need to code much of a backend. But as demand grew and the landscape shifted, I started writing additional backend services in TypeScript—because I already knew TS from building React sites. It was fun at first, but the codebase started ballooning faster than my coffee mug.

Every day, TypeScript felt harder to maintain. I tried Python, but it didn’t fit the vibe. So I kept wrestling with TS just to ship projects—at the expense of my sanity, ha! That’s when I stumbled upon Go.

Meet Go (the Simple, Fast, and Reliable Hero)

Go (yes, I keep calling it “Go Lang” because it’s a pun‑tastic name) is a statically‑typed, compiled language from Google, created in 2009. I love it for its minimalism, blazing speed, built‑in concurrency, and a culture that encourages idiomatic code. And by “idiomatic” I don’t mean “for dummies”—I mean following Go’s core design principles: keep syntax lean, package your code logically, handle errors with explicit returns, and use goroutines and channels for lightweight concurrency. When you do this, your code is easy for other Go devs (and future‑you) to read, maintain, and extend.

The Wakatime Numbers (and the Go‑to‑the‑Top Moment)

At the time of writing, Go is the second‑most used language in my Wakatime stats, with 252 hours logged versus 254 hours for TypeScript. I expect to surpass that in a few days, making Go my top language. Once that happens, I’ll keep TS for the client side (because we all love a slick UI) and focus Go on backend stuff.

If you’re tired of the daily grind of maintaining sprawling TS backends, Go feels like the first day again—fresh, clean, and full of possibilities. I’m so confident in Go’s backend chops that I’m telling every dev still hunting for a stack to give it a shot.

What’s Next? Self‑Hosted Go Playground

My plan is to keep building personal projects in Go and deploy them on my own self‑hosted platform—aldrickb.app. Free hosting services keep cutting features, and with AWS and Cloudflare’s occasional downtimes, having my own stack feels like building a bunker: I’m basically immune to outages 😉.

I’ll be blogging about aldrickb.app and showing how you can self‑host your own projects. It’s a win‑win: I sharpen my full‑stack chops and get hands‑on DevOps experience—plus, I get to brag about the “in‑house” server that never goes down.

Hello World, Go‑style

Here’s a quick, idiomatic “Hello World” in Go (and it’s still shorter than a Python script!):

// hello.go – a tiny, idiomatic Go program
package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("Welcome to my Go journey!")
    time.Sleep(1 * time.Second) // simulate a small delay
    fmt.Println("Let’s keep learning together.")
}

What makes this tiny snippet a showcase of Go’s power?

FEATURE	WHY IT MATTERS
Tiny language surface	Go has just 20–30 core keywords; no heavy syntactic sugar, so the learning curve is flat and the code stays readable.
Fast compilation	A few seconds to compile the whole project. Combine that with Air and you get hot‑reload as if you were working on a React SPA.
Built‑in concurrency	Goroutines are cheaper than threads (just a few kilobytes of stack) and channels make passing data simple. No need for external libraries.
Garbage collection	You can focus on business logic; Go’s GC keeps memory clean without manual intervention.
Cross‑platform binaries	One `go build` gives you a native executable for Windows, Linux, or macOS—deploy wherever you like, no Docker needed if you prefer.
Rich standard library	From `net/http` to `crypto/ed25519`, Go ships a full toolbox. Need more? The ecosystem is huge and battle‑tested.

It may not be as terse as Python or TS, but it’s a tiny footprint, lightning‑fast compilation, and built‑in concurrency. Add garbage collection, cross‑platform binaries, and a rich standard library, and you’ve got a powerhouse for any backend you can dream up. Need AI? Go has libraries for that too (don’t worry, the “basic” AI stuff is still a win).

Getting Started with Go

If you’re ready to hop on the Go train, the official site, go.dev, has everything you need: quick‑start guides, docs, tutorials, books, training, and more. I got up and running on day one—especially if you’re a polyglot like me. The learning curve is shallow, and the payoff is huge.

Wrap‑Up

Time’s ticking, so I’ll leave you with this: If you want to read more posts like this or tutorials on my platform, just drop me a line. I’ll send you updates—promise no spam, just pure dev goodness. Whether you’re a subscriber or not, you’re part of this journey, and I’ve got more posts and projects coming your way.

Thanks for reading, fellow devs. Let’s keep building, keep learning, and keep the puns flowing!