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

Final Online Acceptance of the New A Tour of Go ChatGPT Translation: 103/103 and 7/7 Exact Match

Figure 3: The production origin and EdgeOne public responses for all 7 article endpoints achieve an exact match, while the new ChatGPT translation marker is present and the old translation marker has disappeared.

作者:

在

The previous two articles documented the first two phases of this round of Simplified Chinese re-translation for A Tour of Go.

The first phase involved using ChatGPT + GitHub to complete a full-page re-translation of all 103 official lesson pages, and integrating the ChatGPT translations into the existing engineering workflow via the current restore, validator, and retry processes.

The second phase continued with an independent semantic quality review, revision, and canonical promotion for all 103 pages. The final result was:

Plaintext
A = 103
B/C/D = 0

Based on the entire review round, my internal comprehensive quality assessment for the current zh-CN has also increased from around 94 to around 98.

But at this point, there is actually one last question left unanswered:

The canonical in the repository has already been switched to the new ChatGPT translation, but does this mean that when users open the production website, they will definitely see this new translation?

This cannot be directly inferred.

Because in between, there is still:

Plaintext
production release
↓
Production deployment
↓
Currently running release
↓
origin
↓
EdgeOne
↓
Public response

If any layer still uses the old content, the following could occur:

The repository has been updated, but public users are still seeing the old version.

So this article will no longer discuss the translation model, nor will it repeat the design process of the production deployment script that I wrote about previously.

I will only do one last thing:

Prove that this round of 103 new ChatGPT translated pages has truly entered the production environment in its entirety, and that the public network is returning the content of this official release.

1. First, confirm which release the production environment is actually running

After the official deployment concludes, the first step is not to immediately open a few browser pages to check.

I first confirm:

Which release /data/go-tour/current currently points to.

Figure 1: The release currently running in the production environment. The current version is 20260818-zh-CN-45f4cad, containing 103 official lesson pages and 7 articles; the systemd service is active, and both origin and public entry points return HTTP 200.
Figure 1: The release currently running in the production environment. The current version is 20260818-zh-CN-45f4cad, containing 103 official lesson pages and 7 articles; the systemd service is active, and both origin and public entry points return HTTP 200.

Current result:

Plaintext
current release :
/data/go-tour/releases/20260818-zh-CN-45f4cad

Corresponding manifest:

Plaintext
locale       : zh-CN
published_at : 2026-08-18T13:22:48Z
pages        : 103
articles     : 7
transport    : http-playground-proxy
local socket : False

Also:

Plaintext
service     : active
origin HTTP : 200
public HTTP : 200

This step first proves:

The currently running production version has indeed been switched to the new official release generated in this round.

Instead of:

Plaintext
Code commit successful
But current still points to old release

Or:

Plaintext
current has switched
But go-tour.service is not running normally

It can also be confirmed that:

Plaintext
local socket : False

Meaning the official release still uses the HTTP Playground proxy, and does not re-enable the local /socket code execution path.

2. The homepage opening is far from enough

If I only execute:

Plaintext
curl https://go-dev.shuijingwanwq.com/

And get:

Plaintext
HTTP 200

This actually does not prove that all 103 lesson pages have gone live normally.

Therefore, the next step directly expands to a full public route validation.

Figure 2: Final public route validation. The homepage, lesson entry, lesson list, robots, sitemap, and frontend scripts all return HTTP 200; the 103 official lesson routes achieve 103/103, with 0 failures.
Figure 2: Final public route validation. The homepage, lesson entry, lesson list, robots, sitemap, and frontend scripts all return HTTP 200; the 103 official lesson routes achieve 103/103, with 0 failures.

Core entry points:

Plaintext
/                    200
/tour/               200
/tour/list           200
/robots.txt          200
/sitemap.xml         200
/tour/script.js      200

Official lesson routes:

Plaintext
Formal course routes : 103
HTTP 200             : 103
Failed               : 0

That is:

Plaintext
103 / 103

All passed.

This layer answers:

After the new version is deployed, do any pages directly return 404, 500, or other HTTP errors?

The final answer is:

No.

3. Paths that should remain closed must also continue to be closed

Validation is not just checking:

Plaintext
Whether URLs that should succeed do succeed

It should also confirm:

Plaintext
Whether any URLs that should not be public have been accidentally restored by this release

Final check:

Plaintext
/socket          → 404
/socket/anything → 404
/_/share         → 404

These results are consistent with the current production architecture.

This point is especially important because the A Tour of Go upstream originally had browser and server-side code execution capabilities, while my production environment has been changed to an independent Playground proxy.

The normal production chain is:

Plaintext
Browser
↓
play.go-dev.shuijingwanwq.com
↓
Independent Playground proxy

Not:

Plaintext
Browser
↓
Main site /socket
↓
Local code execution

