ardanlabs/gotraining: Go Class Material for Intermediate Developers from Ardan Labs

Who This Material Is For: The Minimal Qualified Student

The README is direct about the prerequisite: 'Our classes are perfect for intermediate-level developers who have at least a few months to years of experience writing code in Go.' This is not documentation for someone learning Go for the first time. Developers who have not yet written Go professionally and want an introduction to the language should start elsewhere.

The README describes what Ardan Labs targets: 'a very deep knowledge of the programming language with a big push on language mechanics, design philosophies and guidelines.' The emphasis is on understanding how Go works at the level of the scheduler, the memory allocator, and the escape analysis pass, not on API familiarity. The README summarizes the curriculum focus as 'how to write code with a priority on consistency, integrity, readability and simplicity' and 'if performance matters with a focus on mechanical sympathy, data oriented design, decoupling and writing/debugging production software.'

The phrase 'if performance matters' is notable. It signals that the performance-oriented content is not universally prescriptive but conditional. A developer writing an internal tool where throughput is not a constraint does not need to apply every optimization the curriculum covers. The course teaches when performance considerations apply, not just how to apply them.

The README also states a commercial claim: 'There is no other company that has been doing it longer and our material has proven to help jump-start developers 6 to 12 months ahead of their knowledge of Go.' This is a marketing assertion about the training program, not a verifiable benchmark. The repository itself does not contain data supporting the 6-to-12-month figure.

The Curriculum Emphasis: Language Mechanics, Concurrency, and Data Orientation

The material focuses on topics that experienced Go developers frequently cite as sources of confusion and bugs: how Go's value and pointer semantics interact with the garbage collector, how goroutines are scheduled and what that implies for synchronization, and how data layout in memory affects both correctness and cache performance.

Mechanical sympathy, a term the README uses explicitly, refers to writing code that aligns with how the underlying hardware actually works. In Go, this connects to understanding that goroutines are scheduled cooperatively by the Go runtime (not by the OS kernel), that interface values carry both type and pointer information in two words, and that memory allocation decisions made by the compiler's escape analysis determine whether a value lives on the stack or in heap memory, which affects garbage collection pressure.

Data-oriented design is another theme the README names directly. The concept contrasts with object-oriented design in that it prioritizes how data is laid out and accessed in memory rather than how abstractions model the problem domain. In Go, this tends to mean preferring slices of structs over slices of interface values, avoiding pointer-heavy data structures when value-type representations fit the use case, and thinking about cache line utilization when designing hot-path code.

The topics README at topics/README.md is described as the index for the course content, but that file's contents are not available in the materials used for this review. The curriculum categories mentioned in the README include engineering, design, algorithms, concurrency, and performance profiling.

William Kennedy, the lead instructor, has presented at GopherCon, GopherCon UK, GopherCon Singapore, GopherCon Europe, P99, dotGo, Code::Dive, and other conferences between 2014 and 2025, with talks covering concurrency design, escape analysis, garbage collection semantics, profiling, K8s CPU limits, and building coding agents. The README lists these presentations with links, providing a public record of the instructor's areas of focus.

Repository Structure and How to Navigate the Material

The repository root contains several directories and a few top-level files. The main content is in the topics/ directory, which the README describes as the location for all course material. The reading/ directory presumably holds supplementary reading material; the tools/ directory holds utility code. An env/ directory and a vendor/ directory are also present.

The go.mod file declares the module as github.com/ardanlabs/gotraining and requires go 1.26.0. The dependencies listed are: github.com/braintree/manners for graceful HTTP shutdown, github.com/google/go-cmp for test comparisons, github.com/patrickmn/go-cache for in-memory caching examples, github.com/pborman/uuid for UUID generation, github.com/pkg/errors for error wrapping, and gonum.org/v1/plot for data visualization in exercises. These dependencies reveal the kinds of practical examples the course covers: HTTP servers, testing patterns, caching, and data visualization.

The README links to topics/README.md as the index for course content with the text 'Review our different courses and material.' A developer accessing the repository for self-study should start there rather than at the root README.

A CONTRIBUTORS file and a .mailmap file are present at the root, standard for projects that accept community contributions. The repository has been under development since 2015, which is reflected in the copyright notice: 'Copyright 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, Ardan Labs.'

The Opening.md file at the root is also present. Its contents are not available here, but its name suggests it contains introductory context for the class materials.

Getting the Material: Cloning, the Dockerfile, and the Video Edition

