Recently, I have been advancing the A Tour of Go multilingual translation project.
After all 103 Simplified Chinese course pages completed automatic translation and structural validation, I started having ChatGPT perform a second round of pre-release quality review on these pages.
I originally thought this phase would mainly deal with some relatively clear issues, such as:
- A certain sentence not being translated naturally enough;
- A certain technical meaning being skewed;
- Individual English words left untranslated;
- Certain headings bearing obvious marks of machine translation.
But after actually checking page by page, I found another category of issues that deserved more serious attention than I had imagined:
Which Chinese translation should be adopted for technical terms?
The most typical among these is channel in Go.
On the Chinese internet, you can see “通道” (channel), “信道” (signal channel), and “管道” (pipe/conduit), and many resources simply keep channel directly.
If the goal were merely to make the project look internally consistent, I could of course count which word appears more often in the current 103 pages and then change them all to that word.
But I later realized that this approach was unreasonable.
What a translation project currently uses internally cannot conversely prove that this translation is the more appropriate usage for the Chinese Go community.
Thus, what originally started as reviewing a few pages ultimately led to an additional horizontal calibration of core Chinese Go terminology.
1. The Problem Starts with channel
While reviewing the concurrency course, I first noticed an obvious inconsistency.
One page translated channel as:
信道
However, multiple subsequent pages used:
通道
In addition, another exercise page directly left the English word:
channel
In terms of project consistency, this definitely needed to be addressed.
But at the time, the first question was not:
“Can I just change the minority ‘信道’ to the majority ‘通道’?”
But rather:
In the Chinese Go community, what is
channelactually commonly called?
After this round of calibration, the project ultimately decided:
channel → 通道
And unified the headings and body text of concurrency/2 accordingly.

The first paragraph on this page now reads:
Channels are a typed communication mechanism through which you can send and receive values using the channel operator
<-.
Here, another original expression was also adjusted in passing.
It previously read:
A channel is a typed pipe…
This is not difficult to understand, but if the project later translates pipeline as “管道” (pipe), then defining channel as “管道” as well would easily conflate the two concepts in Chinese.
So, we ultimately used the more neutral:
typed communication mechanism
2. You Cannot Assume “通道” is the Standard Answer Just Because It Appears More Often in the Project
The real reason I decided to pause page modifications and do terminology calibration first was that I realized:
You cannot use the existing translation itself as the basis for judging whether the existing translation is correct.
Suppose that in the current 103 pages:
- “通道” appears 15 times;
- “信道” appears 2 times;
- The original
channelappears 1 time.
This at most only shows that:
The current translation model generates “通道” more frequently.
It does not show that:
The Chinese Go world has already formed “通道” as the sole standard.
So, I started reviewing resources that have long existed in the Chinese Go community.
A very intuitive phenomenon can be seen quickly.