Therefore:

Plaintext
/socket → 404

Is not a functional anomaly.

On the contrary, it is the expected result in this validation.

4. 103/103 HTTP 200 still cannot prove the content is not stale cache

At this step:

Plaintext
103/103 HTTP 200

Actually still does not fully answer the most important question in this article.

Because the CDN can experience the following situation:

Plaintext
Production origin has been updated
↓
EdgeOne still holds old cache
↓
User access still returns 200
↓
But receives the previous version's content

So simply having:

Plaintext
HTTP 200

Cannot prove that “the new ChatGPT translation has truly reached the public network.”

It is necessary to further compare:

Whether the article content returned by origin and public is exactly the same.

5. Exact Match for 7 Article Endpoints

A Tour of Go currently has 7 .article:

Plaintext
welcome
basics
flowcontrol
moretypes
methods
generics
concurrency

These 7 articles ultimately make up all 103 official lesson pages.

Therefore, I separately fetched:

Plaintext
Production origin
http://127.0.0.1:3999/tour/lesson/<article>

And:

Plaintext
Public network
https://go-dev.shuijingwanwq.com/tour/lesson/<article>

Then calculated and compared the SHA-256 of the response content.

The results are as follows.

Figure 3: The production origin and EdgeOne public responses for all 7 article endpoints achieve an exact match, while the new ChatGPT translation marker is present and the old translation marker has disappeared.
Figure 3: The production origin and EdgeOne public responses for all 7 article endpoints achieve an exact match, while the new ChatGPT translation marker is present and the old translation marker has disappeared.

Results:

Plaintext
welcome      exact=True
basics       exact=True
flowcontrol  exact=True
moretypes    exact=True
methods      exact=True
generics     exact=True
concurrency  exact=True

Final:

Plaintext
Origin/Public exact match : 7/7

This step is more important than “access is normal.”

It proves:

The 7 articles returned by the EdgeOne public network are completely identical to the new production origin currently running.

Therefore, there is no:

Plaintext
origin has been updated
But CDN still returns old article

Such situation.

6. Using a set of new and old translation markers for intuitive confirmation

Exact Match is already strong byte-level evidence.

But to make the result more intuitive, I also picked a sentence from the official translation that changed in this round as a marker.

The new ChatGPT version contains:

Plaintext
每个 Go 程序都是由包组成的。

While the previous version used:

Plaintext
每个 Go 程序都由包构成。

Final public network check:

Plaintext
New ChatGPT marker : True
Old translation    : False

That is to say:

The public network indeed shows the new ChatGPT translation, and the corresponding sentence from the old version no longer exists.

This item, combined with the previous:

Plaintext
7/7 exact match

Essentially eliminates the doubt of “are we still looking at stale cache.”

7. With pages and translations normal, we still need to continue verifying Run

A Tour of Go is not a purely static tutorial.

Users can directly run the example code on the right side.

So if I only check:

Plaintext
Lesson pages normal
Translation normal

But:

Plaintext
Run is broken

It still cannot be considered a complete production validation.

Therefore, this time I continued to send a code execution request to the real Playground proxy.

Figure 4: Final production validation actually executing Run and Format. Both return HTTP 200, JSON responses are valid, Run gets the expected ONLINE_RUN_OK, and Format also successfully returns the formatted code.
Figure 4: Final production validation actually executing Run and Format. Both return HTTP 200, JSON responses are valid, Run gets the expected ONLINE_RUN_OK, and Format also successfully returns the formatted code.

Run:

Plaintext
Run HTTP         : 200
Run JSON valid   : True
Run errors empty : True
ONLINE_RUN_OK    : True

This is not just requesting a health check URL.

It is actually submitting:

Go
package main

func main() {
	println("ONLINE_RUN_OK")
}

And confirming that the response actually contains:

Plaintext
ONLINE_RUN_OK

Therefore, it can be confirmed:

The public network code execution chain is still normal.

8. Format also completes a real request

Next, I continued testing Format:

Plaintext
Format HTTP         : 200
Format JSON valid   : True
Format errors empty : True
ONLINE_FMT_OK       : True
Formatted func      : True

The input intentionally used unformatted code:

Go
package main;func main(){println("ONLINE_FMT_OK")}

The final response confirmed the presence of the normalized:

