Open-source project
ardanlabs/gotraining avatar
ardanlabs/gotraining

ardanlabs/gotraining: The Ultimate Go Class Material as a Repository

Go Training Class Material :

12,237 stars2,181 forksGoNOASSERTION

At a glance

What is it?
The ardanlabs/gotraining repository is the class material for Ardan Labs' Ultimate Go course, not an installable library. Here is what is actually in it, how to run the code, and where it stops being useful.
Who is it for?
Adopt ardanlabs/gotraining if you already write Go and want the language mechanics, design philosophy and profiling material that Ardan Labs teaches in class, and you are willing to read rather than be taught. Skip it if you need a runnable library, a beginner tutorial, or a course with an official completion record, because the repository provides none of those.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository last received commits 17 days ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 13, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • ardanlabs/gotraining12,237 ★ · +2
Star history
Repository2026-09-222026-11-13
ardanlabs/gotraining12.2k12.2k

2 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What ardanlabs/gotraining actually is

This repository is the written material for Ardan Labs' Go classes, not a package you import. The README points readers to topics/README.md for the list of courses and material, and it states plainly that the classes target intermediate-level developers with at least a few months to years of experience writing Go. The stated push is language mechanics, design philosophies and guidelines, with emphasis on consistency, integrity, readability and simplicity. There is also a recurring phrase in the README, "if performance matters", tied to mechanical sympathy, data oriented design and decoupling.

The audience is therefore narrow and specific. If you are learning your first for loop, this is the wrong shelf. If you have shipped Go and want to understand why the runtime behaves the way it does, the material is aimed at you. Ardan Labs also sells a recorded version of the class and a book, the Ultimate Go Notebook, through education.ardanlabs.com, so the repository functions as the open part of a commercial training offering. That is worth knowing before you assume the repository is the whole product.

How the material is organised: topics, reading, tools

The top-level layout tells you most of what you need. There is topics/, reading/, tools/, env/, a Dockerfile, go.mod and go.sum, plus a vendor/ directory. The README's own index links to sections such as Important Reading and Before You Come To Class, which means the repository is structured around a taught session rather than around a self-paced path.

Because vendor/ is committed, the module dependencies are pinned in the tree as well as in go.mod. That is a deliberate choice: it makes the examples reproducible even when upstream modules move. The cost is repository size and the fact that dependency updates arrive as commits rather than as resolved versions at build time. The go.mod declares module github.com/ardanlabs/gotraining and requires go 1.26.0, with direct dependencies including github.com/google/go-cmp, github.com/patrickmn/go-cache, github.com/pborman/uuid, github.com/pkg/errors and gonum.org/v1/plot. That mix suggests the code spans comparison testing, caching examples, UUID generation, error wrapping and plotting, which fits a class that covers both language mechanics and profiling output.

Running the class code: Dockerfile and a first example

The repository ships a Dockerfile rather than install instructions. It builds from golang:1.11-alpine3.8 and installs graphviz and ttf-freefont, sets the working directory to /go/src/github.com/ardanlabs/gotraining, and sets the entrypoint to /bin/sh.

Note the mismatch worth checking before you build: the Dockerfile pins Go 1.11 while go.mod requires go 1.26.0. Treat the Dockerfile as a legacy convenience image and prefer a local toolchain that satisfies go.mod.

To work with the material locally, clone the repository and confirm the module resolves. The go.mod declares the module path, so builds run from the repository root:

bash
git clone https://github.com/ardanlabs/gotraining.git
cd gotraining
go mod download
go build ./...

If you would rather use the provided image, build and enter it. The entrypoint is a shell, so you get an interactive session inside the working directory:

bash
docker build -t gotraining .
docker run --rm -it gotraining

Inside that shell you are at /go/src/github.com/ardanlabs/gotraining, which is where the examples expect to be. The README links topics/README.md for the courses and material. Start there rather than guessing at a directory.

Where the repository falls short as a learning resource

The biggest limitation is that the repository is class material. The README's index includes Before You Come To Class and links to corporate training, open enrollment sessions and on-demand options, which tells you the intended delivery is a taught session with an instructor.

Second, there are no releases. GitHub shows no releases, so there is no versioned snapshot to pin against. You track master, and the last push was on 2026-10-29. That is recent enough that the repository is not abandoned, but it also means the material moves without a changelog you can consult.

