没有不值得去解决的问题,也没有不值得去学习的技术!

Only 16 Pages Need Revision After a 103-Page Review: A Quality Audit of the A Tour of Go Chinese Text

Figure 1: The technical meaning is mostly correct, but "returns a function that returns..." clearly affects readability, so it was still listed as a Category C revision

作者:

在

Recently, I have been advancing the A Tour of Go multilingual translation project.

In the previous phase, I completed the translation of all course body text for the Simplified Chinese zh-CN. According to the current release scope, there are a total of 103 official release pages, and all of them have passed the project’s existing automated structural and page validation.

However, “passing automated validation” does not mean “ready for release.”

Automated validation is better at confirming:

  • whether the present structure is correct;
  • whether directives like .play are missing;
  • whether link targets have changed;
  • whether inline code structures are intact;
  • whether emphasis structures are preserved;
  • whether comments in the teaching code have broken the program structure;
  • whether the candidate’s structure matches the English source page.

But it struggles to judge another category of issues:

Although this sentence is technically correct, is the Chinese too convoluted?

Or:

Although this term is understandable, does it match the more common expression in the Chinese Go community?

So, after all 103 pages entered ready, I did not start publishing immediately. Instead, I added a complete round of pre-release body text quality audit.

The final result was somewhat unexpected:

Out of 103 pages reviewed page by page, only 16 actually needed revisions.


1. Why not have ChatGPT re-translate all 103 pages

The simplest and crudest approach would be to hand all 103 pages back to ChatGPT.

But I did not agree with this approach from the start.

Because the current translations are not unverified drafts.

They have already gone through:

Plaintext
GLM-5.2 full-page translation
→ candidate
→ present parsing
→ protected structure validation
→ page structure comparison
→ ready

If I rewrote all 103 pages before release, it would mean:

To improve a few sentences with actual issues, I would be reintroducing changes to a large amount of content that was already ready for release.

And every change reintroduces:

  • link shifts;
  • inline code structure changes;
  • emphasis structure changes;
  • missing directives;
  • technical meaning drift;
  • fluctuations in Chinese style.

So the principle for this audit was not:

Can ChatGPT write it better?

But rather:

Is the current page already good enough to be published?

These two standards are very different.


2. Establishing A / B / C / D four-tier audit criteria for 103 pages

To prevent the audit from gradually turning into “wanting to rewrite a sentence every time I see one,” I first set four levels for all pages.

A: No modification needed

The translation is:

  • technically accurate;
  • natural in Chinese;
  • reasonable in terminology;
  • free of obvious reading obstacles.

Even if ChatGPT could produce an alternative expression, that does not constitute a reason for modification.

B: Optional polish

There are minor optimizations that can be clearly identified, but the current version is perfectly fine to publish.

In principle, this category is not modified.

C: Suggested modification

There are relatively clear issues, such as:

  • obvious translationese;
  • inconsistent terminology;
  • English residue;
  • expressions so convoluted they require a re-read;
  • although the technical meaning is mostly correct, it already affects the reading experience.

D: Must modify

This category covers issues that genuinely affect technical meaning, such as:

  • mistranslations;
  • omissions;
  • shifts in technical concepts;
  • Chinese expressions that easily lead readers to misunderstand.

Later, during the actual audit process, I further adjusted one criterion:

“Technically correct” does not automatically earn an A or B.

If a sentence obviously reads like machine translation, and the reader needs to break it down to understand it, then even if the technical meaning it conveys is mostly correct, it should be classified as C.

This standard later directly affected a very typical page.


3. Representative C: technically correct, but “returns a function that returns…” is too convoluted

moretypes/26 is a very representative example.

This is the exercise page about function closures and the Fibonacci sequence.

The original translation was:

Implement a fibonacci function that returns a function (closure) that returns successive Fibonacci numbers (0, 1, 1, 2, 3, 5, …).

Strictly speaking, this is not a technical mistranslation.

After reading it a few times, you can understand what it is trying to say.

The problem is:

“returns a function that returns…”

This nested structure clearly bears the marks of English syntax being directly mapped into Chinese.

So it was ultimately classified as C, not B.