Go
func main() {

This shows that Format is not a case of “the API returned 200 but didn’t actually work.”

Rather, it has actually completed the code formatting.

At this point:

Plaintext
Pages
Translations
Run
Format

All four main user-visible layers have passed real public network validation.

9. Why an EdgeOne full-site cache purge was not performed this time

This round of release also has a slightly different aspect from before.

After the deployment was completed, I did not immediately execute a:

EdgeOne full-site cache purge.

I had previously encountered issues with /tour/script.js caching old versions, so initially I was a bit worried:

Will the new 103-page translation still be blocked by EdgeOne’s old cache?

But this final validation has directly proven:

Plaintext
Origin/Public exact match : 7/7

So if no stale content is found, executing another full-site purge is actually unnecessary.

Subsequently, I checked the cache response headers of different URLs.

Figure 5: EdgeOne cache Age is not consistent across different URLs. The homepage and tour/script.js have had HIT for a long time, while the lesson URLs just accessed in this round have an Age of only a few seconds, indicating that different URLs form their cache states independently, and the public validation itself may also complete re-fetching from the origin and cache warming for some URLs.
Figure 5: EdgeOne cache Age is not consistent across different URLs. The homepage and tour/script.js have had HIT for a long time, while the lesson URLs just accessed in this round have an Age of only a few seconds, indicating that different URLs form their cache states independently, and the public validation itself may also complete re-fetching from the origin and cache warming for some URLs.

For example, the homepage:

Plaintext
age: 54712
eo-cache-status: HIT

tour/script.js:

Plaintext
cache-control: max-age=604800
age: 54709
eo-cache-status: HIT

But the one just involved in the validation:

Plaintext
/tour/basics/1

Only has:

Plaintext
age: 4
eo-cache-status: HIT

And:

Plaintext
/tour/lesson/basics

Also only has:

Plaintext
age: 13
eo-cache-status: HIT

This phenomenon is very interesting.

It shows:

EdgeOne does not have a unified cache state where the entire site is either all old or all new.

Each URL can have its own cache lifecycle.

10. For low-traffic sites, the validation itself might be completing cache warming

A Tour of Go currently has very low traffic.

This means that before deployment, an EdgeOne node very likely did not pre-cache all 103 lesson URLs at all.

Performing the following after the release is complete:

Plaintext
103/103 public validation

Will itself access all lesson URLs.

For URLs that were not cached before, the actual process very likely becomes:

Plaintext
First validation access
↓
EdgeOne MISS
↓
Fetches from the new production release origin
↓
Returns new content
↓
Writes to EdgeOne cache
↓
Subsequent accesses become HIT

So in this low-traffic phase, the public validation itself might simultaneously undertake a part of:

cache warming.

This also explains why later checking:

Plaintext
/tour/basics/1
/tour/lesson/basics

they were already:

Plaintext
HIT

But:

Plaintext
Age

Was only a few seconds.

11. “Full-site purge” will no longer be the default action for every release

This time, a release habit more suitable for the current project was finally formed:

Plaintext
Deploy
↓
Origin validation
↓
Public validation
↓
Exact-match / marker validation
↓
If stale URL found
    → targeted purge
Otherwise
    → no proactive purge

Compared to:

Plaintext
Every release
↓
Unconditionally purge full-site cache

This approach makes it easier to know:

Whether the cache has actually caused a problem.

If the cache is purged every time after deployment regardless of the actual situation, it is actually very difficult to observe the CDN’s original behavior.

And this time it恰好 proves:

Even without executing a full-site purge, the public network has still completely returned the new ChatGPT release.

So going forward, I am more inclined to:

Validate first, and only perform a targeted purge after finding a specific stale URL.

Rather than treating a CDN purge as a fixed component of deployment.

12. Final validation results

At this point, the final layer of validation for this round of ChatGPT zh-CN re-translation is also complete.

The final summary is:

Plaintext
Official production release
20260818-zh-CN-45f4cad
        ↓
service active
origin HTTP 200
public HTTP 200
        ↓
Core entry points all 200
        ↓
103/103 official lesson routes HTTP 200
        ↓
7/7 article
Origin/Public exact match
        ↓
New ChatGPT marker = True
Old translation    = False
        ↓
Run = 200 / ONLINE_RUN_OK
Format = 200 / ONLINE_FMT_OK
        ↓
/socket = 404
        ↓
No EdgeOne full-site purge required

This also means that from the very beginning of re-evaluating the translation approach up to now, the entire chain has finally truly closed:

Plaintext
Translation Engine experiment
↓
Select ChatGPT
↓
103-page full re-translation
↓
Semantic quality review
↓
A=103
↓
Canonical Promotion
↓
Official Production Release
↓
Production deployment
↓
103/103 public validation
↓
7/7 Exact Match
↓
Run / Format actual verification

The previous two articles resolved:

Whether the new translation is good enough, and how to safely enter the official repository.

This article resolves the last question:

How to prove that what users are accessing from the public network right now is truly the new ChatGPT translation officially released in this round.

Now this answer is available:

103/103 normal, 7/7 exact match, new translation present, old translation gone, Run and Format all passed.

With this, this round of full re-translation for the 103 pages of A Tour of Go in Simplified Chinese using ChatGPT can be officially wrapped up.

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

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

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

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

关于我  ·  GitHub  ·  邮件联系