Beginner on

Lesson 25: What's Next — Your roadmap from beginner to production Go

Sat, 11 May 2024 00:00:00 +0000

You made it. Twenty-five lessons ago you didn’t know what package main meant. Now you understand variables, types, functions, error handling, interfaces, goroutines, testing, JSON, file I/O, the type system, and the entire toolchain. That is not beginner knowledge anymore.

But there’s a gap between knowing the language and writing Go the way experienced Go developers write it. This lesson is about that gap — what it is, how to close it, and what to build while you do.

Lesson 24: The Go Toolchain — build, test, vet, fmt — your daily tools

Tue, 07 May 2024 00:00:00 +0000

One of the things that drew me to Go was that the toolchain ships with the language. You don’t need to choose a build tool, a formatter, or a test framework — they’re all there from day one, and they’re all invoked the same way: go <command>. This lesson is a tour of the tools you’ll use every single day.

The Basics

go run and go build

You’ve used go run throughout this course. It compiles your code and immediately executes it — perfect for development. Under the hood it creates a temporary binary and runs it, then throws the binary away.

Lesson 23: The Type System — Types, aliases, conversions, and embedding

Thu, 02 May 2024 00:00:00 +0000

When I first came to Go from Python, the type system felt like a lot of ceremony. Why can’t I just use an int where a float64 is expected? Why do I need to define a whole new type just to give an integer more meaning? The answers to those questions turned out to be one of the things I now appreciate most about Go. Types aren’t bureaucracy — they’re a way of making your code explain itself.

Lesson 22: File I/O — Reading and writing files the Go way

Fri, 26 Apr 2024 00:00:00 +0000

At some point every program needs to persist something — a config file, a log, a data export. File I/O is one of those topics that sounds tedious but is genuinely satisfying once it clicks. Go gives you a few different layers to work with, from the low-level os package to convenient one-liners. I’ll show you all of them so you can pick the right tool for the job.

The Basics

Reading a file the simple way

For most cases where the file is small enough to fit in memory, os.ReadFile is all you need:

Lesson 21: JSON and HTTP — Reading and writing the web's language

Sun, 21 Apr 2024 00:00:00 +0000

Almost every program I write these days talks to something over HTTP — a third-party API, a database service, a webhook. And almost everything speaks JSON. So learning how Go handles JSON and HTTP isn’t an advanced topic; it’s one of the most practical skills you can pick up early.

In this lesson I’ll walk you through converting Go structs to JSON and back, decoding JSON from an API response, and making real HTTP requests — all using only Go’s standard library. No third-party packages needed.

Lesson 25: Where to Go from Here — Your Rust learning path

Thu, 18 Apr 2024 18:00:00 +0000

You’ve made it through 24 lessons. You understand ownership, borrowing, structs, enums, traits, generics, error handling, closures, iterators, and file I/O. That’s not nothing — that’s the foundation of every Rust program ever written. But foundations are for building on. Here’s where to go from here.

What You Know Now

Take a second to appreciate what you’ve learned. You can:

Set up a Rust project with Cargo
Write functions with proper ownership and borrowing
Model data with structs and enums
Handle errors with Result and the ? operator
Use collections: Vec, HashMap, HashSet
Write generic code with trait bounds
Process data with iterators and closures
Test your code with #[test]
Read and write files

That’s a real skill set. You can build useful things right now. Before diving into advanced topics, I strongly recommend you build something. Nothing fancy — a command-line tool, a file processor, a simple data structure. The gap between “I understand the concepts” and “I can write a program” is only bridged by practice.

Lesson 20: Testing in Go — Every Go file gets a test file

Wed, 17 Apr 2024 00:00:00 +0000

I used to think testing was something you did after you finished writing code — a checkbox you ticked before committing. Go changed that attitude for me, not by lecturing me about best practices, but by making testing so straightforward that there was no excuse not to do it. The tooling is built in, the conventions are clear, and writing a test in Go takes about as long as writing the function itself. After a few weeks with Go, I started writing tests alongside my code, then slightly before it. The feedback loop became addictive.

