As I explained in previous articles, we are working on building LiveAPI, a super-convenient auto-API doc generation tool. LiveAPI's backend is in Golang, and I'm discovering the unique and cool features of Golang.
For those who don't know, Golang (Go) is a programming language designed at Google in 2009. It is syntactically similar to C.
Before working on Golang projects, I primarily used Node.js and Python web frameworks. For a beginner switching to Golang from another domain, it can be a little difficult initially, but once you practice and gain expertise, you won't leave.
My first Golang project was to convert a Python CLI tool, Glee, to Golang.
We found Python to be slower and maintaining a single compiled CLI binary to be very difficult, the binary sometimes not compatible with Mac OS. These and other issues forced us to switch to Golang. Here is a Reddit post on the story and the issues behind the switch.
In this article, I will explain the unique features in Golang that attracted me to it.
1. Goroutines - Lightweight Concurrency
func main() {
go sayHello("World") // runs concurrently
time.Sleep(1 * time.Second)
}
func sayHello(name string) {
fmt.Printf("Hello, %s!\n", name)
}
Think of goroutines like tiny workers that can do tasks independently. They're much lighter than traditional threads - you can create thousands of them without a performance hit.
2. Channels - Built-in Communication
func main() {
messages := make(chan string)
go func() { messages <- "ping" }()
msg := <-messages
fmt.Println(msg)
}
Channels are like pipes that let goroutines communicate safely. Imagine two people passing notes through a tube - one writes and puts it in, the other takes it out.
3. Defer - Cleanup Made Simple
func readFile() {
file, err := os.Open("test.txt")
defer file.Close() // Will run when function exits
}
Defer is like setting a reminder for cleanup tasks. It's similar to writing a post-it note saying "don't forget to close the file" right when you open it.
4. Interface Implementation - Implicit Contracts
type Writer interface {
Write([]byte) (int, error)
}
type ConsoleWriter struct{}
func (cw ConsoleWriter) Write(data []byte) (int, error) {
return fmt.Println(string(data))
}
Go's interfaces are satisfied implicitly - if a type has the right methods, it automatically implements the interface. It's like joining a club: you don't need to formally declare membership; if you can do what the club requires, you're automatically in.
5. Multiple Return Values - Native Error Handling
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("cannot divide by zero")
}
return a / b, nil
}
func main() {
result, err := divide(10, 0)
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Println("Result:", result)
}
Multiple return values make error handling natural and explicit in Go. It's like getting both a package and a receipt when shopping - you can check if everything is okay before proceeding. This pattern encourages developers to handle errors properly.
These are just a few features I like in Go. There are also others, like single executable binaries, faster performance, type inference, built-in testing support, and cross-compilation.
If you're making resolutions for 2025, add Golang to your list. You won't regret it. Thanks for reading! If you want to learn Golang by contributing to an open-source project, check out glee and Lama2.
Top comments (9)
Overall, what makes go special is simplicity. Go programs are easy to write and easy to read. This often makes them easy to debug, too.
Exactly.
I built my first Go web server this year.
It was my best descision this year to learn Go!!
Im going to learn go in 2025
Great decision. While learning, build a mini tool or product.
I think Rust is much more easer. By your points:
Also no "Million dollar mistake" in Rust.
Go replaced PHP for me as the #1 language in 2024, but it really looks like I can't use it much in 2025 and I'm just sad
Finally moving into Go full time in 2025
I am really excited to try it out this year. Thank you for sharing.