In the previous post, we discussed why Rust is worth learning and how to run your first Hello World. This post dives directly into syntax—variables, types, control flow, functions, and pattern matching. The core goal is simple: enable you to read and write Rust code. If you have a Go background, none of these concepts will be unfamiliar. I’ll provide comparisons at key points to help map your existing knowledge to Rust.
Continue reading →This article is based on Rust 1.82 (released on 2026-01-23, current latest stable version). Rust is a modern systems programming language proven in production. Official documentation is at doc.rust-lang.org, and installation guide is at rust-lang.org/tools/install/. Why Rust? If you’ve already mastered Go, you might ask: why learn Rust? Rust exists to fill the performance and control gap that Go leaves open. Go has conquered cloud-native and microservices domains with its extremely low learning curve, excellent concurrency model, and fast compilation speed. But its garbage collector (GC) and fixed runtime make it constrained in systems programming, embedded, and high-performance scenarios. When you need more precise memory control, lower latency, or work in embedded environments without OS kernel support, Go’s GC becomes a burden.
Continue reading →After three articles of our journey—why choose Go, basic syntax and concurrency, interfaces and generics—we’ve reached the finale of the Go chapter, time to connect the engineering practices. Go’s engineering capacity also shows up in its standard library, testing framework, and toolchain. They make up the daily working environment for Go developers and underpin rapid construction of reliable, maintainable software.
Continue reading →Concurrency is the core feature that distinguishes Go from other languages. Unlike C++/Java’s thread model, and unlike JavaScript’s single-threaded event loop, Go provides a set of concurrency primitives — goroutines, channels, and context — that let you write high-performance concurrent programs with relatively straightforward code. This article covers the technical details of Go’s concurrency model: the underlying scheduling mechanism, the implementation of channels and context, common concurrency patterns, and performance optimization and best practices.
Continue reading →Go’s error handling philosophy is “simple, explicit, controllable.” Every function that can fail can return an error value, and the caller must explicitly handle it. No exceptions, no implicit propagation—everything is in plain sight. The error Interface: One Value, One Method Go’s error interface is minimal: just one Error() string method. go 1 2 3 type error interface { Error() string } This means any type that implements Error() string is an error. The Go standard library provides many built-in error types, most commonly errors.New and fmt.Errorf.
Continue reading →In the previous articles, we covered Go’s basic syntax and concurrency model. Now let’s dive deep into the two core components of Go’s type system—interfaces and generics. These two constitute the foundation of Go’s abstraction mechanisms: interfaces provide runtime polymorphism based on behavior, while generics bring compile-time abstraction with type safety. Go’s design philosophy always emphasizes simplicity. Interfaces adopt implicit implementation, meaning no explicit declaration of implementation relationships is needed. As long as a type possesses the method set required by an interface, it automatically implements that interface. This duck typing style makes code more natural and reduces unnecessary coupling.
Continue reading →This article is based on Go 1.26. In the previous article, we discussed Go’s design philosophy and your first Hello World program. This time, let’s dive directly into syntax—variables, types, control flow, functions, composite types, and pointers. The core goal is simple: enable you to read and write basic Go code. Go’s syntax design philosophy is simplicity over complexity—eliminating unnecessary syntactic sugar while keeping things clear and intuitive. If you’re coming from another language, you’ll find Go’s learning curve relatively gentle because it has few syntactic features, but each one is practical.
Continue reading →Why Go? You might ask: why learn Go? There are so many programming languages—Python is simple and easy to learn, Java has a mature ecosystem, C/C++ delivers unmatched performance, and JavaScript is everywhere. What makes Go special? Go’s value lies in engineering practice: it aims language design squarely at team collaboration and large-scale software development, not at syntactic expressiveness or theoretical purity. Go was created in 2007 by a team of engineers at Google with one goal in mind: solve real-world pain points in software development. They wanted fast compilation, simple deployment, easy concurrency handling, and maintainable code. They weren’t looking for the “coolest” language—they wanted the most practical one, where developers can write code quickly, compile fast, run efficiently, and keep things simple and maintainable.
Continue reading →