Lesson 24: Reading and Writing Files — Real I/O in Rust

Tue, 16 Apr 2024 13:45:00 +0000

Every tutorial teaches you to manipulate data in memory, but real programs read from files and write to files. Rust’s file I/O is built on the same ownership and error handling principles you’ve been learning — and once you see how Result, iterators, and traits come together, the entire language design starts to feel cohesive.

Reading a File — The Quick Way

use std::fs;

fn main() {
 match fs::read_to_string("hello.txt") {
 Ok(content) => println!("File contents:\n{content}"),
 Err(e) => eprintln!("Error reading file: {e}"),
 }
}

fs::read_to_string reads the entire file into a String. It returns Result<String, io::Error> — because file operations can fail (file doesn’t exist, permission denied, disk error, etc.).

Lesson 23: Writing Your First Tests — #[test] and assert!

Sun, 14 Apr 2024 11:00:00 +0000

I have a rule: I won’t merge code without tests. Not because I’m a purist — because I’ve been burned too many times. Rust makes testing so frictionless that there’s no excuse to skip it. Tests live in the same file as your code. They run with one command. The tooling just works.

Your First Test

fn add(a: i32, b: i32) -> i32 {
 a + b
}

#[cfg(test)]
mod tests {
 use super::*;

 #[test]
 fn test_add() {
 assert_eq!(add(2, 3), 5);
 }

 #[test]
 fn test_add_negative() {
 assert_eq!(add(-1, 1), 0);
 }

 #[test]
 fn test_add_zero() {
 assert_eq!(add(0, 0), 0);
 }
}

Run with cargo test:

Lesson 22: Iterators — Lazy, composable data processing

Fri, 12 Apr 2024 09:30:00 +0000

I once profiled a Go service and found it was spending 40% of CPU time allocating intermediate slices in a data pipeline. Each transformation created a new slice, copied data, processed it, then created another. In Rust, iterator chains do the same transformation with zero intermediate allocations. The data flows through the pipeline element by element, transformed in place. That’s not just elegant — it’s measurably faster.

The Iterator Trait

At its core, an iterator is any type that implements the Iterator trait:

Lesson 19: Context — Passing deadlines and cancellation through your code

Fri, 12 Apr 2024 00:00:00 +0000

There’s a moment in every Go developer’s journey when they realize that starting an operation isn’t the hard part — stopping it cleanly is. What happens when a user cancels a request? What happens when a database query takes 30 seconds instead of 300 milliseconds? Without a way to communicate “stop what you’re doing,” those goroutines keep running, consuming resources for something that no longer matters.

That’s the problem context solves. It gives you a standard way to carry a cancellation signal, a deadline, and a small amount of request-scoped data through your entire call stack. Once you understand it, you’ll see why the Go standard library passes it as the first parameter to almost every function that does I/O.

Lesson 21: Closures — Functions that capture

Wed, 10 Apr 2024 12:15:00 +0000

Closures are where Rust stops feeling like a systems language and starts feeling like a functional one. You’ve already been using them — every time you passed |x| x * 2 to .map() or |a, b| a.cmp(b) to .sort_by(), that was a closure. Time to understand what’s actually happening under the hood.

What Is a Closure?

A closure is an anonymous function that can capture variables from its surrounding scope:

Lesson 20: Generics — Writing code that works for any type

Mon, 08 Apr 2024 20:00:00 +0000

I used to think generics were fancy academic stuff that you’d rarely need in practice. Then I wrote my third function that was identical to a previous one except it operated on f64 instead of i32. Generics aren’t luxury features — they’re how you stop writing the same function five times for five different types.

The Problem Generics Solve

Without generics, you write duplicate code:

