go-questions: the Go interview question bank that ships as a Hugo site and a printed book

What go-questions actually is, and the reader it assumes

The name suggests a question bank. The repository is closer to a book's companion site. The README lists three authors, an ISBN (978-7-111-70242-9), and a publisher, 机械工业出版社, and links to purchase pages on 京东, 当当 and 天猫. The site itself is described in the README as containing part of the printed content, some updates to that content, and errata, with the recommendation that readers buy the physical book and use the site alongside it.

The stated audience is broader than job seekers. The README's letter to readers argues that developers arriving from PHP, C++, or Java can write Go that performs acceptably without understanding the runtime, and then struggle to diagnose problems or tune performance because they lack the underlying model. It names k8s, docker, etcd and consul as evidence that Go is used at scale, and claims that companies including Google, Meta, Uber, Tencent, ByteDance, Zhihu and Maimai use the language. The framing is that interview preparation is one use, but any working Go programmer benefits from the source-level explanations.

That framing matters when you evaluate it. This is not a LeetCode-style drill set with runnable test cases. It is explanatory prose about Go internals, organized around questions. If you want graded exercises with hidden test suites, you are looking at the wrong artifact.

How the site is assembled: Hugo, content/, themes/ and two Makefile targets

The repository is a Hugo site, not a Go library. The top-level entries include config.toml, content/, themes/, archetypes/, scripts/ and a Makefile. There is no go.mod at the root, which is the clearest signal that the primary language tag on the repository is about the subject matter rather than the build system.

The Makefile is four lines and defines three targets. all runs hugo, which builds the site into the default output directory. s runs hugo server -D, the development server with drafts included. clean removes the public and data directories. The README does not document a deployment pipeline, a CI workflow, or how the published site at golang.design/go-questions is produced from this tree, so if you need to reproduce the live site exactly, the Makefile alone tells you the build command but not the hosting configuration.

Content lives under content/, and the README points at a specific path for the errata page, content/assets/ for images such as the cover and the WeChat QR code, and a released errata URL. The practical consequence is that the reading experience and the build are separable: you can read the Markdown under content/ without ever installing Hugo, and you can build a browsable local copy if you want search and navigation.

Installing Hugo and building the site locally

The repository does not vendor a Hugo binary and does not pin a Hugo version in the files available. The README gives no installation instructions for the toolchain at all; it points readers at the published site and the printed book. What the repository does give you is the Makefile, so the build step is whatever your local hugo resolves to.

Install Hugo through your package manager or the official release, then clone the repository and run the default target. The all target runs hugo with no arguments, which builds the site using the configuration and theme already in the tree.

git clone https://github.com/golang-design/go-questions.git
cd go-questions
make

After make completes, Hugo writes the generated site to its output directory (public/ by default, which is also what the clean target deletes). You should see the HTML tree appear there.

For a live preview while reading, use the s target, which passes -D so draft content is included in the server output.

make s

Hugo's server prints the local address it is listening on, typically port 1313, and serves the site with live reload. The README does not state a port, so confirm the address from the server output rather than assuming.

To return the tree to a clean state, the clean target removes the generated output and the data directory.

make clean

That is the whole documented workflow. There is no install target, no dependency lockfile, and no documented way to produce a PDF or EPUB from this tree.

The licence is the constraint that decides most adoption questions

The repository carries GPL-3.0 as its code licence, and the README separately states that the book content is released under 署名-非商业性使用-禁止演绎 4.0 国际 (CC BY-NC-ND 4.0), with a Creative Commons badge and the sentence that commercial use or quotation of all or part of the document is strictly prohibited, with publication authorized specifically to golang.design/go-questions.

Those two statements pull in different directions, and the repository does not reconcile them. A reader who wants to reuse the prose should treat the README's content licence as the governing statement for the prose, because that is the one the authors attached to the text itself. The practical reading: you may share the content with attribution, you may not use it commercially, and you may not distribute modified versions. A translated fork, an abridged version, or a question set extracted into your own product all fall on the wrong side of NoDerivatives or NonCommercial.

This is a description of what the files say, not legal advice. If you are building anything around this content, read LICENSE at the repository root and the licence paragraph in the README yourself, and get your own answer. The upgrade cost is low in the technical sense, since Hugo rebuilds are cheap, but the licence cost is fixed: there is no path to a derivative work under these terms.

Where the repository is thin, and when to pick something else

The README is written for a reader of the book, not for a contributor to a codebase. It documents the errata process (Issues and Pull Requests on GitHub), the discussion venue, and a table of author talk videos on talkgo.org covering defer and escape analysis, map internals, the scheduler, channel and select, CSP, concurrency bugs in real Go programs, time.Timer, generics, and reliable performance testing. What it does not document: a contribution guide for content, a style guide, a review process, a release process, or versioning. There are no releases in the repository.

The maintenance picture is a single data point. The last push was on 2026-06-06. The repository is not archived. That is all the repository supports; there is no release cadence to extrapolate from, and no stated commitment to tracking new Go versions. Go's runtime changes between releases, and prose about map internals or the scheduler can drift out of date, so check whether the specific chapter you care about reflects the Go version you are running.

A concrete alternative with a different approach is the Go source tree itself, plus the official blog and the language specification. That is primary material: it is always current with the release you are compiling against, it is permissively licensed for reuse, and it is not organized around interview questions. The trade-off is real in both directions. go-questions gives you a curated question order, Chinese explanations, and a printed counterpart; the source tree gives you authority and reuse rights but no narrative and no index of what interviewers ask. If your goal is to quote Go explanations inside your own training material, the upstream documentation is the only one of the two you can legally build on.

One more limitation worth naming: the site is explicitly a partial artifact. The README says the site contains part of the book, some updates, and errata, and recommends buying the book to use alongside it. Anyone treating the repository as a complete reference will find gaps that only the printed edition fills.

A realistic path from clone to reading

The shortest route does not involve Hugo. Clone the repository and read the Markdown under content/ directly, because the prose is the product and the site is a rendering of it.

If you do want the browsable version, the sequence is: install Hugo, clone, make s, open the address the server prints, and read. When you are done, make clean removes the generated output. Nothing in the tree requires a Go toolchain, a database, or network access beyond the initial clone and whatever the theme needs.

Before relying on any chapter, check the errata page the README links to, since the authors maintain it specifically to resolve confusion readers hit while reading. That page is the project's own statement about where the text is wrong or unclear, which makes it more useful than a general changelog for this kind of content.

Editorial conclusion

Use go-questions if you want a Chinese-language Go interview reference you can build locally with hugo and read offline, and if you accept that the content is NoDerivatives and non-commercial. Do not use it as a question bank to embed in a product, a training course, or a translated fork: the licence forbids derivatives and commercial use, and the repository states that commercial use or quotation of any part of the document is strictly prohibited. Before you clone, read LICENSE in the repository root and the errata page, because the site is described as containing only part of the printed book plus updates and corrections, so the book and the site are not the same artifact.

Frequently asked questions

Official sources

1. golang-design/go-questions on GitHub
2. Issues
3. License: GPL-3.0
4. Project website
5. README