Go 101 on the left directly calls this concept:
通道
Another Go tutorial series on the right explicitly uses:
信道
And if you keep looking, you can find other resources that directly use the English word channel.
As for “管道”, it is also very common in many videos, blogs, and tutorials.
So the answer is not:
One translation is correct, and all the rest are wrong.
The more accurate situation is:
The Chinese Go community itself has multiple expressions that have been used for a long time.
This means that “unification” in technical translation is not the same as simply looking up a dictionary.
3. Why We Ultimately Still Chose “通道”
Given so many translations, why did I ultimately choose:
channel → 通道
Instead of “信道”, “管道”, or directly keeping the English word?
This was not decided by the number of occurrences within the project, but by considering several factors comprehensively.
1. “通道” is Already an Established Chinese Go Term
It is not a translation invented by this project itself.
Many long-term maintained Chinese Go resources use “通道”, so when Chinese developers see this word, they can generally immediately associate it with Go’s channel.
2. “信道” is Also Valid, but is More of a Project Choice Issue
“信道” is not an incorrect translation.
Moreover, it has been used in some Chinese Go tutorials for years.
However, “信道” also carries a rather obvious communication engineering connotation in Chinese. For a programming tutorial like A Tour of Go, which is aimed at beginners, I personally ultimately felt that “通道” was slightly more natural.
So my approach was not:
“信道” is an incorrect translation.
But rather:
The Chinese community has a mature divergence of usage, and this project chooses to uniformly use “通道”.
3. “管道” is Best Reserved for pipeline
This is also a major reason why I ultimately leaned toward “通道”.
In the field of Go concurrency, there is also:
pipeline
If we uniformly adopt:
pipeline → 管道
Then also translating:
channel → 管道
Would cause two different concepts to use the same core term in Chinese.
Of course, when explaining channel in daily contexts, saying:
“You can think of it as a pipe that passes data.”
Is perfectly fine.
However, metaphors used during explanation and formal terms in the project glossary are best kept separate.
Therefore, it is currently determined as:
channel→ 通道pipeline→ 管道
This makes the conceptual boundaries clearer.
4. What Really Needs Solving is Not Just a Single channel
After investigating this far, I realized that it would be a bit of a pity to just fix channel and stop.
Because during the review of the 103 pages, other similar situations were encountered.
For example:
type inference
A certain page currently translates it as:
类型推导
This word is understandable, and it is not entirely unused in Chinese technical resources.
But after a horizontal check, I ultimately decided to unify it as:
类型推断
There is also:
untyped constant
The original translation was:
未指定类型的常量
The technical meaning is basically understandable.
But in Go’s Chinese terminology system:
无类型常量
Is clearly more concise and stable.
Thus, this terminology investigation gradually expanded from a single channel into a re-examination of a batch of core Go terms.
5. Not All Terms Should Adopt the Same “Forced Unification” Approach
After this round of investigation, I felt that Chinese Go terminology could be roughly divided into three categories.
Category 1: The Chinese Community Has Already Formed a Strong Consensus
For example:
slice→ 切片array→ 数组struct→ 结构体type assertion→ 类型断言type inference→ 类型推断untyped constant→ 无类型常量interface value→ 接口值concrete type→ 具体类型type parameter→ 类型参数constraint→ 约束standard library→ 标准库built-in→ 内置
There is no great need to invent new translations for this category.
The project can just uniformly use the expressions already long established by the Chinese community.
Category 2: Multiple Mature Translations Exist, and the Project Needs to Choose One Itself
For example:
receiver
In Chinese resources, you can often see both:
- 接收者
- 接收器
Both have been used for a long time.
So the A Tour of Go project decided to continue uniformly using:
接收者
This does not mean that if you see “接收器” in other resources in the future, you should consider it a mistranslation.
Another example is:
type switch
In Chinese resources, you can see:
- 类型选择
- 类型开关
- 类型分支
- 类型 switch
This project ultimately continues to adopt:
类型选择
It belongs to:
Fixed internal project usage
Rather than:
The only correct answer in the Chinese world
This distinction is actually very important.
Category 3: Retain Go’s Own Native Nouns
The most typical is:
goroutine
A large amount of resources on the Chinese internet write:
协程
Or even directly say:
Go 协程
But goroutine and a coroutine in the traditional sense are not completely equivalent.
Moreover, when Go developers actually read official documentation, source code, error messages, or search for technical issues, they will ultimately constantly encounter:
goroutine
So currently, the project has not forcibly translated it all into “协程”.
Instead, it retains:
goroutine
When it first appears, we then explain:
A goroutine is a lightweight thread managed by the Go runtime.
I think that for a technical tutorial, this approach is more robust than translating all English terms.
6. Terminology Discussions Ultimately Have to Be Grounded in the Project
If we merely finish discussing and then continue to rely on the translation model itself to remember these decisions, the problem will very likely reappear during the next round of upstream synchronization.
So, once determined, these translations need to actually enter the project’s maintained glossary.

This time, the following were added:
built-in→ 内置channel→ 通道type inference→ 类型推断untyped constant→ 无类型常量untyped numeric constant→ 无类型数值常量
There is a detail here that is also quite worth recording.
These words were ultimately added to:
preferred
Instead of:
mandatory
I later specifically had Codex check the actual implementation of the project’s existing glossary.
It turned out that the current mandatory does not simply mean:
“Whenever this English word is encountered in the body text, the specified Chinese translation must be used.”
It mainly participates in prompt words and the forced validation of certain protected structures.
And:
preferred
Is mainly used to provide unified terminology suggestions to the translation model.
In other words, if in the future we truly hope to achieve:
Automatic checking of whether any occurrence of
channelin the regular body text is translated as “通道”.
The correct direction should be to enhance the regular body text terminology validator, rather than simply moving the glossary entry from preferred to mandatory.
This was also an extra takeaway from this investigation process:
The configuration name in the glossary does not necessarily equal its validation semantics in the actual code.
Ultimately, you still have to look at the implementation.
7. basics/14 is a Very Typical Actual Modification
After terminology unification was truly applied to the pages, basics/14 is an example well-suited to serve as a representative.