fn largest_i32(list: &[i32]) -> &i32 {
 let mut largest = &list[0];
 for item in list {
 if item > largest {
 largest = item;
 }
 }
 largest
}

fn largest_f64(list: &[f64]) -> &f64 {
 let mut largest = &list[0];
 for item in list {
 if item > largest {
 largest = item;
 }
 }
 largest
}

fn main() {
 let ints = vec![34, 50, 25, 100, 65];
 let floats = vec![3.4, 5.0, 2.5, 10.0, 6.5];

 println!("Largest int: {}", largest_i32(&ints));
 println!("Largest float: {}", largest_f64(&floats));
}

These functions are identical except for the type. Generics let you write it once:

Lesson 19: Traits — Your first abstraction

Sun, 07 Apr 2024 15:45:00 +0000

Traits are the mechanism I miss most when I leave Rust. They’re interfaces without inheritance, type classes without the math, and the foundation of every abstraction in the language. If structs define what data is, traits define what data does.

What Is a Trait?

A trait defines a set of methods that a type can implement:

trait Greet {
 fn hello(&self) -> String;
}

struct Person {
 name: String,
}

struct Robot {
 id: u32,
}

impl Greet for Person {
 fn hello(&self) -> String {
 format!("Hi, I'm {}!", self.name)
 }
}

impl Greet for Robot {
 fn hello(&self) -> String {
 format!("UNIT-{} OPERATIONAL", self.id)
 }
}

fn main() {
 let person = Person { name: String::from("Alice") };
 let robot = Robot { id: 42 };

 println!("{}", person.hello());
 println!("{}", robot.hello());
}

The trait Greet declares that any implementing type must have a hello method. Person and Robot each provide their own implementation. Different types, same interface.

Lesson 18: The sync Package — Coordination tools for concurrent code

Sat, 06 Apr 2024 00:00:00 +0000

Goroutines make concurrency easy to start, but easy to start isn’t the same as easy to get right. The first time I ran multiple goroutines that touched shared data, I got a data race — a situation where two goroutines read and write the same variable at the same time, producing unpredictable results. The Go race detector caught it immediately, but I still had to understand how to fix it.

Lesson 18: Crates, Cargo.toml, and Dependencies — The Rust ecosystem

Fri, 05 Apr 2024 10:30:00 +0000

The first time I added a dependency in Rust, I was shocked. Add one line to Cargo.toml, run cargo build, and it downloads, compiles, and links everything automatically. Coming from C++ where dependency management is a special circle of hell, Cargo felt like cheating.

What Is a Crate?

A crate is a compilation unit in Rust — the smallest amount of code the compiler considers at a time. There are two kinds:

Lesson 17: Modules — Organizing your code

Wed, 03 Apr 2024 14:00:00 +0000

Rust’s module system confused me for longer than I’d like to admit. I came from Go, where packages map directly to directories. Rust’s module system is more flexible — and more confusing as a result. But once you understand the mental model, it’s actually quite elegant. The key insight: the file system doesn’t define the module tree. You do.

Modules in a Single File

The simplest case — modules defined inline:

Lesson 17: Go Modules — Managing dependencies without pain

Tue, 02 Apr 2024 00:00:00 +0000

Before Go modules existed, managing dependencies was genuinely painful. People used all sorts of third-party tools with their own conventions, and getting a new contributor up and running on a project could eat half a day. I started learning Go after modules became the standard, and I took for granted how smooth the experience was — until I read the old blog posts describing what came before. It made me appreciate go mod init in a way that’s hard to describe.

Lesson 16: Result and the ? Operator — Errors as values

Mon, 01 Apr 2024 08:45:00 +0000

Exception-based error handling has a fundamental flaw: you can’t tell by looking at a function signature whether it might throw. Go fixed this by returning (value, error) tuples, but then you’re back to forgetting to check the error. Rust’s Result type gets it right — errors are values, and the type system makes them impossible to ignore.

The Result Type