Third, the licence is recorded as NOASSERTION. GitHub could not classify it automatically, and the repository does contain a LICENSE file, but the metadata does not tell you which terms apply. If you plan to reuse examples in your own training or product, read LICENSE yourself; the repository metadata will not answer the question for you. Finally, the Dockerfile's Go 1.11 base against a go 1.26.0 module is a real friction point for anyone who assumes the container is the supported path.

How it compares with other Go learning paths

The obvious alternative is the official Go tour and the language documentation, which are self-paced, runnable in a browser and updated with each release. The difference in approach is the direction of travel: the tour teaches syntax and standard library surface, while ardanlabs/gotraining assumes you already write Go and spends its time on mechanics, data oriented design and profiling. If your gap is "I do not know Go yet", the tour closes it faster. If your gap is "my Go compiles but I do not understand the scheduler, escape analysis or channel semantics", the tour will not help and this material will.

A second alternative is a general Go book. The README points to the Ultimate Go Notebook, described as a book for all of the material in the class, sold through education.ardanlabs.com. The repository's advantage is that it is free to read and contains the actual example code; the advantage of the book is that someone has ordered the argument for you. Choosing between them is really choosing between reading a repository tree and reading a narrative.

Maintenance, upgrades and licence questions

Maintenance signals here are mixed and should be read carefully. The repository is not archived, and the last push was on 2026-10-29, so it is being touched. There are no tagged releases, so there is no upgrade path in the usual sense: you pull master and deal with whatever changed. The module requires go 1.26.0, which sets a floor on your toolchain; building with an older Go will fail at module resolution rather than at compile time, which is at least a clear error.

The committed vendor/ directory is the practical upgrade story. Because dependencies are vendored, a fresh clone builds against the exact versions the maintainers tested, and you are not exposed to upstream breakage until you choose to update. The trade-off is that you inherit those pinned versions too, including indirect ones such as golang.org/x/image and golang.org/x/text, and refreshing them is a manual exercise.

On licensing, the metadata says NOASSERTION, and a LICENSE file exists at the repository root. That combination means the automated classifier declined to pick a standard identifier. Do not infer terms from the README's copyright line, which lists years from 2015 through 2022 alongside a contact address. Read the LICENSE file before reusing material, and treat any conclusion you draw as your own reading rather than legal advice.

Editorial conclusion

Adopt ardanlabs/gotraining if you already write Go and want the language mechanics, design philosophy and profiling material that Ardan Labs teaches in class, and you are willing to read rather than be taught. Skip it if you need a runnable library, a beginner tutorial, or a course with an official completion record, because the repository provides none of those. Before you commit, open topics/README.md, confirm the Go version in go.mod against your toolchain, and check whether the Dockerfile's golang:1.11-alpine3.8 base still fits your environment.

Frequently asked questions

What is ardanlabs/gotraining?

It is the class material for Ardan Labs' Go training courses, published as a repository rather than as a library. The README describes the classes as aimed at intermediate-level developers with at least a few months to years of experience writing Go, focused on language mechanics, design philosophies and guidelines.

Is ardanlabs/gotraining free to use?

The repository is public and readable, and the README links to a recorded version of the class and a book sold through education.ardanlabs.com. The licence metadata is recorded as NOASSERTION, so check the LICENSE file at the repository root before reusing any material.

How do I run the code in ardanlabs/gotraining?

The repository ships a Dockerfile that builds from golang:1.11-alpine3.8, installs graphviz and ttf-freefont, and sets /bin/sh as the entrypoint with the working directory at /go/src/github.com/ardanlabs/gotraining. Alternatively, clone the repository and run go mod download and go build ./... with a toolchain that satisfies the go 1.26.0 directive in go.mod.

Which Go version does ardanlabs/gotraining require?

The go.mod file declares go 1.26.0, and the module path is github.com/ardanlabs/gotraining. The Dockerfile, by contrast, uses golang:1.11-alpine3.8.

Does ardanlabs/gotraining have releases I can pin to?

The repository has no published GitHub releases, so there is no tagged version to pin against. You follow the master branch, and the last push was on 2026-10-29.

Official sources

  1. ardanlabs/gotraining on GitHub
  2. Issues
  3. Project website
  4. README
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/ardanlabs-gotraining.svg)](https://hysenlabs.com/projects/ardanlabs-gotraining)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/ardanlabs-gotraining.svg)](https://hysenlabs.com/projects/ardanlabs-gotraining)

Was this useful?