Why 87% of Go Roadmaps Teach the Wrong Things

Critiques existing Go roadmaps for focusing too narrowly on syntax, handlers, and databases, ignoring crucial production aspects like graceful shutdowns, health checks, and full architectural understanding. This roadmap aims to bridge that gap, offering a complete picture of Go development over five years of experience, suitable for beginners, experienced developers from other languages, and those looking to fill knowledge gaps. It's structured with progressively complex modules, from basics to microservices, observability, and Kubernetes, with timecodes for easy navigation and interview questions for each topic. The speaker also briefly touches on the impact of AI on the relevance of this roadmap, arguing it increases its importance.

This foundational level covers essential Go syntax (variables, loops, conditions, slices, maps, structs, interfaces). It emphasizes understanding basic syntax for application, not exhaustive memorization, and highlights Go's duck typing for interfaces. The recommended learning time is 2-4 weeks for experienced programmers and 4-6 for beginners, with GoTour as a key resource. Interview questions often involve subtle syntax behaviors like 'defer' execution and 'nil' interfaces. The discussion moves to goroutines and channels, Go's primary concurrency features, explaining their differences from OS threads, synchronization primitives (Mutex, WaitGroup), and channel types. Practical problems, such as handling timeouts with context and stopping goroutines, are presented. HTTP handling is covered as the 'hands' of Go, detailing the 'net/http' package, REST principles, UDP vs. TCP, popular routers (Gin, Echo, Fiber), and middleware for cross-cutting concerns like logging and authentication. The differences between HTTP methods (PUT vs. PATCH) and the concept of idempotency are also explained. Finally, database interactions, specifically with PostgreSQL, are discussed, covering essential SQL commands (SELECT, INSERT, UPDATE, DELETE, JOIN, GROUP BY), the PGX driver, database migrations with 'goose,' and transaction management, including ACID properties and isolation levels.

The final skills for the first stage are Git for version control and testing. Git basics include commits, pushes, pulls, branches, merges, and pull requests, with an interactive game (Leing Gitching) recommended for learning. Understanding Git principles is crucial even when using GUI clients. For testing, the standard 'testing' package is highlighted, demonstrating table-driven tests for organizing test cases efficiently. This foundational set of skills is considered sufficient for an entry-level Go developer role, emphasizing practice with typical interview tasks.

This level addresses the complexities of real-world projects beyond basic coding. Docker is introduced as a standard, covering Dockerfiles, multi-stage builds (for optimized Go binaries), images, containers, volumes, and Docker Compose for local development. Error handling in Go, particularly wrapping errors with additional context and using custom error types with 'errors.Is' and 'errors.As,' is detailed, along with a warning against 'log.Fatal' in handlers. A common three-layer architecture (Handler, Service, Repository) is explained, emphasizing separation of concerns, especially the isolation of business logic in the service layer from transport and infrastructure via interfaces. Structured logging with the 'slog' package is presented as crucial for debugging in production. Caching with Redis is discussed, covering its in-memory storage, common commands (GET, SET, TTL), the 'go-redis' library, and the Cache-Aside pattern. The importance of handling Redis failures gracefully to avoid service outages is also noted. Integrating with external APIs requires attention to timeouts, proper error handling, retries (with idempotent operations), and retry policies. The Anti-Corruption Layer pattern is introduced to shield business logic from third-party API complexities. Asynchronous communication via message queues like Kafka is explained using the example of order confirmation emails. Key Kafka concepts such as topics, partitions, partition keys for ordered processing, consumer groups for scaling, and delivery guarantees (At Most Once, At Least Once, Exactly Once) are covered, with practical advice on implementing idempotency on the consumer side.

This level focuses on building robust, production-ready systems. It starts with a discussion on microservices vs. monoliths, highlighting the trade-offs and advocating for granular microservice division by business domain rather than technical function. GRPC is introduced as a preferred communication protocol for internal microservices due to its performance benefits (HTTP/2, binary body, compressed headers, streaming) and language agnosticism via Protobuf. Key GRPC concepts like unary calls, streaming, interceptors, and error codes are explained. Advanced Kafka topics include partitioning for ordering and load distribution, consumer groups for scalability, and delivery guarantees (At Most Once, At Least Once, Exactly Once), with a focus on implementing idempotency. Observability, comprising metrics, logs, and traces, is presented as essential for understanding system behavior in production. OpenTelemetry is highlighted for standardizing these signals, and common tools like Prometheus, Grafana, Jaeger, ELK stack (Elasticsearch, Logstash, Kibana), and Filebeat are mentioned. Graceful shutdown is emphasized for preventing data loss and 500 errors during deployments, explaining how to handle system signals and manage active requests. Health checks (Liveness and Readiness probes) in Kubernetes are detailed for ensuring service availability and readiness, showcasing how incorrect implementation can lead to traffic issues. The integration of these complex technologies requires hands-on experience, which the speaker addresses with a plug for his microservices course.