The original title of this page was:
类型推导
Ultimately changed to:
类型推断
The original body text:
When declaring a variable, if you do not specify an explicit type…
Was changed to:
When declaring a variable, if you do not explicitly specify a type…
Here, it is not just a terminology issue; the Chinese word order was also adjusted to be more natural in passing.
In addition:
未指定类型的数值常量
Was unified into:
无类型数值常量
So this pre-release review was not about rewriting GLM-5.2’s translations for the sake of “manual polishing”.
The real goal was more like:
Finding the technical terms, semantic issues, and expressions that clearly affect readability and truly deserve modification, and then making minimal corrections.
8. Terminology Unification is Not the Same as “Pursuing the Only Standard Answer”
After this round of investigation, my biggest takeaway was actually not:
Finding the only correct Chinese translation for all Go terms.
But rather:
Many technical terms inherently do not have a single correct answer.
For example:
- Whether
receiveruses “接收者” or “接收器”; - Whether
type switchuses “类型选择”, “类型分支”, or directly retains switch; - Whether
goroutineis translated as “协程”; - Whether
mapis translated as “映射”, or if the body text just directly writes map.
If the goal is set to:
Find the only correct translation across the entire Chinese internet.
You might end up getting no answer at all.
For a long-term maintained multilingual project, I now prefer to adopt the following principle:
First respect the habits already formed by the target language community, and then select the project’s own unified standard when multiple mature translations exist.
That is to say:
Unification does not mean declaring other translations wrong.
This principle is more important than simply building an “English → Chinese” terminology table.
9. This Terminology Calibration Ultimately Did Not Cause Large-scale Rework
When I started the investigation, I was actually a bit worried:
Would checking Chinese community usage reveal that many terms in the previous 103 pages needed readjusting?
The result was no.
The vast majority of core terms were already quite stable.
What really needed to be added or adjusted were just a few words.
This also shows that the previous full-page translations by GLM-5.2 did not suffer from a severe loss of control over the terminology system.
Ultimately, this round of terminology investigation just helped the project further clarify:
- Which words belong to strong community consensus;
- Which words belong to the project’s own fixed choices;
- Which Go-specific terms are more appropriate to keep in English;
- What responsibilities the glossary should bear;
- And what responsibilities the validator should bear.
This is more valuable in the long run than just fixing a single:
信道 → 通道
It has more long-term value.
10. Summary
This matter started out very simply.
I was just reviewing concurrency/2 and found:
Why is it called “信道” here, but “通道” on the following pages?
If the goal was just to complete the project as quickly as possible, the simplest method would of course be:
See which one appears more, and unify them all to that one.
But I later decided to stop and confirm.
The result was:
A technical translation project cannot use its own existing translations as the final basis for whether terminology is reasonable.
Especially for a language like Go, which already has a large amount of Chinese technical resources and years of community accumulation, you should first look at how Chinese developers have actually been expressing these concepts over the long term.
Ultimately, the Simplified Chinese version of A Tour of Go determined:
channel→ 通道
But what is more important is not this individual result.
What truly formed is a set of judgment principles that can continue to be used in the future:
Adopt terms with strong community consensus directly; let the project uniformly select terms with mature divergence; and do not forcibly translate Go’s native proper nouns just for the sake of Chinese localization.
This set of principles will not only be used for the current zh-CN going forward.
If the project adds new target languages in the future, it will similarly need to face:
What kind of terminology habits has that language’s technical community already formed?
So, although this round seemingly just adjusted a few words, it actually also filled in a very important piece of multilingual translation projects:
Terminology is not an accessory to the model’s generated results, but should become a part of the project’s long-term maintenance.
And after completing the terminology calibration, I continued to process the pages from the 103-page body text review that truly deserved modification.
The final result was:
All 103 pages were audited, and only 16 pages were modified.
I will leave this process to be recorded in the next article.