// Built into the language:
// enum Result<T, E> {
// Ok(T),
// Err(E),
// }

Result<T, E> is either Ok(T) (success with a value) or Err(E) (failure with an error). You’ve seen Option<T> — Result is similar but carries error information when something goes wrong.

Lesson 15: Vec, HashMap, and HashSet — The collections you'll use daily

Sat, 30 Mar 2024 11:15:00 +0000

In my experience, about 80% of all data structures in real programs are either lists or key-value maps. Rust nails both of them. Vec and HashMap are fast, safe, and ergonomic — and once you know these two plus HashSet, you can build almost anything.

Vec — The Dynamic Array

Vec<T> is Rust’s growable array. It stores elements contiguously on the heap, like ArrayList in Java or std::vector in C++.

Lesson 14: Methods and Associated Functions — impl blocks explained

Thu, 28 Mar 2024 17:30:00 +0000

In most object-oriented languages, data and behavior are bundled together inside classes. Rust separates them — you define data with struct (or enum) and attach behavior with impl blocks. This separation is cleaner than it sounds. You can add methods to a type from anywhere, not just its original definition. And there’s no inheritance tax.

Your First impl Block

#[derive(Debug)]
struct Rectangle {
 width: f64,
 height: f64,
}

impl Rectangle {
 fn area(&self) -> f64 {
 self.width * self.height
 }

 fn perimeter(&self) -> f64 {
 2.0 * (self.width + self.height)
 }

 fn is_square(&self) -> bool {
 (self.width - self.height).abs() < f64::EPSILON
 }
}

fn main() {
 let rect = Rectangle { width: 10.0, height: 5.0 };

 println!("Area: {}", rect.area());
 println!("Perimeter: {}", rect.perimeter());
 println!("Is square: {}", rect.is_square());
}

The impl Rectangle block defines methods for the Rectangle type. Inside the block, &self is a reference to the instance the method is called on. It’s equivalent to self: &Self, where Self is an alias for Rectangle.

Lesson 16: Packages and Imports — Organizing code like a professional

Wed, 27 Mar 2024 00:00:00 +0000

Every Go program I’ve written has taught me the same lesson over and over: good code isn’t just about what you write inside functions — it’s about how you organize those functions in the first place. When I started with Go, I crammed everything into one file. It worked, until it didn’t. By the time I had a few hundred lines, I couldn’t find anything. That’s when packages stopped being an abstract concept and became something I genuinely needed.

Lesson 13: Pattern Matching — The match superpower

Tue, 26 Mar 2024 09:45:00 +0000

Pattern matching ruined switch statements for me. After using match in Rust for a few months, going back to C-style switch/case feels like using a butter knife to do surgery. The compiler checks that you’ve covered every case. It destructures data inline. It does not fall through. It is, hands down, the most elegant control flow construct I’ve ever used.

Basic match

fn main() {
 let x = 3;

 match x {
 1 => println!("one"),
 2 => println!("two"),
 3 => println!("three"),
 _ => println!("something else"),
 }
}

_ is the catch-all pattern — it matches anything. Think of it as the default case in a switch statement, except it’s mandatory when the other arms don’t cover all possibilities.

Lesson 12: Enums and Option — Null safety by design

Mon, 25 Mar 2024 12:00:00 +0000

Tony Hoare called null his “billion-dollar mistake.” He invented it in 1965 and has publicly apologized for it multiple times since. Rust took him seriously. There is no null in Rust — and the replacement is so much better that going back to languages with null feels like giving up a superpower.

Basic Enums

At their simplest, enums define a type that can be one of several variants:

#[derive(Debug)]
enum Direction {
 North,
 South,
 East,
 West,
}

fn describe(dir: &Direction) -> &str {
 match dir {
 Direction::North => "heading north",
 Direction::South => "heading south",
 Direction::East => "heading east",
 Direction::West => "heading west",
 }
}

fn main() {
 let d = Direction::North;
 println!("{:?}: {}", d, describe(&d));
}

