108 Days of Golang: Overview
The 108 Days of Golang series is a comprehensive journey designed to help developers master the Go programming language, step by step. Whether you're a beginner looking to get started with Go or an experienced developer seeking to deepen your understanding of the language, this series covers everything you need to become proficient in Go. The series is broken into sections, each focusing on essential Go concepts, practical projects, and advanced features of the language.
Days 1–10: Go Fundamentals
The first 10 days focus on setting up the Go environment, understanding Go's basic syntax, and mastering key foundational concepts like variables, constants, control flow, and error handling.
- Day 1: Setting Up Your Go Development Environment on Windows, macOS, and Linux
- Day 2: Mastering Variables and Constants in Go
- Day 3: Control Flow in Go: If and Switch Statements
- Day 4: Looping with For in Go, Comprehensive Guide to Loops in Go: For Loops
- Day 5: Functions and Robust Error Handling in Go
- Day 6: Exploring Data Types in Go: Numbers, Strings, and Booleans
- Day 7: Understanding Arrays and Slices in Go
- Day 8: Mastering Maps in Go: Key-Value Collections
- Day 9: Go Functions with Multiple Return Values: A Practical Guide
- Day 10: Best Practices for Error Handling in Go
Days 11–20: Advanced Data Structures and Algorithms
Building on the foundations, we dive deeper into Go's data structures, algorithms, and more complex control structures to tackle real-world problems.
- Day 11: Exploring Structs: Building Custom Data Types
- Day 12: Pointers in Go: Understanding Memory and References
- Day 13: Interfaces and Polymorphism in Go
- Day 14: Introduction to Go's Built-in Collections: Linked Lists, Stacks, and Queues
- Day 15: Sorting and Searching Algorithms in Go
- Day 16: Go Packages: Organizing Code and Building Modular Projects
- Day 17: Error Types and Custom Error Handling Strategies
- Day 18: JSON and XML Parsing in Go
- Day 19: File Handling and I/O Operations in Go
- Day 20: Recursion and Backtracking in Go
Days 21–30: Concurrency and Parallelism in Go
Concurrency is one of Go’s strongest features. These days focus on learning Go’s goroutines and channels to build concurrent and parallel programs.
- Day 21: Introduction to Goroutines: Lightweight Concurrency in Go
- Day 22: Channels in Go: Communication Between Goroutines
- Day 23: Buffered vs. Unbuffered Channels
- Day 24: Go Select Statements for Multiplexing
- Day 25: Sync Package: Handling Race Conditions and Synchronization
- Day 26: Mutex and RWMutex: Locking and Synchronization
- Day 27: Worker Pools: Managing Goroutines Effectively
- Day 28: Error Handling in Concurrent Go Programs
- Day 29: Building a Concurrent Web Scraper in Go
- Day 30: Concurrency Patterns and Best Practices
Days 31–40: Testing, Debugging, and Profiling
Testing and optimization are critical in Go. This section focuses on writing tests, debugging, and optimizing performance.
- Day 31: Writing Unit Tests in Go
- Day 32: Testing Strategies: Table-Driven Tests and Benchmarking
- Day 33: Mocking and Dependency Injection in Go
- Day 34: Profiling Go Code with pprof
- Day 35: Optimizing Go Code for Performance
- Day 36: Using the Go Race Detector to Identify Race Conditions
- Day 37: Handling Panics and Recover in Go
- Day 38: Logging and Monitoring with Go's Log Package
- Day 39: Writing Integration Tests for REST APIs
- Day 40: Debugging Techniques: Common Issues in Go Projects
Days 41–50: Networking and Web Development
Go is widely used in building scalable web servers and APIs. This section dives into Go's capabilities for web and network development.
- Day 41: Introduction to Go's net/http Package
- Day 42: Building REST APIs with Go
- Day 43: Handling HTTP Requests and Responses in Go
- Day 44: WebSockets: Building Real-Time Applications in Go
- Day 45: Authentication and Authorization in Go Web Applications
- Day 46: Serving Static Files and Templates
- Day 47: Building Middleware in Go
- Day 48: Rate Limiting and Throttling in Go Web Applications
- Day 49: Error Handling and Logging in Web Applications
- Day 50: Deploying Go Web Applications to Cloud Platforms
Days 51–60: Databases and Persistence
Learn how to interact with databases, use ORMs, and persist data using Go.
- Day 51: Introduction to SQL Databases in Go (PostgreSQL, MySQL)
- Day 52: Database Queries with the sql Package
- Day 53: Go ORMs: Using GORM for Database Operations
- Day 54: Handling Transactions in Go
- Day 55: NoSQL Databases in Go: Working with MongoDB
- Day 56: Redis in Go: Caching and Key-Value Store Operations
- Day 57: Managing Database Migrations in Go
- Day 58: Best Practices for Database Connection Pooling
- Day 59: Data Validation and Error Handling in Database Queries
- Day 60: Building a Simple CRUD Application in Go
Days 61–70: Advanced Topics in Go
This section covers more advanced topics such as Go’s runtime, memory management, and Go's unique design patterns.
- Day 61: Go's Runtime and Garbage Collection
- Day 62: Memory Management and Escape Analysis in Go
- Day 63: Reflection in Go: Inspecting and Modifying Programs at Runtime
- Day 64: Go Modules: Managing Dependencies
- Day 65: Understanding Contexts for Managing Timeouts and Cancellations
- Day 66: Implementing Middleware with Go Contexts
- Day 67: Advanced Error Handling Patterns in Go
- Day 68: Go Microservices: An Overview
- Day 69: Event-Driven Programming in Go
- Day 70: Implementing Background Jobs and Task Scheduling in Go
Days 71–80: Real-World Projects
Develop real-world applications using Go and put your knowledge to the test with hands-on projects.
- Day 71: Building a CLI Application with Cobra
- Day 72: Creating a Go-Based URL Shortener
- Day 73: Building a Web Crawler in Go
- Day 74: Developing a Simple Blogging Platform with Go
- Day 75: Building a RESTful API for a Task Manager Application
- Day 76: Implementing OAuth in a Go Web Application
- Day 77: Building a Chat Application with WebSockets
- Day 78: Go Microservices with gRPC
- Day 79: Developing a Command-Line Tool for Log Parsing
- Day 80: Real-Time Data Streaming with Go
Days 81–90: Performance Optimization and Go Tooling
These days focus on improving the performance of your Go applications and mastering the tools that Go provides for developers.
- Day 81: Profiling and Tracing with Go
- Day 82: Using Go Build Flags for Custom Builds
- Day 83: Go Toolchain: Compiling, Building, and Running Go Applications
- Day 84: Go Generics: Introduction and Use Cases
- Day 85: Optimizing Memory Usage in Go Applications
- Day 86: Parallelism with Goroutines and Worker Pools
- Day 87: Understanding and Optimizing Garbage Collection
- Day 88: Using Channels to Avoid Memory Leaks
- Day 89: Efficient String Manipulation in Go
- Day 90: Using Go's Trace Tool to Debug Concurrent Applications
Days 91–100: Advanced Concurrency Patterns
Master concurrency by learning advanced patterns and techniques for handling asynchronous operations.
- Day 91: Pipeline Concurrency Pattern
- Day 92: Fan-Out/Fan-In Pattern in Go
- Day 93: Error Handling in Concurrent Systems
- Day 94: Rate Limiting for Concurrent Requests
- Day 95: Deadlocks and How to Avoid Them
- Day 96: Throttling Goroutines
- Day 97: Building Safe Concurrent Systems with Goroutines and Mutexes
- Day 98: Handling Timeouts and Cancellations Gracefully
- Day 99: Building Scalable Services with Go Concurrency
- Day 100: Performance Benchmarks for Concurrent Programs
Days 101–108: Final Projects and Mastery
The final days are dedicated to building full-scale projects and reviewing advanced concepts to solidify your expertise.
- Day 101: Building a Full-Stack Go Application
- Day 102: Implementing Authentication and Authorization from Scratch
- Day 103: Developing a Microservice-Based Architecture with Go
- Day 104: Building a Distributed System with Go
- Day 105: Writing High-Performance Go Services
- Day 106: Contributing to Open Source Go Projects
- Day 107: Final Project: Build Your Own Go Library
- Day 108: Reviewing and Reflecting on the Journey to Go Mastery