Figure 1: The technical meaning is mostly correct, but "returns a function that returns..." clearly affects readability, so it was still listed as a Category C revision
Figure 1: The technical meaning is mostly correct, but “returns a function that returns…” clearly affects readability, so it was still listed as a Category C revision

It was ultimately changed to:

Implement a fibonacci function that returns a function (closure), which in turn returns successive Fibonacci numbers (0, 1, 1, 2, 3, 5, …).

The technical meaning has not changed at all.

But the main structure of the Chinese sentence became clear immediately:

Plaintext
fibonacci
→ returns a closure
→ the closure returns successive Fibonacci numbers

This is also a point I became increasingly clear about later:

Pre-release quality audit is not about re-translating, but about fixing expressions that genuinely affect understanding.


4. Representative D: fmt.Println was incorrectly translated as main

Compared to Category C, Category D issues were much fewer.

Across all 103 pages, there were ultimately only 2 Category D pages.

One of them was flowcontrol/7.

The English original means:

Both calls to pow return before the call to main within fmt.Println begins.

But the original Chinese became:

Before main begins execution, both calls to pow have already returned…

These two statements are not the same thing.

Because pow itself is called during the execution of main.

If we say:

Before main begins execution, pow has already returned.

Then the execution order completely falls apart.

Figure 2: Technical mistranslation in flowcontrol/7—incorrectly translating "before the fmt.Println call begins" as "before main begins execution"
Figure 2: Technical mistranslation in flowcontrol/7—incorrectly translating “before the fmt.Println call begins” as “before main begins execution”

It was ultimately revised to:

Both calls to pow will return before fmt.Println is called within main.

This is a very clear Category D:

Must modify.

The other D appeared in moretypes/7.

The original Chinese described:

Go
a[1:4]

as:

the 1st to 3rd elements of a

But this Go slice actually contains:

the elements corresponding to indices 1, 2, and 3

In Chinese, “the 1st element” is usually understood as the first element at index 0.

So it was ultimately unified to:

elements at indices 1 to 3 in a

Neither of these two Ds is about “writing it more beautifully.”

They are issues that could genuinely affect a beginner’s understanding of program behavior.


5. A Go Chinese terminology calibration was inserted midway through the audit

Originally, I thought this round of work only required auditing the body text of 103 pages.

As a result, after checking the concurrency lessons, I found:

  • some pages used “信道” (channel);
  • some pages used “通道” (channel);
  • and some pages just kept channel.

This raised a new question:

What exactly should determine Go Chinese terminology?

Later, I did not decide based on “which word appears more in the project.” Instead, I referred back to long-standing resources in the Chinese Go community and ultimately froze a set of project terms.

For example:

  • channel → 通道
  • type inference → 类型推断
  • untyped constant → 无类型常量
  • untyped numeric constant → 无类型数值常量
  • built-in → 内置

I have already organized this part into a separate previous article, so I will not expand on it here.

But this terminology calibration also affected the final audit statistics.

For example, moretypes/15 originally had both appearing on the same page:

内建
内置

Two built-in translation methods.

Although this does not affect technical understanding at all, since the pre-release terminology baseline was decided to uniformly adopt:

内置

this page also entered Category C.

So the final number of official revisions increased from the initial 15 pages to:

16 pages


6. How many of the 103 pages ultimately needed modification

After all pages were audited and the terminology was calibrated, the final statistics were:

Plaintext
A: 87
B: 0
C: 14
D: 2

Total: 103

Those actually needing modification:

Plaintext
14 Category C
+
2 Category D
=
16 pages

That is to say:

87 / 103 pages remained as is.

I did not rewrite them just because ChatGPT could provide an alternative Chinese expression.

This is actually the part of this audit that I am quite satisfied with.

If a round of so-called “pre-release manual audit” ended up rewriting eighty or ninety of the 103 pages, I would instead suspect:

Was this an audit, or a re-translation?

And the current result is closer to the state I hoped for:

The model is responsible for producing the majority of the publishable translations, while the manual audit only finds the few genuine anomalies worth intervening on.


7. The 16 pages were not re-run through GLM, but received minimal precise revisions

After identifying the 16 pages, I did not call GLM-5.2 again.