The repository is public and can be cloned with standard git tooling. The README does not provide explicit clone instructions, but the repository's public URL is github.com/ardanlabs/gotraining.

The repository includes a Dockerfile for a development environment:

FROM golang:1.11-alpine3.8
RUN apk add --update --no-cache \
           graphviz \
           ttf-freefont
WORKDIR /go/src/github.com/ardanlabs/gotraining
ENTRYPOINT [ "/bin/sh" ]

This Dockerfile is based on golang:1.11-alpine3.8, which is a Go 1.11 image, and installs graphviz and ttf-freefont. These packages support exercises that generate call graphs or visualize data using the gonum/plot dependency. The Dockerfile has not been updated to match the go.mod requirement of go 1.26.0. This discrepancy means a developer building the Docker image as written would get a much older Go runtime than the go.mod expects. The README does not document whether the Dockerfile is still in use for local setup or is a legacy artifact.

For the full course experience with video instruction, the README points to education.ardanlabs.com as the location for the recorded training. The README describes this as 'the entire class material' in video form, available for 'those who can't have the class taught at their company or who can't attend a conference.' The recorded training is a paid product separate from the free repository.

The Ultimate Go Notebook, a companion book covering all class material, is also available at education.ardanlabs.com/courses/ultimate-go-notebook. The README mentions both the video and the book as supplementary resources for the class exercises in this repository.

For corporate training, live open-enrollment sessions, and on-demand options, the README directs inquiries to [email protected] and www.ardanlabs.com/training.

Limitations: Scope, Toolchain Version, and Licence Uncertainty

The curriculum does not cover web framework selection, database integration, microservices architecture, or cloud deployment. It focuses on the Go language and runtime itself. Developers who want guidance on building a complete web application stack in Go will need to look beyond this repository.

The toolchain version situation is worth noting. The go.mod file requires go 1.26.0, which is current. The Dockerfile, as mentioned, still references golang:1.11-alpine3.8 and has not been updated. Anyone who clones the repository and tries to build the exercises using the Dockerfile as written will encounter version mismatches. The README does not document this discrepancy or explain how to set up a working local environment for the exercises.

The licence for ardanlabs/gotraining is listed as NOASSERTION on GitHub, which means the repository does not have a standard SPDX-identified licence. The README footer includes a copyright notice: 'Copyright 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, Ardan Labs.' This is a copyright assertion, not a licence grant. Without an explicit licence, the default copyright law applies: the material is protected and not licensed for reuse. Developers who want to use the training material in their own courses or published materials should contact Ardan Labs to clarify terms rather than assuming open reuse is permitted.

The repository was last pushed on 2026-05-12. There are no GitHub releases.

William Kennedy and the Ardan Labs Training Ecosystem

The lead instructor is William Kennedy, a managing partner at Ardan Labs in Miami. The README describes him as the co-author of Go in Action (Manning), the author of the GoingGo.Net blog (now at www.ardanlabs.com/blog/), and a founding member of GoBridge, which works to increase Go adoption through diversity and outreach.

Kennedy's conference talk history, as listed in the README, spans from GopherCon 2014 (building an analytics engine) through GopherCon UK 2025 (building a coding agent from scratch and K8s CPU limits). The talks cover a consistent set of themes: scheduler semantics, garbage collection, escape analysis, profiling, and systems-level thinking in Go. This history is useful context for evaluating whether the material's emphases reflect durable principles or time-specific concerns.

Ardan Labs offers corporate training events, open enrollment live training sessions, and on-demand learning through the training page at www.ardanlabs.com/training. The gotraining repository is the companion to these commercial offerings; Ardan Labs publishes it publicly as a reference for class participants and as a demonstration of the curriculum.

The YouTube channel at youtube.ardanlabs.com provides additional recorded content. The README links to it alongside the conference talks. A developer who wants to assess the instructional style before committing to the paid training can watch recorded talks there.

Editorial conclusion

Intermediate Go developers who want principled instruction on Go's memory model, goroutine semantics, and data-oriented design will find this material well-suited. Go beginners should expect to be lost: the README explicitly states the target is developers with at least a few months to years of Go experience. The free repository covers all class exercises and reading material; video instruction is sold separately at education.ardanlabs.com. The last push was on 2026-05-12.

Frequently asked questions

Official sources

1. ardanlabs/gotraining on GitHub
2. Issues
3. Project website
4. README