Skip to content
New this month 24 fresh C++, C#, F#, JavaScript, TypeScript and Lua courses just landed. Browse new releases Use code WELCOME10 for 10% off your first order · 14-day refund
WisdomCharms — home
Cart 0 items in cart
Programming Languages Beginner

Go Modules and Tooling: A Practical 90-Minute Guide

Stop guessing at go.mod, vendoring and workspaces, and get the toolchain working for you.

Rated 4.5 out of 5 from 2 reviews 30 students

TE Created by Tom Eriksen

  • Last updated August 2026
  • English
  • 1h 28m of material
  • 11 lessons

What you will learn

6 concrete outcomes

Every bullet below is something you will have built, shipped or be able to explain by the time you finish the last lesson.

  • Read go.mod and go.sum and explain what each line and hash guarantees
  • Add, upgrade and downgrade dependencies with minimal version selection in mind
  • Trace unwanted dependencies using go mod graph and go mod why
  • Use replace directives and go.work workspaces for local multi-module development
  • Configure private modules with GOPRIVATE and proxy authentication
  • Cross-compile with GOOS and GOARCH and produce reproducible, version-stamped builds

Course curriculum

4 modules · 11 lessons · 1h 28m of material

3 lessons running 24m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

3 lessons running 24m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

3 lessons running 22m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

2 lessons running 18m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

4 modules · 11 lessons

1h 28m total length

Requirements

Short list, and deliberately so. If you meet these you can start today.

  • Basic Go familiarity: you can build and run a program
  • Go 1.22 or newer installed with access to a terminal

About this course

The Go language is famously simple, and then you meet modules. Minimal version selection, replace directives, the toolchain line, vendoring, private module proxies and multi-module workspaces are all straightforward once explained, and mysterious until then. This short guide covers the whole picture in ninety minutes.

You start with what go.mod and go.sum actually contain and why the checksum database matters. Then comes dependency work in practice: adding, upgrading and downgrading, understanding minimal version selection instead of assuming npm-style resolution, reading go mod graph and go mod why to find where an unwanted dependency entered, and pruning with go mod tidy.

The second half covers the situations that generate support questions: replace directives for local development, workspaces with go.work for changing several modules at once, vendoring and when it is still the right call, private modules with GOPRIVATE and authentication, and the toolchain directive that pins a Go version per module. The final lessons cover build tags, cross-compilation with GOOS and GOARCH, and reproducible builds with trimpath and version stamping.

Topics covered

Frequently asked questions

Still unsure about something? Write to misteryjj100@gmail.com and a human answers, usually the same working day.

No, it covers modules and tooling only. If you are new to Go entirely, the backend course teaches the language and then uses this material in context.

Yes, in the workspaces lesson. go.work is exactly the mechanism for developing several modules in one repository without permanent replace directives.

The final lesson covers it: copy go.mod and go.sum first so the download layer caches, mount the module cache for repeat builds, and pass private module credentials without baking them into an image layer.

Checkout is handled on our provider's secure payment page. The moment your payment clears we email your personal access link and access code to the address you used at checkout, and the same link appears in your account library. There is nothing to install and nothing to wait for.

Email misteryjj100@gmail.com within 14 days of your purchase, quote your order number, and we refund the full amount to your original payment method. No form to fill in and no questions about how much of the course you watched.

What students say

Reviews are written by people who bought this course. We publish the critical ones too.

4.5

Rated 4.5 out of 5

Course rating · 2 reviews

Rating distribution

  • 5 stars 50%
  • 4 stars 50%
  • 3 stars 0%
  • 2 stars 0%
  • 1 star 0%
  • DS

    Dawid Szymański

    Backend engineer

    Feb 2026
    Rated 5.0 out of 5

    Minimal version selection, explained properly

    I read the original proposal twice and came away none the wiser about why Go declines to take the newest version on offer. The worked example with three modules and conflicting requirements made it click, and go.sum diffs have stopped alarming me.
  • AR

    Aisha Rahman

    Platform engineer

    Oct 2025
    Rated 4.0 out of 5

    Private modules deserved longer

    Workspaces and replace directives get thorough treatment and I fixed a monorepo problem the same evening. Private module setup gets roughly four minutes and skips the proxy configuration you will certainly need once your build moves into CI.

Your instructor

TE

Tom Eriksen

Platform engineer and DevOps instructor

  • 219 students taught
  • 13 courses published
  • 4.8 instructor rating
  • Docker
  • Kubernetes
  • CI/CD
  • Testing and tooling

Tom has built delivery pipelines for teams of three and teams of three hundred, and openly prefers the smaller ones. He teaches Docker, Kubernetes and CI/CD outward from a single commit, so nothing ever appears by magic, and he treats the test suite as part of the pipeline rather than a separate subject. Every course includes a deliberate outage that you have to diagnose from logs and metrics before you can continue. He is a CNCF contributor and a reluctant but formidable YAML expert.

See every course by Tom Eriksen
$9 USD

One-time payment · lifetime access

The WisdomCharms dispatch

One useful email a week. No fluff, no spam.

New course releases, discount codes before anyone else, and a short, practical breakdown of one technique — a prompt pattern, a C++ idiom, a TypeScript trick — that you can use the same day.

  • Subscriber-only launch pricing
  • Unsubscribe in one click
  • We never sell your address

By subscribing you agree to our Privacy Policy. Questions? Write to misteryjj100@gmail.com.