2025-04-19 11:26:39
本文永久链接 – https://tonybai.com/2025/04/19/learn-go-in-ai-era
大家好！我是Tony Bai。
近来，AI领域的技术迭代速度惊人，尤其在代码生成能力上的显著提升，已有目共睹。现在，AI不仅能辅助编写Go代码片段，还能应对一些更复杂的逻辑结构，甚至还能完成一个完整工程的全部代码，这在开发者社区无疑引发了热烈讨论和对未来的思考。对于初学者来说，一个现实的问题摆在面前：我们还需要老老实实、一步一个脚印地去系统学习吗？比如像《Go语言第一课》专栏这样的系统课程还有必要去学吗？
这个问题确实值得我们认真思考。AI的便捷是显而易见的，但它能帮助我们构建起真正的专业能力吗？
如今，一个普遍的认知是，AI更像是一个能力的放大器，它能够增强你已有的知识和技能，但却很难从零开始为你构建坚实的基础。依赖于碎片化的AI交互，我们或许能快速“上手”，但要真正“掌握”某个领域，成为一名专业人士，可能还有很长的路要走。
那么，在AI时代，系统学习能为渴望成长的你，尤其是初学者，提供哪些不可替代的价值呢？ 我觉得至少有如下几点：
AI能帮你生成代码片段，但这就像给你一堆散落的乐高积木。系统学习则教你如何将它们搭建成一个完整的城堡。
初学一门语言，最怕的就是知识点零散、不成体系。以Go学习为例，系统课程精心编排了学习路径，覆盖了环境搭建、基础语法、核心特性(接口、并发等)到简单实践。
它就像一张清晰的地图，引导你系统性地认识Go的世界，为你提供“一站式”的基础构建服务，避免在碎片信息中迷失方向，让起步更高效、更稳固。
还是以Go学习为例，系统的课程学习不仅仅是知道“怎么做”，也会适时地告诉你一些“为什么”。比如了解Go的设计哲学（简洁、显式、组合、面向并发等），理解某些特性（如接口设计）背后的考量。
这并非要求初学者一开始就深究底层，而是像《认知觉醒》一书里说的，帮助你适度地拓展“舒适区”，进入能获得更快提升的“拉伸区”。
理解了这些，你会发现自己应用起来更灵活，学习新知识也更快，整体学习效率自然更高。这是一种更高效的学习方式。
AI能写出代码，但判断代码的好坏、进行复杂调试、做出架构决策，这些都需要你具备扎实的专业基础。
系统学习正是帮你奠定这个基础，让你未来能有效地指导和评估AI写出的代码，而不是仅仅停留在简单地复制粘贴，甚至让AI生成一堆你自己都看不懂、无法评估好坏的代码，这样的代码一旦上生产可能带来潜在的风险和隐患。
只有足够专业，你才能有效地向AI提问，辨别AI答案的优劣，最终驾驭AI，让它成为你专业能力的延伸，而非被其能力所取代。碎片化的学习，是无法构建起这种专业壁垒的。而系统的课程学习，正是你迈向专业之路的第一块、也是至关重要的基石。
网络信息真假难辨，AI的回答也可能存在谬误。对于初学者来说，一开始接触到准确、可靠的信息至关重要。
一门好的课程，其内容是经过作者和编辑团队反复打磨、验证和审校的，源自大量实践和教学经验，确保了其准确性和权威性。它为你提供了一个可以信赖的学习起点和参照系，这本身就是一种重要的学习服务。
所以，回到最初的问题：AI会写Go代码了，初学者还需要系统学习吗？
我的答案是：如果你不满足于“能用”，而是渴望真正“掌握”Go，渴望成为一名具备深度思考和解决复杂问题能力的Gopher，那么，系统学习依然是必经之路。
而《Go语言第一课》，这门我在极客时间打磨许久的专栏，正是基于上述理念设计的。它专注于为你铺设一条清晰、可靠、高效的Go入门之路，帮助你从“知道”走向“理解”，为未来成长为一名专业的Gopher奠定基础。
如果你正准备开始学习Go，或者希望巩固基础、构建体系，可以扫描下方二维码，订阅《Go语言第一课》专栏，为你的Go专业之路，打下第一个坚实桩基！，你也可以与其他订阅和学习该专栏的数万Gopher一起交流学习心得，共享学习成果。
最后补充一点信息： 为了让课程能更好地服务大家，最近我和极客时间的编辑老师一起，为《Go语言第一课》做了一次重要的课程迭代，增加了6篇“加餐”内容，涉及测试、性能、I/O、语言新特性等，希望能为你的学习之路提供一些额外的助力。当然，课程的核心价值，始终在于主体内容所构建的那个系统化的入门基础。
现在，轮到你了：作为Go学习者（特别是初学者），你如何看待AI对学习的影响？你认为系统学习最大的价值是什么？欢迎在评论区分享你的想法，我们一起探讨！如果觉得这篇文章说到了你的心坎里，请点个“在看**”支持一下吧！
愿我们都能拥抱AI，但不忘构建自身的专业核心！
原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！
我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：
衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！
著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格6$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。
Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com
我的联系方式：
商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。
© 2025, bigwhite. 版权所有.
2025-04-18 06:52:21
本文永久链接 – https://tonybai.com/2025/04/18/reproduce-thorsten-balls-code-agent
大家好，我是Tony Bai。
人工智能Agent风头正劲，但构建它们真的那么难吗？本文深入解读Thorsten Ball 的“皇帝新衣”论，并通过一个 Go 标准库 + OpenAI Compatible API + DeepSeek的实战复现，揭示代码编辑 Agent 的核心简洁性，探讨真正的挑战与机遇。
近来，AI Agent（人工智能代理）无疑是技术圈最炙手可热的话题之一。从能自主编码的软件工程师，到能规划执行复杂任务的智能助手，Agent 展现出的潜力令人兴奋。但与此同时，它们往往被一层神秘的光环笼罩，许多人觉得构建一个真正能工作的 Agent，尤其是能与代码交互、编辑文件的 Agent，必然涉及极其复杂的技术和深不可测的“炼金术”。
事实果真如此吗？Agent 的核心真的那么难以企及吗？
著名开发者、“Writing A Compiler In Go”和“Writing An Interpreter In Go”两本高质量大作的作者Thorsten Ball最近发表了一篇振聋发聩的文章——《How To Build An Agent》（如何构建一个Agent），副标题更是直言不讳：“The Emperor Has No Clothes”（皇帝没有穿衣服）。
Thorsten 的核心观点非常清晰：构建一个功能齐全、能够编辑代码的 Agent，其核心原理并不神秘，甚至可以说没有所谓的“护城河”。他认为，那些看似神奇的 Agent（自动编辑文件、运行命令、从错误中恢复、尝试不同策略）背后并没有什么惊天秘密。
其核心不过是：一个强大的大语言模型 (LLM) + 一个循环 (Loop) + 足够的上下文额度 (Tokens) + 工具调用 (Tools)。
而那些让Agent产品（如Cursor等）令人印象深刻、甚至上瘾的特性，更多来自于务实的工程实践和大量的“体力活” (Elbow Grease)——UI 设计、编辑器集成、错误处理、提示词工程、工具链优化等等。
为了证明核心逻辑的简单性，Thorsten 在文章中手把手地用不到 400 行 Go 代码，基于Anthropic Claude模型和其Go SDK，实现了一个具备基本代码编辑能力的Agent Demo。这个Demo 包含了三个关键的工具：
就是这样一个看似“简陋”的Agent，却能在实验中成功完成创建JavaScript文件、修改代码逻辑、解码字符串等任务，展现了自主规划和调用工具的能力。
Thorsten 的文章和示例极具启发性。但为了进一步验证其观点的普适性(其实主要是我没有Claude的API key)——即这种 Agent 的核心逻辑是否独立于特定的 LLM 提供商或 SDK——我们进行了一项挑战：
在不使用任何第三方 LLM SDK 的情况下，仅依靠Go标准库 (net/http, encoding/json 等)，将 Thorsten 的示例移植到使用通用的 OpenAI Compatible API(主要是Chat Completions API)。
这意味着我们需要：
经过一番努力，我们成功了！这个纯标准库版本的 Go Agent 不仅编译通过，而且完美地复现了 Thorsten 文章中的所有实验，无论是文件读写、列表，还是代码创建与修改，其行为和效果与原版几乎一致。
这有力地证明了：代码 Agent 的核心交互范式（请求 -> LLM 思考/工具调用 -> 执行工具 -> 返回结果 -> LLM 再思考…）确实是通用的，不依赖于特定的 SDK 或 API 提供商。 掌握了底层的 HTTP 通信和 API 协议规范，用任何语言、任何网络库都可以构建类似的核心。
理论和别人的成功固然鼓舞人心，但亲手实践才能带来最真切的感受。“纸上得来终觉浅，绝知此事要躬行”。下面，我们将结合关键代码片段，指导你一步步复现这个使用 Go 标准库和 OpenAI Compatible API 构建的代码编辑 Agent 实验。
(注意：你需要准备一个 OpenAI API Key 或其他兼容 OpenAI API 的服务商提供的 Key 和 Endpoint，我这里使用的是兼容OpenAI API的DeepSeek的deepseek-chat大模型。此外，这里展示的是关键代码片段，完整代码请参考code-editing-agent-deepseek)
准备工作:
$export OPENAI_API_KEY=<your_deepseek_api_key>
$export OPENAI_API_BASE=https://api.deepseek.com
$export OPENAI_MODEL=deepseek-chat
// Simplified flow within Agent.Run for basic chat
func (a *Agent) Run(ctx context.Context) error {
// ... setup ...
conversation := []OpenAIChatCompletionMessage{ /* system prompt */ }
for { // Outer loop for user input
// ... get userInput from console ...
conversation = append(conversation, OpenAIChatCompletionMessage{Role: "user", Content: userInput})
// --- Call API ---
resp, err := a.callOpenAICompletion(ctx, conversation)
if err != nil {
fmt.Printf("\u001b[91mAPI Error\u001b[0m: %s\n", err.Error())
continue // Let user try again
}
if len(resp.Choices) == 0 { /* handle no choices */ continue }
assistantMessage := resp.Choices[0].Message
conversation = append(conversation, assistantMessage) // Add response to history
// --- Print Text Response ---
if assistantMessage.Content != "" {
fmt.Printf("\u001b[93mAI\u001b[0m: %s\n", assistantMessage.Content)
}
// --- Tool Handling Logic would go here, but skipped for basic chat ---
// In a basic chat without tool calls, the inner loop (if any) breaks immediately.
} // End of outer loop
return nil
}
步骤:
在 You: 提示符后输入：
You: Hey! I'm Tony! How are you?
观察 AI 是否能正常回复，确认 API 连接。
Agent输出:
$./agent
Chat with AI (use 'ctrl-c' to quit)
You: Hey! I'm Tony! How are you?
AI: Hi Tony! I'm just a program, so I don't have feelings, but I'm here and ready to help you with anything you need. How can I assist you today?
工具定义 (ReadFileDefinition): 告诉AI 有一个名为 read_file 的工具，它需要一个path参数，并描述了其功能。
type ReadFileInput struct { // Defines the input structure for the tool
Path string json:"path" jsonschema_description:"The relative path..." jsonschema:"required"
}
var ReadFileDefinition = ToolDefinition{
Name: "read_file",
Description: "Read the contents of a given relative file path...",
InputSchema: GenerateSchema[ReadFileInput](), // Generates {"type": "object", "properties": {"path": {"type": "string", ...}}, "required": ["path"]}
Function: ReadFile, // Links to the Go function below
}
工具执行函数 (ReadFile): 这个 Go 函数接收 AI 提供的参数（文件路径），并使用标准库 os.ReadFile 实际执行文件读取。
func ReadFile(input json.RawMessage) (string, error) {
readFileInput := ReadFileInput{}
err := json.Unmarshal(input, &readFileInput) // Parse the JSON arguments from AI
if err != nil || readFileInput.Path == "" { /* handle parse error or missing path */ }
content, err := os.ReadFile(readFileInput.Path) // Use Go standard library to read file
if err != nil { /* handle file read error */ }
return string(content), nil // Return file content as a string
}
You: buddy, help me solve the riddle in the secret-file.txt file
Tool Call: list_files({})
Tool Call: read_file({"path":"secret-file.txt"})
AI: The answer to the riddle is a **horse**, because it always says "neigh" (which sounds like "nay," meaning disagreement).
Let me know if you need help with anything else, Tony!
You: What's going on in main.go? Be brief!
Tool Call: read_file({"path":"main.go"})
AI: The `main.go` file is a Go program that sets up an **AI agent** capable of interacting with the local filesystem (reading, listing, and editing files). Here's a brief breakdown:
1. **Purpose**:
- The agent acts as a helper, responding to user requests by either providing text answers or using tools to interact with files.
2. **Key Features**:
- **Tools**: It has three built-in tools:
- `read_file`: Reads file contents.
- `list_files`: Lists files/directories.
- `edit_file`: Edits or creates files.
- **OpenAI Integration**: Uses the OpenAI API (like GPT-4) to process user input and decide when to use tools.
- **Interactive CLI**: Takes user input from the command line and displays responses.
3. **Workflow**:
- The agent maintains a conversation history with the user.
- If a tool is needed, it calls the OpenAI API, executes the tool, and updates the conversation.
4. **Dependencies**:
- Requires an `OPENAI_API_KEY` environment variable to work with the OpenAI API.
In short, it's a **file-system assistant powered by OpenAI**, designed to help with file operations via natural language commands. Let me know if you'd like more details!
工具定义 (ListFilesDefinition): 定义 list_files 工具，路径参数可选。
type ListFilesInput struct { // Input structure, path is optional
Path string json:"path,omitempty" jsonschema_description:"Optional relative path..."
}
var ListFilesDefinition = ToolDefinition{
Name: "list_files",
Description: "List files and directories at a given path. If no path...",
InputSchema: GenerateSchema[ListFilesInput](),
Function: ListFiles, // Links to the Go function below
}
工具执行函数 (ListFiles): 使用 filepath.WalkDir 遍历目录，并将结果格式化为 JSON 数组字符串。
func ListFiles(input json.RawMessage) (string, error) {
// ... Parse optional path from input ...
dir := "." // Default to current directory
if listFilesInput.Path != "" { dir = listFilesInput.Path }
var files []string
err := filepath.WalkDir(dir, func(...) error { // Use standard library WalkDir
// ... build relative path ...
// ... append path to files slice (add "/" for directories) ...
return nil
})
if err != nil { /* handle walk error */ }
result, err := json.Marshal(files) // Return as JSON array string
if err != nil { /* handle marshal error */ }
return string(result), nil
}
You: what do you see in this directory?
Tool Call: list_files({})
AI: Here’s what’s in the current directory:
1. **Files**:
- `.main.go.swp` (likely a temporary swap file for `main.go`).
- `go.mod` and `go.sum` (Go module files for dependency management).
- `main.go` (the main Go program file).
- `secret-file.txt` (the file with the riddle you solved earlier).
2. **Directory**:
- `agent/` (a subdirectory, possibly containing agent-related code or resources).
Let me know if you'd like to explore any of these further!
// Inside Agent.Run method
for { // Outer loop for user input
// ... get user input, add to conversation ...
for { // <--- INNER LOOP: Handles multi-turn tool calls ---
resp, err := a.callOpenAICompletion(ctx, conversation) // Call API
// ... handle response ...
assistantMessage := resp.Choices[0].Message
conversation = append(conversation, assistantMessage) // Add assistant's response
// Check for tool calls in the response
if len(assistantMessage.ToolCalls) == 0 {
// No tools called by AI in this turn. Print text response (if any)
// and break the INNER loop to wait for next user input.
if assistantMessage.Content != "" { /* print content */ }
break // Exit INNER loop
}
// --- AI requested tools, execute them ---
toolResults := []OpenAIChatCompletionMessage{}
for _, toolCall := range assistantMessage.ToolCalls {
// ... find tool definition by toolCall.Function.Name ...
// ... execute the tool's Go function with toolCall.Function.Arguments ...
// ... prepare resultMsg (role: "tool", content: output/error) ...
toolResults = append(toolResults, resultMsg)
}
conversation = append(conversation, toolResults...) // Add tool results to history
// DO NOT BREAK! Continue the INNER loop immediately.
// The conversation now includes the tool results,
// so the next call to callOpenAICompletion will send them back to the AI.
} // <--- End of INNER LOOP ---
} // End of OUTER loop
解释: 关键在于内部循环 (INNER LOOP)。当 AI 的回复包含 ToolCalls 时，Agent 会：
步骤 (实验 4 – Go 文件信息):
You: Tell me about all the Go files in here. Be brief!
AI: Here’s a quick rundown of the Go files in the directory:
1. **`main.go`**:
- The core program file. It sets up an **AI agent** that interacts with the local filesystem using tools (`read_file`, `list_files`, `edit_file`).
- Integrates with the **OpenAI API** for natural language processing.
- Handles user input via the command line.
2. **`go.mod` & `go.sum`**:
- **`go.mod`**: Defines the Go module (project) and its dependencies (e.g., `github.com/invopop/jsonschema` for JSON schema generation).
- **`go.sum`**: Locks dependency versions for reproducibility.
That’s it! The other files (like `.main.go.swp`) are temporary or non-Go files. Let me know if you want details on any specific part!
注意：这里DeepSeek模型并没有再调用read_file！与预期不相符，也许和模型的实现有关。比如模型缓存了这些文件的内容。
You: What go version are we using in this project?
Tool Call: read_file({"path":"go.mod"})
AI: The project is using **Go version 1.24.0**, as specified in the `go.mod` file.
Let me know if you'd like help with anything else!
工具定义 (EditFileDefinition): 定义 edit_file 工具，包含 path, old_str, new_str 三个参数。
type EditFileInput struct {
Path string json:"path" jsonschema_description:"The path..." jsonschema:"required"
OldStr string json:"old_str" jsonschema_description:"Text to search for..."
NewStr string json:"new_str" jsonschema_description:"Text to replace with..." jsonschema:"required"
}
var EditFileDefinition = ToolDefinition{
Name: "edit_file",
Description: "Make edits to a text file. Replaces ALL occurrences...",
InputSchema: GenerateSchema[EditFileInput](),
Function: EditFile, // Links to the Go function below
}
工具执行函数 (EditFile 及助手 createNewFile): 处理文件创建和修改逻辑。
func EditFile(input json.RawMessage) (string, error) {
editFileInput := EditFileInput{}
// ... parse input path, old_str, new_str ...
content, err := os.ReadFile(editFileInput.Path)
if err != nil {
// Key logic: If file doesn't exist AND old_str is empty, try creating it.
if os.IsNotExist(err) && editFileInput.OldStr == "" {
return createNewFile(editFileInput.Path, editFileInput.NewStr)
}
return "", err // Other read error
}
// File exists, perform replacement
oldContent := string(content)
newContent := strings.Replace(oldContent, editFileInput.OldStr, editFileInput.NewStr, -1) // Replace all
// ... check if replacement happened ...
err = os.WriteFile(editFileInput.Path, []byte(newContent), 0644) // Write back
// ... handle write error ...
return "OK", nil
}
// Helper to create a new file (and parent directories if needed)
func createNewFile(filePath, content string) (string, error) {
dir := path.Dir(filePath)
if dir != "." && dir != "" {
// Ensure parent directories exist
if err := os.MkdirAll(dir, 0755); err != nil { /* handle error */ }
}
err := os.WriteFile(filePath, []byte(content), 0644) // Write the new file
// ... handle error ...
return fmt.Sprintf("Successfully created file %s", filePath), nil
}
解释: edit_file 是最强大的工具。AI 根据用户的意图（创建或修改）来调用它，并提供必要的参数。Go 代码的核心逻辑在于：
步骤 (实验 6 – 创建):
You: hey buddy, create fizzbuzz.js that I can run with Nodejs and that has fizzbuzz in it and executes it
Tool Call: edit_file({"path":"fizzbuzz.js","old_str":"","new_str":"// FizzBuzz in Node.js\nfunction fizzbuzz(n) {\n for (let i = 1; i <= n; i++) {\n if (i % 15 === 0) console.log(\"FizzBuzz\");\n else if (i % 3 === 0) console.log(\"Fizz\");\n else if (i % 5 === 0) console.log(\"Buzz\");\n else console.log(i);\n }\n}\n\n// Execute FizzBuzz for numbers 1 to 100\nfizzbuzz(100);"})
AI: Done! I've created **`fizzbuzz.js`** with a FizzBuzz implementation that runs in Node.js. Here's what it does:
1. **Function**:
- `fizzbuzz(n)` prints numbers from 1 to `n`, replacing multiples of 3 with "Fizz", multiples of 5 with "Buzz", and multiples of both with "FizzBuzz".
2. **Execution**:
- It runs for numbers **1 to 100** by default.
### How to Run:
node fizzbuzz.js
Let me know if you'd like any tweaks!
生成的fizzbuzz.js的文件内容如下：
$cat fizzbuzz.js
// FizzBuzz in Node.js
function fizzbuzz(n) {
for (let i = 1; i <= n; i++) {
if (i % 15 === 0) console.log("FizzBuzz");
else if (i % 3 === 0) console.log("Fizz");
else if (i % 5 === 0) console.log("Buzz");
else console.log(i);
}
}
// Execute FizzBuzz for numbers 1 to 100
fizzbuzz(100);%
使用node运行该fizzbuzz.js的文件，输出如下：
$node fizzbuzz.js
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
... ...
97
98
Fizz
Buzz
You: Please edit fizzbuzz.js so that it only prints until 15
Tool Call: edit_file({"path":"fizzbuzz.js","old_str":"// Execute FizzBuzz for numbers 1 to 100\nfizzbuzz(100);","new_str":"// Execute FizzBuzz for numbers 1 to 15\nfizzbuzz(15);"})
AI: Got it! I updated **`fizzbuzz.js`** to print FizzBuzz only up to **15** instead of 100.
### How to Run:
node fizzbuzz.js
Now it’ll output:
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
Let me know if you'd like further changes!
查看更新后的fizzbuzz.js：
$cat fizzbuzz.js
// FizzBuzz in Node.js
function fizzbuzz(n) {
for (let i = 1; i <= n; i++) {
if (i % 15 === 0) console.log("FizzBuzz");
else if (i % 3 === 0) console.log("Fizz");
else if (i % 5 === 0) console.log("Buzz");
else console.log(i);
}
}
// Execute FizzBuzz for numbers 1 to 15
fizzbuzz(15);%
运行更新后的fizzbuzz.js结果如下：
$node fizzbuzz.js
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
You: Create a congrats.js script that rot13-decodes the following string 'Pbatenghyngvbaf ba ohvyqvat n pbqr-rqvgvat ntrag!' and prints it
AI: Here's the plan:
1. I'll create a **`congrats.js`** script.
2. It will **ROT13-decode** the string `'Pbatenghyngvbaf ba ohvyqvat n pbqr-rqvgvat ntrag!'`.
3. The decoded result will be printed to the console.
Let me implement this for you.
Tool Call: edit_file({"path":"congrats.js","old_str":"","new_str":"// ROT13 decoder in Node.js\nfunction rot13(str) {\n return str.replace(/[a-zA-Z]/g, function(c) {\n const base = c <= 'Z' ? 65 : 97;\n return String.fromCharCode((c.charCodeAt(0) - base + 13) % 26 + base);\n });\n}\n\n// Encoded string\nconst encoded = 'Pbatenghyngvbaf ba ohvyqvat n pbqr-rqvgvat ntrag!';\n\n// Decode and print\nconsole.log(rot13(encoded));"})
AI: Done! I've created **`congrats.js`** for you. Here's what it does:
1. **ROT13 Decoding**:
- The script decodes the string `'Pbatenghyngvbaf ba ohvyqvat n pbqr-rqvgvat ntrag!'` using ROT13.
2. **Output**:
- Running it will print the decoded message to the console.
### How to Run:
node congrats.js
The decoded result should appear. Let me know if you'd like to tweak anything!
查看生成的congrats.js结果如下：
$cat congrats.js
// ROT13 decoder in Node.js
function rot13(str) {
return str.replace(/[a-zA-Z]/g, function(c) {
const base = c <= 'Z' ? 65 : 97;
return String.fromCharCode((c.charCodeAt(0) - base + 13) % 26 + base);
});
}
// Encoded string
const encoded = 'Pbatenghyngvbaf ba ohvyqvat n pbqr-rqvgvat ntrag!';
// Decode and print
console.log(rot13(encoded));%
运行生成的congrats.js结果如下：
$node congrats.js
Congratulations on building a code-editing agent!
通过这些结合了代码片段和解释的步骤，你应该能更清晰地理解 Agent 在每个实验中是如何利用其被赋予的工具和核心循环机制来完成任务的。这再次印证了 Thorsten Ball 的观点：核心很简单，但组合起来却能产生强大的效果。
既然核心逻辑相对简单，那是否意味着构建一个优秀的 Agent 应用就没有门槛了呢？显然不是。Thorsten Ball 的“体力活” (Elbow Grease) 一词点醒了我们：真正的挑战和壁垒，在于核心逻辑之外的大量工程细节和产品打磨。
这包括但不限于：
这些才是构建一个能在现实世界中可靠、高效、安全地工作的 Agent 应用时，需要投入大量时间和精力去解决的真正工程难题。未来的 Agent 应用竞争，很可能就围绕着这些方面展开。
Thorsten Ball 的文章和我们的复现实验，共同揭示了一个令人兴奋的事实：理解和开始构建 AI Agent 的门槛，比许多人想象的要低得多。 其核心概念是清晰且可及的。
这并不意味着打造卓越的 Agent 产品很容易，但它确实意味着，任何具备基本编程能力和对 LLM API 有所了解的开发者，都可以动手尝试，去探索 Agent 的可能性。
不要被表面的复杂性所迷惑，正如“皇帝的新衣”所揭示的，有时最强大的能力隐藏在最简洁的原理背后。现在，轮到你去发现、去实践、去创造了。
鼓励大家亲自尝试运行和修改这个Go Agent示例，感受一下与“你自己创造的智能体”协作编码的初步体验！
想更进一步？开启你的 Go & AI 精进之旅！
本文为你揭示了构建代码 Agent 的核心简洁性，但这仅仅是冰山一角。真正的挑战在于将这些基础概念，通过扎实的工程实践，转化为可靠、高效、能在实际场景中创造价值的应用。
如果你渴望在这条激动人心的道路上走得更远、更深，希望系统性学习如何用Go构建AI原生应用，深入探索 Agent、RAG（检索增强生成）、模型集成、向量数据库应用等前沿实践，我强烈推荐我的知识星球「Gopher的AI原生应用开发第一课」。在这里，我们不只有理论探讨，更有动手实战项目、最新的技术趋势解读、活跃的高质量社群交流，以及与我的直接互动答疑。如果你对用 Go 在 AI 时代创造真正有影响力的应用充满热情，这里将是你的最佳实践场和加速器。
扫码加入「Go & AI 精进营」知识星球，开启你的 AI 原生开发之旅！ 并且，体系化Go核心进阶内容：「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，将帮助你夯实Go内功
你的支持，是创作的最大动力！
最后，如果你觉得本文对你有启发、有帮助：
感谢你的耐心阅读与宝贵支持！期待在学习的路上与你继续同行！
著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格6$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。
Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com
我的联系方式：
商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。
© 2025, bigwhite. 版权所有.
2025-04-17 21:30:56
本文永久链接 – https://tonybai.com/2025/04/17/go-is-badly-designed
大家好，我是Tony Bai。
今天刷X (前Twitter) 的时候，看到Golang Insiders社区下面这条推文，真是差点扑哧一声笑出来，感觉说得太形象了，必须分享给大家：
这位叫Lyes的开发者回应 “Go is badly designed” (Go 语言设计得很糟糕) 的说法，他打了个比方：
这让我想起了我的高中物理老师，我们当时都恨他，因为他从不‘放水’简化物理知识。课难、考试难，大部分人在他手下分数都不高，所以他自然成了‘坏老师’。
Go 语言就有点像他。它从不‘放水’，直面问题。你可以很快用它变得高效，写出远比用 Python 或 JavaScript 写得更好的软件。
但你也得知道，这门语言不会‘溺爱’你。当你的服务器因为一个 nil map 或其他新手常犯的错误而 panic 时，别生气。
不像 Rust，Go 的编译器不会在你编程生涯的每一刻都‘牵着你的手’。它会给你足够的方向让你知道该往哪走，满足你 80% 的需求，同时仍然保持你的生产力。
怎么样？看完这段话，是不是像极了我们初学Go时，被nil pointer dereference 或 index out of range 当头棒喝的瞬间？ 像极了我们当年一边抱怨物理老师太严格、考试太变态，一边又不得不硬着头皮去啃那些公式和定理的样子？
Lyes 的这个比喻，可以说精准地戳中了 Go 语言的一些核心特质，也解释了为什么关于“Go是否设计糟糕”的争论从未停止。咱们今天就借着这个“物理老师”的比喻，好好聊聊Go的“坏脾气”和它背后的设计哲学。
Lyes 说 Go 不会 “dumb down anything(简化任何事物，去除复杂性)”，这太对了。Go语言的设计哲学里，“简洁”（Simplicity） 是核心原则之一，但这不代表“简单化”到隐藏问题的程度。相反，它选择直面问题：
显式的错误处理 (if err != nil)：不像某些语言用try-catch将错误“藏”起来，Go强迫你几乎在每次可能出错的操作后都检查错误。这很“烦”，但它逼着你思考每一步潜在的风险，就像物理老师逼着你弄懂每个公式的推导过程。
直白的运行时Panic：当你对一个 nil 的 map 或 slice 进行操作时，Go 不会帮你“优雅地”处理，而是直接给你一个运行时 panic，程序崩溃。这很“粗暴”，但它用最直接的方式告诉你：“同学，你这里犯了个基础错误，赶紧改！” 这不就是物理老师发现你基本概念没搞懂时，直接点名批评，让你印象深刻吗？
没有“溺爱”的语法糖：相比一些现代语言，Go 的语法糖相对较少。它没有泛滥的操作符重载，没有复杂的隐式转换。很多事情需要你明确地写出来。这让代码有时候显得“啰嗦”，但大大降低了阅读和理解他人代码时的歧义，保证了大规模团队协作的效率。就像物理老师坚持用标准的符号和单位，不允许自创“简写”，是为了保证科学的严谨性。
我们当年可能都偷偷抱怨过物理老师不近人情，但多年后回想，是不是反而感谢他的严格，才让我们打下了坚实的基础？Go 语言的“严格”同样如此：
逼你养成好习惯：被 nil panic 搞崩溃几次后，你自然就学会了在使用 map/slice/pointer 前做检查，学会了初始化，学会了更严谨地思考边界条件。这种被“教训”出来的习惯，最终会融入你的编程血液，让你写出更健壮、更可靠的代码。这比那些“温柔”地帮你掩盖了问题，直到生产环境才爆发出更大危机的语言，是不是长期来看更负责任？
简单直白，易于掌握核心：虽然会“当头棒喝”，但Go的核心概念相对较少，语法简洁。一旦你掌握了它的规则（比如错误处理模式、接口哲学、goroutine的使用），就能快速上手，并且写出的代码风格差异不会太大，易于团队维护。它不像某些语言，特性繁多，学习曲线陡峭，精通需要漫长时间。Go就像物理老师划定的核心考点，虽然难，但范围明确，努力就有回报。
效率与务实：给你“80%的指引”：Lyes 提到了Go与Rust的对比，说Go不会“全程牵手”。这正是Go的务实之处。它在编译速度、开发效率和运行时安全之间做了一个取舍。它通过快速编译、垃圾回收、简洁的并发模型，让你能高效地构建系统，满足大部分（比如 80%）场景的需求。它相信开发者是成年人，应该为自己的代码负责，而不是让编译器承担所有检查的重任。这就像物理老师教会你核心原理和解题方法，但不会一步步带着你做完所有练习题，他相信你能举一反三，独立解决问题。
所以，“Go is badly designed” 吗？
与其说是“糟糕”，不如说是设计哲学和目标受众的不同。
Go 就像那位严格的物理老师，他可能不会让你在学习过程中时刻感到“舒适”，甚至会让你经历挫败和“阵痛”。但他目标明确，方法直接，逼着你打好基础，养成严谨的习惯，最终让你能够独立、高效地解决实际问题。
那么，你怎么看？
欢迎在评论区留下你的看法，分享你和 Go “相爱相杀”的故事！
原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！
我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：
衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！
著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格6$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。
Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com
我的联系方式：
商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。
© 2025, bigwhite. 版权所有.
2025-04-17 07:15:31
本文永久链接 – https://tonybai.com/2025/04/17/standardize-the-hash-function
大家好，我是Tony Bai。
随着Go泛型的落地和社区对高性能自定义容器需求的增长，如何为用户自定义类型提供一套标准、安全且高效的Hash计算与相等性判断机制，成为了Go核心团队面临的重要议题。近日，经过Go核心开发者多轮深入探讨，编号为#70471 的提案”hash: standardize the hash function”最终收敛并被接受，为Go生态引入了全新的maphash.Hasher[T] 接口，旨在统一自定义类型的Hash实现方式。
这个旨在统一自定义类型Hash实现的提案令人期待，但我们首先需要理解，究竟是什么背景和痛点，促使Go社区必须着手解决自定义 Hash 的标准化问题呢？
在Go 1.18泛型发布之前，为自定义类型（尤其是非comparable类型）实现Hash往往需要开发者自行设计方案，缺乏统一标准。随着泛型的普及，开发者可以创建自定义的哈希表、集合等泛型数据结构，此时，一个标准的、能与这些泛型容器解耦的Hash和相等性判断机制变得至关重要。
更关键的是安全性。一个简单的func(T) uint64类型的Hash函数看似直观和易实现，但极易受到Hash 洪水攻击 (Hash Flooding DoS) 的威胁。
什么是Hash洪水攻击呢？ 简单来说，哈希表通过Hash函数将键（Key）分散到不同的“桶”（Bucket）中，理想情况下可以实现快速的O(1)平均查找、插入和删除。但如果Hash函数的设计存在缺陷或过于简单（例如，不使用随机种子），攻击者就可以精心构造大量具有相同Hash值的不同键。当这些键被插入到同一个哈希表中时，它们会集中在少数几个甚至一个“桶”里，导致这个桶形成一个长链表。此时，对这个桶的操作（如查找或插入）性能会从O(1)急剧退化到O(n)，消耗大量CPU时间。攻击者通过发送大量这样的冲突键，就能耗尽服务器资源，导致服务缓慢甚至完全不可用。
Go内建的map类型通过为每个map实例使用内部随机化的 Seed（种子）来初始化其Hash函数，使得攻击者无法预测哪些键会产生冲突，从而有效防御了此类攻击。hash/maphash包也提供了基于maphash.Seed的安全Hash计算方式。因此，任何标准化的自定义Hash接口都必须将基于Seed的随机化纳入核心设计，以避免开发者在不知情的情况下引入安全漏洞。
明确了标准化Hash接口的必要性，尤其是出于安全性的考量之后，Go核心团队又是如何一步步探索、权衡，最终从多种可能性中确定接口的设计方向的呢？其间的思考过程同样值得我们关注。
围绕如何设计这个标准接口，Go 团队进行了广泛的讨论（相关issue: #69420, #69559, #70471）。
最初，开发者们提出的 func(T) uint64 由于无法有效防御 Hash 洪水攻击而被迅速否定。
随后，大家一致认为需要引入Seed，讨论的焦点则转向Seed的传递和使用方式：是作为函数参数（func(Seed, T) uint64）还是封装在接口或结构体中。对此，Ian Lance Taylor提出了Hasher[T]接口的雏形，包含Hash(T) uint64和Equal(T, T) bool方法，并通过工厂函数（如 MakeSeededHasher）来管理 Seed。 然而，这引发了关于Seed作用域（per-process vs per-table）和状态管理（stateless vs stateful）的进一步讨论。
Austin Clements 提出了多种接口变体，并深入分析了不同设计的利弊，包括API 简洁性、性能（间接调用 vs 直接调用）、类型推断的限制以及易用性（是否容易误用导致不安全）。
最终，为了更好地支持递归Hash（例如，一个结构体的Hash需要依赖其成员的Hash），讨论聚焦于将*maphash.Hash对象直接传递给Hash方法。maphash.Hash内部封装了Seed和Hash状态，能够方便地在递归调用中传递，简化了实现过程。
经历了对不同方案的深入探讨和关键决策（例如引入 *maphash.Hash），最终被接受并写入提案的maphash.Hasher[T] 接口究竟长什么样？它的核心设计理念又是什么呢？接下来，让我们来详细解读。
经过审慎评估和实际代码验证（见CL 657296和CL 657297），Go团队最终接受了以下maphash.Hasher[T]接口定义：
package maphash
// A Hasher is a type that implements hashing and equality for type T.
//
// A Hasher must be stateless. Hence, typically, a Hasher will be an empty struct.
type Hasher[T any] interface {
// Hash updates hash to reflect the contents of value.
//
// If two values are [Equal], they must also Hash the same.
// Specifically, if Equal(a, b) is true, then Hash(h, a) and Hash(h, b)
// must write identical streams to h.
Hash(hash *Hash, value T) // 注意：这里的 hash 是 *maphash.Hash 类型
Equal(a, b T) bool
}
该接口的核心设计理念可以归纳为如下几点：
下面是一个maphash.Hasher的使用示例：
package main
import (
"hash/maphash"
"slices"
)
// 自定义类型
type Strings []string
// 为 Strings 类型实现 Hasher
type StringsHasher struct{} // 无状态
func (StringsHasher) Hash(mh *maphash.Hash, val Strings) {
// 使用 maphash.Hash 的方法写入数据
maphash.WriteComparable(mh, len(val)) // 先写入长度
for _, s := range val {
mh.WriteString(s)
}
}
func (StringsHasher) Equal(a, b Strings) bool {
return slices.Equal(a, b)
}
// 另一个包含自定义类型的结构体
type Thing struct {
ss Strings
i int
}
// 为 Thing 类型实现 Hasher (递归调用 StringsHasher)
type ThingHasher struct{} // 无状态
func (ThingHasher) Hash(mh *maphash.Hash, val Thing) {
// 调用成员类型的 Hasher
StringsHasher{}.Hash(mh, val.ss)
// 为基础类型写入 Hash
maphash.WriteComparable(mh, val.i)
}
func (ThingHasher) Equal(a, b Thing) bool {
// 优先比较简单字段
if a.i != b.i {
return false
}
// 调用成员类型的 Equal
return StringsHasher{}.Equal(a.ss, b.ss)
}
// 假设有一个自定义的泛型 Set
type Set[T any, H Hasher[T]] struct {
hash H // Hasher 实例 (通常是零值)
seed maphash.Seed
// ... 其他字段，如存储数据的 bucket ...
}
// Set 的 Get 方法示例
func (s *Set[T, H]) Has(val T) bool {
var mh maphash.Hash
mh.SetSeed(s.seed) // 使用 Set 实例的 Seed 初始化 maphash.Hash
// 使用 Hasher 计算 Hash
s.hash.Hash(&mh, val)
hashValue := mh.Sum64()
// ... 在 bucket 中根据 hashValue 查找 ...
// ... 找到潜在匹配项 potentialMatch 后，使用 Hasher 的 Equal 判断 ...
// if s.hash.Equal(val, potentialMatch) {
// return true
// }
// ...
// 简化示例，仅展示调用
_ = hashValue // 避免编译错误
return false // 假设未找到
}
func main() {
// 创建 Set 实例时，需要提供具体的类型和对应的 Hasher 类型
var s Set[Thing, ThingHasher]
s.seed = maphash.MakeSeed() // 初始化 Seed
// ... 使用 s ...
found := s.Has(Thing{ss: Strings{"a", "b"}, i: 1})
println(found)
}
这个精心设计的 maphash.Hasher[T] 接口及其使用范例展示了其潜力和优雅之处。然而，任何技术方案在落地过程中都难免遇到挑战，这个新接口也不例外。它目前还面临哪些已知的问题，未来又有哪些值得期待的发展方向呢？
尽管 maphash.Hasher 接口设计优雅且解决了核心问题，但也存在一些已知挑战：
综合来看，尽管存在一些挑战需要克服，但maphash.Hasher[T]接口的提出无疑是Go泛型生态发展中的一个重要里程碑。现在，让我们对它的意义和影响做一个简要的总结。
maphash.Hasher[T]接口的接受是Go在泛型时代标准化核心机制的重要一步。它不仅为开发者提供了一种统一、安全的方式来为自定义类型实现 Hash 和相等性判断，也为 Go 生态中高性能泛型容器的发展奠定了坚实的基础。虽然还存在一些编译器优化和 API 便利性方面的挑战，但其核心设计的合理性和前瞻性预示着 Go 在类型系统和泛型支持上的持续进步。我们期待看到这个接口在未来Go版本中的落地，以及它为Go开发者带来的便利。
更多信息:
对于这个备受关注的 maphash.Hasher 接口提案，你怎么看？它是否满足了你对自定义类型 Hash 标准化的期待？或者你认为还有哪些挑战或改进空间？
非常期待在评论区看到你的真知灼见！
原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！
我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：
衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！
著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格6$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。
Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com
我的联系方式：
商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。
© 2025, bigwhite. 版权所有.
2025-04-16 08:32:36
本文永久链接 – https://tonybai.com/2025/04/16/ai-protocol-prefer-jsonrpc
大家好，我是Tony Bai。
在AI技术飞速演进的今天，底层通信协议的选择对系统效率和互操作性至关重要。细心的开发者可能已经发现，新兴的AI协议如模型上下文协议（MCP）和Agent2Agent（A2A）协议，都不约而同地将目光投向了JSON-RPC 2.0。这并非巧合，而是一个深思熟虑的技术选型。在这篇文章中，我将和大家一起看看JSON-RPC 2.0的起源、核心规范以及历史应用，并解读这个10多年前定义的“老协议”为何能在AI时代能再次获得青睐。
JSON-RPC协议的诞生，源于对早期RPC协议（如XML-RPC、SOAP）复杂性的反思，旨在提供一种更轻量、更简洁的远程过程调用机制。其2.0版本规范（基于2009年草案，正式发布于2010年左右）更是将这一理念发扬光大。其核心设计哲学正如规范开篇所言：“It is designed to be simple!”
很多开发者日常都是用过JSON-RPC 2.0，但可能没有对其规范做过深入的了解，借此篇文章机会，让我们依据其官方规范，深入了解其关键特性。。
我们先来看一下JSON-RPC协议设计的几个核心原则。
接下来，我们再来看一下工作原理。JSON-RPC 2.0是一个相对简单的协议，其规范也就几页，因此其工作原理也非常好理解。
JSON-RPC 的工作原理是向实现此协议的服务器发送请求。在这种情况下，客户端通常是打算调用远程系统的单个方法的软件。多个输入参数可以作为数组或对象传递给远程方法，而方法本身也可以返回多个输出数据（这取决于实现的版本。）
下面是对协议中的一些核心对象的解读。
Request Object是发起RPC调用的核心，由客户端发送请求到服务端。我们结合一个示例来理解请求对象的各个字段的含义：
--> {"jsonrpc": "2.0", "method": "subtract", "params": {"minuend": 42, "subtrahend": 23}, "id": 4}
<-- {"jsonrpc": "2.0", "result": 19, "id": 4}
JSON-RPC支持两种传递params的方式，一种是By-name(按名称)，即params是一个对象，其成员名与服务器期望参数名匹配，比如上面示例中params使用的就是一个by-name的参数传递方式。另外一种是By-position (按位置)，即params是一个数组，值按服务器期望顺序排列。比如上面示例中params等价为下面按位置传递方式的params：
{"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": 1}
上面的示例中的第二行其实是一个Repsonse Object，即服务器针对有效请求（非通知类）的回复：
<-- {"jsonrpc": "2.0", "result": 19, "id": 4}
下面是返回错误码的示例：
--> {"jsonrpc": "2.0", "method": 1, "params": "bar"} // method值不是字符串，不是一个合法的请求对象
<-- {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null}
再强调一下：result 和 error 成员互斥，必须存在其一。
错误对象用于描述发生的错误，对象有三个字段：
下面是一个错误对象示例：
--> {"jsonrpc": "2.0", "method": "foobar", "id": "1"}
<-- {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found"}, "id": "1"}
Notification通知一种特殊的Request，它没有id成员。表示客户端不关心响应，服务器也不用回复，适用于无需确认的操作。比如下面这个示例：
--> {"jsonrpc": "2.0", "method": "update", "params": [1,2,3,4,5]}
也就是说当一个合法的Request中没有id，则可以认为是Notification通知。
Batch批量调用是指客户端可能发送一个包含多个Request对象的数组，以实现批量处理。服务器应该返回一个包含对应Response对象的数组（通知除外）。请求处理和响应返回可以是无序的，客户端通过id匹配。下面是一个批量调用的示例：
--> [
{"jsonrpc": "2.0", "method": "sum", "params": [1,2,4], "id": "1"},
{"jsonrpc": "2.0", "method": "notify_hello", "params": [7]},
{"jsonrpc": "2.0", "method": "subtract", "params": [42,23], "id": "2"},
{"foo": "boo"},
{"jsonrpc": "2.0", "method": "foo.get", "params": {"name": "myself"}, "id": "5"},
{"jsonrpc": "2.0", "method": "get_data", "id": "9"}
]
<-- [
{"jsonrpc": "2.0", "result": 7, "id": "1"},
{"jsonrpc": "2.0", "result": 19, "id": "2"},
{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null},
{"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found"}, "id": "5"},
{"jsonrpc": "2.0", "result": ["hello", 5], "id": "9"}
]
自诞生以来，JSON-RPC凭借其简洁、轻量、易于实现和跨语言的特性，在多个领域得到了广泛应用，满足了开发者对“高效”通信的需求：
这些应用场景充分证明了JSON-RPC作为一种基础通信协议的普适性和生命力。
MCP和A2A是AI领域新兴的协议，旨在为日益复杂的AI系统（如多模型协作、Agent智能体交互）提供标准化的通信框架，解决互操作性问题。 那么，JSON-RPC 2.0究竟凭借哪些优势，在众多协议中脱颖而出，被MCP、A2A等选中呢？下面我们就来看看JSON-RPC的优势。
JSON-RPC 2.0 使用人类可读的 JSON 格式。其规范非常简单，定义清晰，无论是开发者学习、实现客户端/服务端，还是调试网络通信，成本都相对较低。这在需要快速迭代和广泛协作的AI领域尤为重要。
AI的开发涉及Python、Java、Go、Rust等多种语言和框架。JSON-RPC的简洁性和文本基础使其极易在不同语言和平台间实现互操作，为构建异构AI系统提供了基础通信能力，某种程度上提供了通信层面的“一站式解决方案”的可能性。
JSON-RPC 2.0本身不绑定具体的网络传输协议。它可以承载于HTTP(S)、WebSocket、TCP、消息队列等多种传输层之上。这种灵活性使得它可以适应不同的部署环境和通信需求，无论是需要低延迟长连接的Agent交互，还是简单的模型服务调用。
作为一个存在已久的协议，JSON-RPC 2.0拥有大量成熟的库和工具支持，覆盖了几乎所有主流编程语言。这意味着开发者可以快速集成，将更多精力投入到核心的AI逻辑开发上，而不是在基础通信协议上“重复造轮子”，符合用户“要更高效”的心理。比如：golang.org/x/exp/jsonrpc2就是Go team维护的一个高质量JSON-RPC 2.0的实现。
JSON-RPC明确的请求（方法名、参数）和响应（结果、错误）结构，非常适合表示AI服务中的函数调用、查询等交互模式，使得接口定义和理解更加直观，有助于提升开发和沟通效率。
JSON-RPC协议本身简洁，但params和data字段提供了足够的扩展空间来承载复杂的AI特定数据结构。
以上JSON-RPC协议的核心特点与AI时代需求的高度契合。
综上所述，JSON-RPC 2.0并非昙花一现的“新宠”，而是凭借其诞生之初的简洁设计、久经考验的稳定性、广泛的跨平台能力以及与当前AI通信需求的天然契合，在AI时代焕发了新的生机。MCP、A2A等协议选择它，正是看中了其作为通信基石的扎实、高效和务实。
对于JSON-RPC在AI领域的应用，以及未来可能出现的更优协议，你有何看法？欢迎在评论区分享你的真知灼见！
关注我，持续获取有深度的AI与技术解析。
Gopher部落知识星球在2025年将继续致力于打造一个高品质的Go语言学习和交流平台。我们将继续提供优质的Go技术文章首发和阅读体验。并且，2025年将在星球首发“Gopher的AI原生应用开发第一课”、“Go陷阱与缺陷”和“Go原理课”专栏！此外，我们还会加强星友之间的交流和互动。欢迎大家踊跃提问，分享心得，讨论技术。我会在第一时间进行解答和交流。我衷心希望Gopher部落可以成为大家学习、进步、交流的港湾。让我相聚在Gopher部落，享受coding的快乐! 欢迎大家踊跃加入！
著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格6$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。
Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com
我的联系方式：
商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。
© 2025, bigwhite. 版权所有.
2025-04-15 07:28:49
本文永久链接 – https://tonybai.com/2025/04/15/embrace-modern-go-style-with-gopls-modernize
大家好，我是Tony Bai。
最近在思考Go语言的发展时，不禁让我想起了当年学习C++的经历。Bjarne Stroustrup在《C++程序设计语言（特别版）》中就专门强调了“现代 C++”（Modern C++）的编程风格，鼓励使用模板、STL等新特性来编写更优雅、更高效的C++代码。
那么，我们热爱的Go语言，随着版本的不断迭代，是否也逐渐形成了一种“现代Go”（Modern Go）的风格呢？答案是肯定的。Go团队不仅在语言层面引入新特性（如泛型、range over int），也在标准库中添加了更强大、更便捷的包（如slices、maps）。
更棒的是，Go官方工具链gopls（Go Language Server Protocol的实现）中，就内置了一个名为modernize的分析器（Analyzer），专门用于帮助我们识别代码中可以用现代Go风格替代的“旧习”，并给出建议。
今天，我们就来深入了解一下gopls/modernize这个利器，看看它如何帮助我们的Go代码焕然一新，并学习一下它所倡导的11个“现代Go”风格语法要素具体包含哪些内容。
gopls/modernize是golang.org/x/tools/gopls/internal/analysis/modernize 包提供的一个分析器。它的核心目标就是扫描你的Go代码，找出那些可以通过使用Go 1.18及之后版本引入的新特性或标准库函数来简化的代码片段。
modernize工具目前可以识别并建议修改多种“旧”代码模式。让我们逐一看看这些建议，并附上代码示例：
(注：以下示例中的版本号指明了该现代写法是何时被推荐或可用的)
1). 使用min/max内建函数 (Go 1.21+)
func findMax(a, b int) int {
var maxVal int
if a > b {
maxVal = a
} else {
maxVal = b
}
return maxVal
}
import "cmp" // Go 1.21 implicitly uses built-ins, Go 1.22+ might suggest cmp.Or for clarity if needed
func findMaxModern(a, b int) int {
// Go 1.21 onwards have built-in min/max
return max(a, b)
// Note: for floats or custom types, use cmp.Compare from "cmp" package
}
2). 使用slices.Sort (Go 1.21+)
import "sort"
func sortInts(s []int) {
sort.Slice(s, func(i, j int) bool {
return s[i] < s[j] // Common case for ascending order
})
}
import "slices"
func sortIntsModern(s []int) {
slices.Sort(s) // For basic ordered types
}
// For custom comparison logic:
// func sortStructsModern(items []MyStruct) {
// slices.SortFunc(items, func(a, b MyStruct) int {
// return cmp.Compare(a.Field, b.Field) // Using cmp.Compare (Go 1.21+)
// })
// }
3). 使用 any 替代 interface{} (Go 1.18+)
func processAnything(v interface{}) {
// ... process v ...
}
func processAnythingModern(v any) {
// ... process v ...
}
4). 使用 slices.Clone 或 slices.Concat (Go 1.21+)
func cloneSlice(s []byte) []byte {
return append([]byte(nil), s...)
}
import "slices"
func cloneSliceModern(s []byte) []byte {
return slices.Clone(s)
}
5). 使用 maps 包函数 (Go 1.21+)
func copyMap(src map[string]int) map[string]int {
dst := make(map[string]int, len(src))
for k, v := range src {
dst[k] = v
}
return dst
}
import "maps"
func copyMapModern(src map[string]int) map[string]int {
return maps.Clone(src) // Clone creates a new map
}
func copyMapToExisting(dst, src map[string]int) {
maps.Copy(dst, src) // Copy copies key-values, potentially overwriting
}
6). 使用 fmt.Appendf (Go 1.19+)
import "fmt"
func formatToBytes(id int, name string) []byte {
s := fmt.Sprintf("ID=%d, Name=%s", id, name)
return []byte(s)
}
import "fmt"
func formatToBytesModern(id int, name string) []byte {
// Appends formatted string directly to a byte slice
return fmt.Appendf(nil, "ID=%d, Name=%s", id, name)
}
7). 在测试中使用 t.Context (Go 1.24+)
import (
"context"
"testing"
"time"
)
func TestSomethingWithContext(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
// Use ctx in goroutines or functions that need cancellation
go func(ctx context.Context) {
select {
case <-time.After(1 * time.Second):
t.Log("Worker finished")
case <-ctx.Done():
t.Log("Worker cancelled")
}
}(ctx)
// Simulate test work
time.Sleep(100 * time.Millisecond)
// Maybe cancel based on some condition, or rely on defer cancel() at end
}
import (
"context"
"testing"
"time"
)
func TestSomethingWithContextModern(t *testing.T) {
// t.Context() is automatically cancelled when the test (or subtest) finishes.
// It may also be cancelled sooner if the test times out (e.g., using t.Deadline()).
ctx := t.Context()
go func(ctx context.Context) {
select {
case <-time.After(1 * time.Second):
t.Log("Worker finished")
case <-ctx.Done():
t.Logf("Worker cancelled: %v", ctx.Err()) // Good practice to log the error
}
}(ctx)
time.Sleep(100 * time.Millisecond)
}
8). 使用 omitzero 代替 omitempty (Go 1.24+)
type ConfigOld struct {
EmptyStruct struct{} `json:",omitempty"`
}
// JSON 输出为 {"EmptyStruct":{}}
type ConfigModern struct {
EmptyStruct struct{} `json:",omitzero"`
}
// JSON 输出为 {}
9). 使用 slices.Delete (Go 1.21+)
func deleteElement(s []int, i int) []int {
if i < 0 || i >= len(s) {
return s // Index out of bounds
}
return append(s[:i], s[i+1:]...)
}
import "slices"
func deleteElementModern(s []int, i int) []int {
if i < 0 || i >= len(s) {
return s
}
// Delete element at index i
return slices.Delete(s, i, i+1)
}
func deleteElementsModern(s []int, start, end int) []int {
// Delete elements from index start (inclusive) to end (exclusive)
return slices.Delete(s, start, end)
}
10). 使用for range n (Go 1.22+)
func iterateN(n int) {
for i := 0; i < n; i++ {
// Use i
_ = i
}
}
func iterateNModern(n int) {
for i := range n { // Requires Go 1.22+
// Use i
_ = i
}
}
11). 使用 strings.SplitSeq (Go 1.24+)
import "strings"
func processSplits(s, sep string) {
parts := strings.Split(s, sep)
for _, part := range parts {
// Process part
_ = part
}
}
import "strings"
func processSplitsModern(s, sep string) {
// SplitSeq returns an iterator, potentially more efficient
// as it doesn't necessarily allocate the slice for all parts at once.
for part := range strings.SplitSeq(s, sep) { // Requires Go 1.24+
// Process part
_ = part
}
}
通过前面modernize工具支持的现代风格的示例，我们大致可以得到三点采用现代Go风格的好处：
认识到拥抱“现代 Go”风格的诸多好处，自然会问：如何使用modern工具才能帮助我们识别并实践这些风格呢？接下来我们就来看看modernize工具的用法。
modernize工具本身是一个命令行程序。你可以通过以下方式在你的项目根目录下运行它：
$go run golang.org/x/tools/gopls/internal/analysis/modernize/cmd/modernize@latest [flags] [package pattern]
执行示例：
正如我在我的两个开源项目go-cache-prog和local-gitingest中尝试的那样：
➜ /Users/tonybai/go/src/github.com/bigwhite/go-cache-prog git:(main) $ go run golang.org/x/tools/gopls/internal/analysis/modernize/cmd/modernize@latest -test ./...
/Users/tonybai/go/src/github.com/bigwhite/go-cache-prog/cmd/go-cache-prog/main.go:19:2: Loop can be simplified using slices.Contains
exit status 3
➜ /Users/tonybai/go/src/github.com/bigwhite/local-gitingest git:(main) ✗ $ go run golang.org/x/tools/gopls/internal/analysis/modernize/cmd/modernize@latest -test ./...
/Users/tonybai/go/src/github.com/bigwhite/local-gitingest/main_test.go:191:5: Loop can be simplified using slices.Contains
exit status 3
我们看到modernize的输出格式为：
文件路径:行号:列号: 建议信息。
这里的 exit status 3 通常表示 Linter 发现了问题。它提示我在这两个项目的指定位置，存在一个循环可以用 slices.Contains 来简化（这也是 modernize 支持的一个检查，虽然未在上述重点说明的现代风格列表中，但也属于简化代码的范畴）。
注意： 工具的文档提到，如果修复之间存在冲突（比如一个修复改变了代码结构，使得另一个修复不再适用或需要调整），你可能需要运行 -fix 多次，直到没有新的修复被应用。
IDE 集成：
好消息是，如果你在使用 VS Code、GoLand 等配置了 gopls 的现代 Go IDE，很多 modernize 提出的建议通常会直接以代码高亮或建议（Quick Fix / Intention Action）的形式出现在你的编辑器中，让你可以在编码时就实时地进行现代化改造。
掌握了如何在项目中使用 modernize 工具后，让我们回到最初的话题，对这个工具及其倡导的“现代 Go”风格做一些思考和总结。
gopls/modernize不仅仅是一个代码检查工具，它更像是Go语言演进过程中的一个向导，温和地提醒我们：“嘿，这里有更现代、可能更好的写法了！”
拥抱“现代 Go”风格，利用好 modernize 这样的工具，不仅能让我们的代码库保持活力，也能促使我们不断学习和掌握 Go 的新知识。这与当年拥抱“现代 C++”的精神是一脉相承的。
建议大家不妨在自己的项目上运行一下 modernize 工具，看看它能给你带来哪些惊喜和改进建议。也欢迎在评论区分享你使用 modernize 的经验或对“现代 Go”风格的看法！觉得这篇文章有用？点个‘在看’，分享给更多Gopher吧！
免责声明: modernize 工具及其命令行接口 golang.org/x/tools/gopls/internal/analysis/modernize/cmd/modernize 目前并非官方稳定支持的接口，未来可能会有变动。使用 -fix 功能前请务必备份或确保代码已提交到版本控制系统。
原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！
我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：
衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！
著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格6$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。
Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com
我的联系方式：
商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。
© 2025, bigwhite. 版权所有.