If this is all enums did, they’d be equivalent to C enums. Mildly useful. Not exciting.

Lesson 11: Structs — Modeling your domain

Sat, 23 Mar 2024 20:15:00 +0000

I worked on a Go codebase once where someone had passed around a map[string]interface{} for user data. It was fine until someone misspelled “email” as “emial” and we spent half a day tracking down why emails weren’t sending. Structs are how you prevent this entire category of mistake — named fields with typed data, checked at compile time.

Defining a Struct

struct User {
 name: String,
 email: String,
 age: u32,
 active: bool,
}

fn main() {
 let user = User {
 name: String::from("Alice"),
 email: String::from("alice@example.com"),
 age: 30,
 active: true,
 };

 println!("{} ({}) - age {}", user.name, user.email, user.age);
}

Struct names are PascalCase. Field names are snake_case. These aren’t suggestions — the compiler warns you if you deviate.

Lesson 10: Strings — String vs &str and why it matters

Fri, 22 Mar 2024 15:30:00 +0000

Strings are the #1 source of confusion for Rust beginners. I see the same questions every week: “Why are there two string types?” “Why can’t I index a string?” “Why is this so much harder than in Python?” It’s not harder — it’s more honest. Other languages hide the complexity of text. Rust makes you deal with it.

The Two String Types

Rust has two main string types:

String — owned, heap-allocated, growable, mutable
&str — borrowed, a slice/view into string data, immutable (usually)

fn main() {
 let owned: String = String::from("hello"); // heap-allocated, you own it
 let borrowed: &str = "hello"; // string literal, embedded in binary

 println!("{owned} {borrowed}");
}

The relationship between String and &str is exactly like Vec<u8> and &[u8]. A String is a buffer you own. A &str is a view into someone else’s string data (or a literal baked into your binary).

Lesson 15: Select — Waiting on multiple channels at once

Fri, 22 Mar 2024 00:00:00 +0000

By now you know how to create goroutines and how to communicate between them using channels. But what happens when a goroutine needs to listen to two channels at the same time? Maybe it’s waiting for work to arrive, but it also needs to stop if a timeout fires. With a single channel you’d be stuck — receiving from one blocks the other.

select solves this. It’s like a switch statement for channels. It waits until one of several channel operations is ready, then executes that case. If multiple are ready at the same time, it picks one at random.

Lesson 9: Slices — Views into data

Wed, 20 Mar 2024 10:45:00 +0000

Slices clicked for me when I stopped thinking of them as a language feature and started thinking of them as a design pattern: “here’s a window into someone else’s data.” They’re one of Rust’s most elegant ideas, and you’ll use them everywhere.

What Is a Slice?

A slice is a reference to a contiguous sequence of elements in a collection. It doesn’t own the data — it’s a view into data owned by something else.

Lesson 8: Borrowing and References — Sharing without giving

Mon, 18 Mar 2024 13:00:00 +0000

After the last lesson, you might be thinking “so every function I call takes my data and I never see it again?” That would be terrible. Borrowing is the answer — it lets you share data without transferring ownership, and it’s where Rust’s safety guarantees really shine.

References with &

A reference lets you refer to a value without owning it:

fn print_length(s: &String) {
 println!("Length of '{}': {}", s, s.len());
}

fn main() {
 let s = String::from("hello");
 print_length(&s); // lend s to the function
 println!("I still own: {s}"); // s is still valid
}

The & creates a reference. &s doesn’t move s — it creates a pointer to s that the function can use. When the function returns, the reference goes away but s remains untouched.

Lesson 14: Channels — How goroutines talk to each other

Mon, 18 Mar 2024 00:00:00 +0000

In the last lesson, I showed you how to run code concurrently with goroutines. But goroutines that can’t talk to each other aren’t very useful. What if one goroutine produces a result that another needs? What if you want to signal that work is done without using a WaitGroup? That’s where channels come in.