The discussion continues with Continuous Integration/Continuous Delivery (CI/CD) pipelines, outlining typical stages like linting, testing, building, and deployment, and common platforms like GitHub Actions. Kubernetes is presented for deploying and managing services at scale, explaining core abstractions: Pods, Deployments, Services, ConfigMaps, Secrets, Ingresses, and resource limits (CPU/memory), including the OOM Killer. Understanding these concepts is crucial for working with enterprise-level systems. Performance issues are also explored, noting that bottlenecks can be at the infrastructure level. Quality assurance aspects are revisited, differentiating between unit, integration, and end-to-end tests, and advising on their appropriate use and implementation (e.g., using Testcontainers for integration tests). The importance of QA involvement in specific testing phases is also touched upon.

This advanced level focuses on the skills that distinguish senior engineers. System design is a core component, involving clarifying requirements, calculating loads, defining APIs, drawing high-level diagrams, and understanding trade-offs. Familiarity with various databases, caching systems, and scaling strategies is essential. Distributed systems patterns are discussed, including CQRS (Command Query Responsibility Segregation) for separating read/write operations, Event Sourcing for storing state changes as events, the Saga pattern for managing distributed transactions with compensation logic, and Circuit Breakers for preventing cascading failures in interconnected services. Transactional Outbox and Inbox patterns are introduced for reliable asynchronous message delivery and deduplication with Kafka. Data management beyond basic PostgreSQL is explored, including document-oriented (MongoDB), key-value (Redis), time-series databases, and columnar databases, emphasizing choosing the right tool for the job. Sharding for horizontal scaling of databases and replication strategies (synchronous, asynchronous, master-replica) are explained. A practical example of safely adding a column to a large database table to avoid downtime is provided. Performance analysis in Go uses pprof for identifying CPU and memory bottlenecks. Load testing with tools like Yandex Tank or K6 is discussed, stressing the importance of proper setup and infrastructure. Finally, defining service reliability through SLI (Service Level Indicator), SLO (Service Level Objective), and SLA (Service Level Agreement) is detailed, along with the concept of error budget and its role in release management. The section also covers deployment platforms, contrasting internal platforms of Russian big tech with public clouds (AWS, GCP, Azure).

This segment moves beyond technical skills to address crucial soft skills and career development. It emphasizes communication, negotiation, and teamwork for complex projects, covering aspects like conveying positions, active listening, and constructive criticism. Architectural Decision Records (ADRs) are mentioned as a tool for documenting major design decisions and gathering feedback. Visibility – the ability to showcase work results – is presented as a vital skill for career advancement, distinct from narcissism. The realities of corporate politics, including manipulation and nepotism, are discussed, encouraging self-reflection on whether to engage in these 'games.' Performance reviews are acknowledged as often unfair but operate within a system whose rules can be understood and leveraged. The evolving job market shows increased competition, plateauing salary growth, and a tendency for developers to switch jobs for promotion. The speaker advocates for continuous learning, technical improvement, and regular market awareness to maintain a competitive edge and make informed career decisions, rather than relying solely on internal company development promises.

The video concludes by addressing the role of AI, particularly in Go development. It notes that while AI can generate code, a significant portion of developers find it requires considerable effort to clean up, implying AI acts as a multiplier of existing skills rather than a replacement. The emergence of AI elevates the importance of system design, system engineering, and producing high-quality code. The roadmap levels are summarized: Level 1 (Fundamentals), Level 2 (Real-world application), Level 3 (Production-grade microservices), and Level 4 (Senior-level system design and soft skills). The key takeaway is to learn in the context of projects, acquiring technologies as needed, rather than following a rigid checklist. The speaker promotes his Go courses and encourages engagement with the channel through likes and subscriptions, offering a PDF version of the roadmap and links to complementary videos.