Go Programming – Golang Course with Bonus Projects

This Go programming course for beginners, led by Lane Wagner and Alan Lers with over 18 years of combined coding experience, aims to teach key concepts and techniques for writing performant, idiomatic Go code. The curriculum covers fundamental topics like variables, functions, and loops, and includes seven real-world projects, such as building an RSS aggregator and implementing authentication with API keys.

Go's growing popularity is attributed to its speed, lightweight nature, excellent developer experience, and ease of learning, making it a potential game-changer for coding careers. The course emphasizes hands-on learning with over 100 coding lessons and exercises, culminating in building a production-ready back-end server from scratch. Students are encouraged to code along and use provided solutions only when stuck, with code samples hosted on boot.dev and a linked GitHub repository. The course is part of a larger back-end developer career path on boot.dev, and help is available through Discord servers and forums.

Key Features and Benefits of Go:

• Execution Speed: Go is significantly faster than interpreted languages like JavaScript, Python, Ruby, and PHP due to its compiled nature. While its execution speed is comparable to languages like Java and C#, it uses less memory than them.
• Compilation Speed: Go boasts faster compilation times than other compiled languages like C and Rust, leading to increased developer productivity and quicker iteration cycles.
• Static and Strong Typing: Go's static typing system, similar to TypeScript, catches errors at compile time rather than runtime, preventing issues like accidentally changing a string to an integer.
• Memory Management: Go is garbage-collected but does not rely on a Java Virtual Machine (JVM). It includes a runtime within each compiled binary to manage memory, resulting in lower memory overhead compared to Java or C#.
• Compiled Language Distribution: Compiled Go programs produce a single executable binary, making distribution easier as users do not need to install the Go toolchain or have access to the source code.
• Error Handling: Go's error handling is unique, treating errors as values. Functions typically return both the result and an error, forcing developers to explicitly handle potential errors, which is seen as a strength over JavaScript's try-catch paradigm.
• Structs and Methods: Go supports structs for defining data structures and methods, which are functions associated with types, providing a way to encapsulate behavior.
• Interfaces: Interfaces in Go define a set of method signatures. Any type that implements these methods implicitly satisfies the interface, promoting polymorphism and decoupling.
• Concurrency: Go has built-in support for concurrency through goroutines (lightweight threads) and channels (thread-safe queues for communication between goroutines).
• Slices: Slices are dynamically sized views into arrays, offering flexibility over Go's fixed-size arrays. They are passed by reference, meaning modifications within a function are visible to the caller.
• Maps: Maps provide key-value storage, offering efficient lookups. Keys must be comparable types, excluding slices, maps, and functions.
• Defer Statement: The defer keyword allows functions to be executed just before the current function exits, useful for cleanup tasks like closing files.
• Closures: Closures are functions that reference variables from their enclosing scope, allowing them to maintain state.
• Pointers: Pointers store memory addresses, enabling functions to modify values outside their scope and potentially optimize performance by avoiding data copying.
• Packages and Modules: Go code is organized into packages, with main packages creating executable programs and other packages serving as libraries. Modules are collections of packages managed by a go.mod file, which specifies dependencies and the module's path.
• Local Development: The course guides users through setting up a local development environment using VS Code, a Unix-like terminal, and the Go toolchain, covering commands like go build, go install, go mod init, go mod tidy, go mod vendor, and go get.
• SQL Integration: The project involves integrating with a PostgreSQL database using the sqlc tool for generating type-safe Go code from SQL queries and goose for database migrations.
• API Development: The course covers building a JSON REST API using the Chi router, implementing handlers for CRUD operations, authentication with API keys, and using middleware for common logic like authentication.
• Generics: Introduced in Go 1.18, generics (type parameters) allow for writing reusable, type-safe code that can operate on different types without sacrificing compile-time safety, reducing repetitive code.

Project: RSS Aggregator

The course culminates in building an RSS aggregator. Key features include:

• Database Schema: Creating tables for users, feeds, and feed follows using SQL migrations.
• API Endpoints: Implementing handlers for creating users, getting users by API key, creating feeds, getting all feeds, following/unfollowing feeds, and fetching posts for a user.
• Authentication: Using API keys passed in HTTP headers for user authentication.
• Background Scraping: Implementing a background service using goroutines and tickers to periodically fetch RSS feed content, parse it, and store it in the database.
• Concurrency: Utilizing goroutines, channels, wait groups, and mutexes (both sync.Mutex and sync.RWMutex) for safe and efficient concurrent operations.
• Error Handling: Implementing custom error types and using the errors package for robust error management.
• Data Models: Creating Go structs to represent database records and API responses, with JSON tags for serialization.

Key Concepts:

• Variables, Functions, Loops, Conditionals
• Compiled vs. Interpreted Languages
• Compilation and Execution Speed
• Static and Strong Typing
• Memory Management (Garbage Collection, Runtime)
• Error Handling (Error Interface, errors.New)
• Structs, Methods, Interfaces
• Concurrency (Goroutines, Channels, Select, Mutexes, RWMutexes)
• Slices, Arrays, Maps
• Pointers
• Packages and Modules (go.mod, go build, go install, go get)
• SQL Databases (PostgreSQL, Migrations with Goose, Queries with sqlc)
• REST APIs (HTTP Handlers, Chi Router, JSON, API Keys, Middleware)
• Generics (Type Parameters, Constraints)
• Defer Statement, Closures, Anonymous Functions
• Go Proverbs (Channels orchestrate, Mutexes serialize; Clear is better than clever)