Go’s guiding philosophy on concurrency is: “don’t communicate by sharing memory; share memory by communicating.” Channels are the mechanism for that. Instead of multiple goroutines reading and writing the same variable, they pass values through a channel — and the channel ensures only one goroutine handles the value at a time.

Lesson 7: Ownership — The rule that changes everything

Sat, 16 Mar 2024 08:30:00 +0000

I spent three hours fighting the borrow checker on my first real Rust project. I was furious. Then I realized every single error the compiler flagged was a genuine bug — a use-after-free, a data race, a dangling reference. The compiler wasn’t being difficult. It was saving me from myself.

Why Ownership Exists

In C, you allocate memory and free it manually. Forget to free? Memory leak. Free twice? Undefined behavior. Use after free? Crash (if you’re lucky) or silent corruption (if you’re not).

Lesson 6: Control Flow — if, loop, while, for — and why there's no ternary

Thu, 14 Mar 2024 19:10:00 +0000

I once reviewed a pull request that had seven levels of nested if-else. In Go. The author said “the language doesn’t give me better tools.” In Rust, you’ve got match, labeled loops, if let, and blocks-as-expressions — enough to keep your code flat and readable even when the logic is complex.

if / else

fn main() {
 let temperature = 35;

 if temperature > 30 {
 println!("It's hot");
 } else if temperature > 20 {
 println!("It's nice");
 } else {
 println!("It's cold");
 }
}

Standard stuff. No parentheses around the condition — that’s a syntax error in Rust. The braces are mandatory, even for single-line bodies. No arguing about whether to use braces. They’re required. Discussion over.

Lesson 5: Functions, Expressions, and Statements — Everything is an expression

Wed, 13 Mar 2024 10:20:00 +0000

When I first read that “everything in Rust is an expression,” I thought it was marketing fluff. It’s not. It’s a genuine design principle that affects how you write code every single day, and once you internalize it, going back to statement-heavy languages feels clunky.

Defining Functions

fn add(a: i32, b: i32) -> i32 {
 a + b
}

fn main() {
 let result = add(3, 7);
 println!("3 + 7 = {result}");
}

A few things to notice:

Lesson 13: Goroutines — Lightweight threads that cost almost nothing

Tue, 12 Mar 2024 00:00:00 +0000

One of the first things people told me about Go was “it makes concurrency easy.” I was sceptical — concurrency is never easy. But the more I used goroutines, the more I understood what they meant. It’s not that concurrency becomes simple. It’s that the cost of starting a concurrent task drops so low that you stop avoiding it.

In most languages, spawning a thread involves megabytes of stack memory and significant overhead. A Go goroutine starts with about 2KB of stack. You can run tens of thousands of them on a normal laptop without breaking a sweat.

Lesson 4: Variables, Mutability, and Primitive Types — Let, let mut, and the type system

Mon, 11 Mar 2024 16:45:00 +0000

Coming from JavaScript, I was stunned the first time Rust refused to compile because I tried to reassign a variable. “What do you mean it’s immutable by default? Who designs a language like that?” Turns out — people who’ve debugged enough mutable state to know better.

Variables with let

fn main() {
 let x = 5;
 println!("x is {x}");
}

let creates a variable binding. It binds a name to a value. By default, that binding is immutable — you can’t change it.

Lesson 3: Hello, World — Anatomy of a Rust program

Sat, 09 Mar 2024 11:00:00 +0000

The first program I ever wrote was in BASIC on a Commodore 64 emulator. Took me twenty minutes to figure out why PRINT didn’t work (I was typing PIRNT). Rust’s version of Hello World looks simple — four lines — but there’s a surprising amount of language design packed into those four lines.

The Program

fn main() {
 println!("Hello, world!");
}

That’s it. Three lines if you’re counting. But each piece tells you something about how Rust thinks.

Lesson 2: Installing Rust — rustup, cargo, and your first build