Instead, I pinned down every modification first, including:

  • the current text;
  • the final suggested text;
  • the reason for modification;
  • whether it involves the glossary;
  • whether it would affect the existing present structure.

Then I handed them all to Codex for modification.

This step had several strict restrictions:

  • do not modify the other 87 Category A pages;
  • no opportunistic polishing;
  • do not re-translate entire pages;
  • do not modify .play;
  • do not change link targets;
  • do not bypass existing validators;
  • do not touch the public UI;
  • do not update project status docs.

Ultimately, only the following were modified:

16 candidates + glossary.yaml

This is why this round of modifications ultimately maintained a very small diff.


8. A particularly valuable surprise: the validator rejected my manual revision

methods/19 is my favorite case in this round of work.

Not because the issue was severe, but because it truly validated the project architecture.

This page originally had the sentence:

A nil error indicates success; a non-nil error indicates failure.

The Chinese was obviously a bit awkward.

My initial revision suggestion was:

A nil error indicates success; non-nil indicates failure.

From a Chinese perspective, there is nothing wrong with this sentence.

It is even more concise than the final adopted version.

But after Codex modified it, the validator did not pass.

The reason was:

The English source structure required this sentence to retain two `error` inline code structures, but my manual suggestion left only one.

In other words, in my attempt to make the Chinese more natural, I inadvertently deleted a protected inline-code span.

Figure 3: Manual revisions cannot bypass structural validation either; methods/19 was rejected by the validator for missing one inline code structure
Figure 3: Manual revisions cannot bypass structural validation either; methods/19 was rejected by the validator for missing one inline code structure

It was finally changed to:

A nil error indicates success; a non-nil error indicates failure.

Running the validator again:

Plaintext
PASS
candidate OK: locale=zh-CN page_id=methods/19

This incident perfectly illustrates why this project insists:

Whether the translation comes from GLM-5.2, ChatGPT, or manual modification, it must pass through the same automated validation.

If a sentence was considered “of course correct” just because ChatGPT and I confirmed it manually, then this structural change would not have been caught.

And the validator does not care:

who modified the sentence.

It only cares:

whether the candidate still satisfies the structural constraints required by the source page.

This is exactly the property I want the entire process to have.


9. Teaching code comments also underwent a dedicated validation pass

This round also included a relatively minor but very representative modification in concurrency/6.

The body text had been translated into Chinese, but two English teaching comments remained in the select example:

Go
select {
case i := <-c:
    // use i
default:
    // receiving from c would block
}

Ultimately translated to:

Go
select {
case i := <-c:
    // 使用 i
default:
    // 从 c 接收会阻塞
}

The project had already specifically implemented protection, restoration, and validation for translatable teaching code comments.

So it was not the case that just because:

“they are just two comments”

they were modified and let through directly.

They still went through the full existing teaching-comment and structural validator.

And ultimately passed.

This again demonstrates:

Translatable does not mean structural protection can be bypassed.


10. Even an extra newline at the end of the file was cleaned up

After all 16 pages were modified, I had Codex perform a read-only diff audit on the 17 files.

There were no issues with the semantic changes, but it found:

10 candidates originally had no newline at the end of the file, but after manual editing, an extra 0a byte was accidentally introduced.

This of course would not affect Go Tour rendering.

Nor would it cause the validator to fail.

But it is a purely meaningless diff.

Since the goal this time was:

minimal, precise revisions

there was no reason to bring this kind of change into the final commit.

So the EOF state of these 10 files was specifically restored to their original state.

Final confirmation:

  • body text unchanged;
  • structure unchanged;
  • 10 EOF noises eliminated;
  • no additional changes in other files.

This kind of detail is not important in itself.

But it makes the final commit easier to audit:

Every diff should answer “why was this changed?”.


11. Ultimately, all 16 / 16 passed validation again

After all revisions were completed, the 16 pages were re-run through the unified validator.

Result:

Plaintext
16 / 16 PASS

Then the complete Go test was executed:

Plaintext
go test ./...

All passed.

Continue checking:

Plaintext
git diff --check

Also passed.

The complete result of this final round is:

Figure 4: All 103 pages completed quality audit, 16 revised pages re-passed unified validation and were committed as 5f77081
Figure 4: All 103 pages completed quality audit, 16 revised pages re-passed unified validation and were committed as 5f77081

