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:
A = 103
B/C/D = 0Based 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:
production release
↓
Production deployment
↓
Currently running release
↓
origin
↓
EdgeOne
↓
Public responseIf 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.

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:
current release :
/data/go-tour/releases/20260818-zh-CN-45f4cadCorresponding manifest:
locale : zh-CN
published_at : 2026-08-18T13:22:48Z
pages : 103
articles : 7
transport : http-playground-proxy
local socket : FalseAlso:
service : active
origin HTTP : 200
public HTTP : 200This step first proves:
The currently running production version has indeed been switched to the new official release generated in this round.
Instead of:
Code commit successful
But current still points to old releaseOr:
current has switched
But go-tour.service is not running normallyIt can also be confirmed that:
local socket : FalseMeaning 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:
curl https://go-dev.shuijingwanwq.com/And get:
HTTP 200This 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.

Core entry points:
/ 200
/tour/ 200
/tour/list 200
/robots.txt 200
/sitemap.xml 200
/tour/script.js 200Official lesson routes:
Formal course routes : 103
HTTP 200 : 103
Failed : 0That is:
103 / 103All 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:
Whether URLs that should succeed do succeedIt should also confirm:
Whether any URLs that should not be public have been accidentally restored by this releaseFinal check:
/socket → 404
/socket/anything → 404
/_/share → 404These 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:
Browser
↓
play.go-dev.shuijingwanwq.com
↓
Independent Playground proxyNot:
Browser
↓
Main site /socket
↓
Local code executionTherefore:
/socket → 404Is 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:
103/103 HTTP 200Actually still does not fully answer the most important question in this article.
Because the CDN can experience the following situation:
Production origin has been updated
↓
EdgeOne still holds old cache
↓
User access still returns 200
↓
But receives the previous version's contentSo simply having:
HTTP 200Cannot 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:
welcome
basics
flowcontrol
moretypes
methods
generics
concurrencyThese 7 articles ultimately make up all 103 official lesson pages.
Therefore, I separately fetched:
Production origin
http://127.0.0.1:3999/tour/lesson/<article>And:
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.

Results:
welcome exact=True
basics exact=True
flowcontrol exact=True
moretypes exact=True
methods exact=True
generics exact=True
concurrency exact=TrueFinal:
Origin/Public exact match : 7/7This 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:
origin has been updated
But CDN still returns old articleSuch 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:
每个 Go 程序都是由包组成的。While the previous version used:
每个 Go 程序都由包构成。Final public network check:
New ChatGPT marker : True
Old translation : FalseThat 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:
7/7 exact matchEssentially 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:
Lesson pages normal
Translation normalBut:
Run is brokenIt still cannot be considered a complete production validation.
Therefore, this time I continued to send a code execution request to the real Playground proxy.

ONLINE_RUN_OK, and Format also successfully returns the formatted code.Run:
Run HTTP : 200
Run JSON valid : True
Run errors empty : True
ONLINE_RUN_OK : TrueThis is not just requesting a health check URL.
It is actually submitting:
package main
func main() {
println("ONLINE_RUN_OK")
}And confirming that the response actually contains:
ONLINE_RUN_OKTherefore, 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:
Format HTTP : 200
Format JSON valid : True
Format errors empty : True
ONLINE_FMT_OK : True
Formatted func : TrueThe input intentionally used unformatted code:
package main;func main(){println("ONLINE_FMT_OK")}The final response confirmed the presence of the normalized:
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:
Pages
Translations
Run
FormatAll 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:
Origin/Public exact match : 7/7So if no stale content is found, executing another full-site purge is actually unnecessary.
Subsequently, I checked the cache response headers of different URLs.

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:
age: 54712
eo-cache-status: HITtour/script.js:
cache-control: max-age=604800
age: 54709
eo-cache-status: HITBut the one just involved in the validation:
/tour/basics/1Only has:
age: 4
eo-cache-status: HITAnd:
/tour/lesson/basicsAlso only has:
age: 13
eo-cache-status: HITThis 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:
103/103 public validationWill itself access all lesson URLs.
For URLs that were not cached before, the actual process very likely becomes:
First validation access
↓
EdgeOne MISS
↓
Fetches from the new production release origin
↓
Returns new content
↓
Writes to EdgeOne cache
↓
Subsequent accesses become HITSo in this low-traffic phase, the public validation itself might simultaneously undertake a part of:
cache warming.
This also explains why later checking:
/tour/basics/1
/tour/lesson/basicsthey were already:
HITBut:
AgeWas 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:
Deploy
↓
Origin validation
↓
Public validation
↓
Exact-match / marker validation
↓
If stale URL found
→ targeted purge
Otherwise
→ no proactive purgeCompared to:
Every release
↓
Unconditionally purge full-site cacheThis 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:
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 requiredThis also means that from the very beginning of re-evaluating the translation approach up to now, the entire chain has finally truly closed:
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 verificationThe 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.