Thu, 07 Mar 2024 14:30:00 +0000

I’ve installed Rust on maybe fifty machines at this point — Linux servers, Macs, Windows boxes, even a Raspberry Pi. The process has gotten remarkably smooth. Rustup is one of the best toolchain managers in any language ecosystem, and I say that without hesitation.

Installing rustup

Rustup is the official Rust toolchain installer and manager. It handles downloading the compiler, updating it, and switching between versions. One command gets you everything.

Lesson 12: Error Handling — Errors are values, not exceptions

Wed, 06 Mar 2024 00:00:00 +0000

The first time I wrote Go after years of Python and JavaScript, I kept waiting for the try/catch block. It never came. Instead, almost every function returned two values: the result, and an error. I had to check the error every single time. It felt tedious at first. After a few weeks, I realised it was one of the best design decisions in the language.

In Go, errors are just values. They’re not special. They don’t teleport up the call stack. They sit right there, in your return value, waiting for you to deal with them.

Lesson 1: Why Rust Exists — And why you should care

Tue, 05 Mar 2024 09:15:00 +0000

I mass-deleted a production database once because a C program I’d written had a use-after-free bug that corrupted a pointer used for query routing. Took us fourteen hours to recover. That was the week I started learning Rust.

The Problem Rust Solves

Every few years, someone publishes a study on CVEs in major software projects. The numbers are always the same: roughly 70% of critical security vulnerabilities in C and C++ codebases are memory safety issues. Buffer overflows, use-after-free, double-free, null pointer dereferences. The same bugs, decade after decade.

Lesson 11: Interfaces — Contracts without the paperwork

Sat, 24 Feb 2024 00:00:00 +0000

When I first learned about interfaces in Go, I expected something complicated — annotations, implements keywords, class hierarchies. Instead, Go just asked: “does your type have the right methods?” That’s it. No paperwork. No explicit declaration. If your type does what the interface requires, it satisfies the interface automatically.

This sounds small, but it changes how you design programs entirely.

The Basics

An interface in Go is a named set of method signatures. Any type that implements those methods automatically satisfies the interface. You don’t declare that you’re satisfying it. Go figures it out at compile time.

Lesson 10: Pointers — Addresses, not magic

Sat, 17 Feb 2024 00:00:00 +0000

Pointers have a reputation for being scary. In C, they’re the source of buffer overflows, dangling references, and cryptic crashes. In Go, pointers are much tamer. There’s no pointer arithmetic, the garbage collector handles memory for you, and the rules are simpler. But pointers are still important — without them, you can’t write Go programs that mutate data through function calls, and you can’t use pointer receivers (which we covered in the last lesson).

Lesson 9: Methods — Functions that belong to a type

Sun, 11 Feb 2024 00:00:00 +0000

In the last lesson we defined a User struct. We could pass it to functions — birthday(u), sendEmail(u), formatName(u). That works, but there’s a better way: we can attach functions directly to the User type. Then instead of birthday(u) we write u.Birthday(). Those are called methods.

Methods make code more readable, more organized, and closer to how we naturally think about objects — “a user does birthday-related things” rather than “a birthday function takes a user.”

Lesson 8: Structs — Your first custom type

Wed, 07 Feb 2024 00:00:00 +0000

So far we’ve been working with Go’s built-in types: strings, ints, booleans, slices, maps. Those are great, but real programs deal with real-world things — users, orders, products, messages. You need a way to group related data together and give it a meaningful name. In Go, that’s a struct.

If you come from Python, think of a struct as a lightweight class that holds data (but with no inheritance, and methods are defined separately). If you come from JavaScript, think of it as a typed object. If you come from C, structs work almost exactly the same way.

Lesson 7: Strings, Runes, and Bytes — Strings aren't what you think

Fri, 02 Feb 2024 00:00:00 +0000