Final summary:

Plaintext
audited pages: 103 / 103

A: 87
C: 14
D: 2

revised pages: 16 / 16
validator: PASS
go test ./...: PASS
git diff --check: PASS

And committed:

Plaintext
5f77081 fix: 完成 zh-CN 课程正文质量审计修订

After committing:

Plaintext
working tree: clean

12. From 103 pages ready to 103 pages passing pre-release quality audit

Before this, the project already had a very important commit:

Plaintext
584ce7d feat: 完成 zh-CN 全部课程页面翻译

It represents:

All 103 official release pages have completed translation and passed automated validation to reach ready.

And this new one:

Plaintext
5f77081 fix: 完成 zh-CN 课程正文质量审计修订

represents another phase:

All 103 pages have undergone a pre-release manual quality audit, and the 16 pages requiring adjustments have been revised and re-passed the same automated validation.

The implications of these two milestones are not the same.

The first answers:

Has the translation process been fully run?

The second answers:

Has the current translation undergone a complete pre-release quality check?

Now, both questions can be answered:

Yes.


13. Why ultimately “only modifying 16 pages” is actually a good result

Before this audit, I actually did not know how much would be changed in the end.

It could have been 10 pages, or it could have been 50 pages.

But ultimately:

Out of 103 pages, only 16 needed clear revisions.

I feel this ratio actually shows that the preceding translation process was already quite stable.

Especially since:

There were only 2 pages of Category D, which are genuine technical errors.

Most of the remaining content needing modification was:

  • obviously awkward Chinese;
  • inconsistent terminology;
  • English residue;
  • a certain expression that was not accurate enough;
  • a sentence that, while understandable, was not suitable as published tutorial text.

This is quite close to the direction the project originally wanted to achieve:

It does not require manual sentence-by-sentence re-translation, but it must have the ability to catch the few genuinely anomalous pages before release.

If this expands to other languages in the future, I also do not want the process to become:

Plaintext
Model translates 100 pages
→ Human re-translates 100 pages

The significance of automation would be very limited then.

I prefer it to maintain its current structure:

Plaintext
Model full-page translation
→ Automated structural validation
→ Full quality audit
→ Revise only clear anomalies
→ Same automated validation
→ Release

14. Summary

What impressed me most about this round of 103-page body text quality audit was not:

how many sentences were changed.

But rather that the entire process began to form a fairly clear closed loop.

After the model generates the translation, automated validation is responsible for structural reliability.

The manual audit is not responsible for rewriting all pages, but only for judging:

which pages are genuinely worth intervening on.

After manual modifications, they do not receive special treatment just because “a human modified them.” Instead, they re-enter the same validator.

Ultimately:

All 103 pages audited, 87 pages kept as is, 14 Category C, 2 Category D, totaling 16 pages revised.

And that failure of methods/19 particularly confirmed to me:

Manual judgment and automated validation are not substitutes for each other, but complements.

Humans are better at noticing:

“Why is this sentence so convoluted?”

The validator is better at noticing:

“You just deleted a mandatory inline code structure to make it less convoluted.”

Having both present at the same time is closer to the release process I hope this project will ultimately have.

At this point, the course body text for A Tour of Go Simplified Chinese can basically be considered to have finished its pre-release wrap-up.

The next remaining focus is no longer the 103 course pages themselves, but another layer of content in the browser:

Public UI copy.

For example, what can still be seen on the page currently:

  • Run
  • Format
  • Reset
  • Syntax
  • Previous / Next related interfaces
  • Other public interactive text

The body text is done, and the next phase will be their turn.

关于作者 · 持续学习与技术实践

我是一名拥有 15 年以上开发经验的技术从业者,自 2013 年起持续运营个人技术博客,记录工作与个人项目中遇到的真实问题,以及解决问题过程中的探索、实践和思考。

除了技术写作,我也在持续开发和维护自己的独立项目,探索新技术和新工具在实际场景中的应用。我始终相信,没有不值得去解决的问题,也没有不值得去学习的技术。

如果这篇文章对你有所帮助,欢迎浏览博客中的其他文章,也欢迎交流技术经验与想法。

关于我  ·  GitHub  ·  邮件联系