Strings look simple. You write "hello", you print it, done. But when I first started working with non-ASCII text in Go — names with accents, emoji, Chinese characters — things started behaving oddly. len("café") returned 5, not 4. Iterating with a regular index loop gave me garbled output. It took me a while to understand why, and once I did, a lot of things clicked.

The short version: Go strings are sequences of bytes, not characters. Once you internalize that, the rest makes sense.

Lesson 6: Maps — Key-value pairs that power everything

Sat, 27 Jan 2024 00:00:00 +0000

Every language has some version of the dictionary or hash map. Python calls it a dict, JavaScript calls it an Object or Map, Ruby calls it a Hash. In Go, it’s just called a map. Once you understand how Go maps work, you’ll reach for them constantly — they’re one of the most useful data structures in the language.

The Basics

Creating a map

The zero value of a map is nil. A nil map is readable (it returns zero values) but not writable. If you try to write to a nil map, your program panics. The safe way to create a map is with make:

Lesson 5: Arrays and Slices — Slices are what you actually use

Mon, 22 Jan 2024 00:00:00 +0000

Go has two sequence types: arrays and slices. I’ll tell you upfront — arrays are rarely used directly. They exist, they matter for understanding how things work under the hood, but in day-to-day Go programming you’ll almost always reach for a slice instead.

Slices are Go’s workhorse collection type. They’re flexible, they grow when you need them to, and they’re used everywhere: in standard library APIs, in function parameters, in HTTP handlers. Understanding slices well will make you a much more effective Go programmer than memorizing syntax ever will.

Lesson 4: Functions — Small functions are Go's building blocks

Wed, 17 Jan 2024 00:00:00 +0000

If there’s one thing experienced Go programmers agree on, it’s this: write small functions. Not tiny, cryptic one-liners, but focused functions that do one thing and are easy to test. Go’s function syntax encourages this style — it’s clean, explicit, and has one feature that’s genuinely different from most languages you’ve used before: multiple return values.

In Python you can return a tuple. In JavaScript you can return an array. But in Go, returning two or three values is a first-class language feature with its own syntax, and it fundamentally changes how error handling works. By the end of this lesson you’ll understand Go functions well enough to start writing real, useful programs.

Lesson 3: Control Flow — if, for, and switch are all you need

Fri, 12 Jan 2024 00:00:00 +0000

Every program you’ll ever write needs to make decisions and repeat actions. “If this condition is true, do that. Otherwise, do something else.” “Keep doing this until we run out of items.” These are the fundamental building blocks of logic, and Go handles them with just three constructs: if, for, and switch.

That’s it. No while. No do-while. No foreach as a separate keyword. Go’s designers made a deliberate choice to keep the language small — fewer constructs means fewer ways to do the same thing, which means code is more consistent and easier to read across different projects and teams.

Lesson 2: Variables and Types — Go is typed, and that's a good thing

Mon, 08 Jan 2024 00:00:00 +0000

If you’re coming from Python or JavaScript, Go’s type system might feel like extra work at first. Why should you have to tell the compiler that a variable holds a number? Can’t it just figure it out?

Here’s the thing — it usually can. Go has type inference, so you rarely have to write out types explicitly. But when types are written out, every person reading your code knows exactly what kind of data they’re dealing with. There’s no guessing, no surprises at runtime because a string snuck in where you expected a number. Go catches those mistakes at compile time, before your code ever runs.

Lesson 1: Your First Go Program — Hello World is just the beginning

Wed, 03 Jan 2024 00:00:00 +0000

I remember the first time I ran a Go program. The compiler yelled at me for an unused import, and I thought, “Okay, this language has opinions.” That’s not a bad thing. Go’s strictness is part of what makes it so readable and maintainable. Once you understand why Go works the way it does, it starts to feel less like friction and more like clarity.

In this lesson you’re going to write your first Go program, understand every single line of it, and learn the basic tools you’ll use every day. By the end, “Hello, World!” won’t feel like a throwaway demo — it’ll feel like a foundation.