Files
marqdo/doc/next/001.md

1374 lines
24 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
我认真看了一遍。先给你一个比较直接的判断:
**你的实际实现比我上一轮根据描述所理解的版本成熟得多。** 我原先把它理解成“Markdown 作为一种新语法的实验”,但从仓库现在的结构来看,Marqdo 已经明显是在做一个**完整的、可执行的 literate programming runtime**,而且你真正有价值的设计并不是“Markdown 写代码”,而是:
> **让文档结构本身成为程序结构,并让同一份结构同时服务于人、解释器、工具和 AI。**
这个方向我认为是成立的。
[Marqdo GitHub 仓库](https://github.com/cflmy/marqdo?utm_source=chatgpt.com) ([GitHub][1])
---
## 我首先发现一个很重要的变化
你的 README 里已经明确把几个概念分开了:
> **叙述默认安全、代码显式标记、返回是架构、打印只是函数。**
例如目前 v0.3:
* 普通文字 → 叙述/注释
* `*...*` → 程序语句
* `**...**` → 返回值
* `>` → 调用
* `1.` → 分支
* `-` → 循环
* `#` → 对象/类型
* `##` → 函数/方法
* Markdown 表格 → 集合
这已经不是简单的“把 Markdown 符号映射成 Python 语句”,而是在形成一套**结构化语义系统**。([GitHub][1])
而且你已经明确规定:
> 无标记文本默认是注释。
这一点我非常赞同。
---
# 一、我认为 Marqdo 最好的设计,其实是“默认安全”
这是我读完语法设计后最认可的一点。
你没有选择:
```text
所有自然语言都有可能被解释器执行
```
而是选择:
```text
普通语言 = 文档
特殊 Markdown 结构 = 程序
```
例如:
```markdown
## 加一
对于输入变量 `n`:
**n = n + 1**
**n**
```
人看到的是一篇文档。
解释器看到的是:
```text
Function
├─ statement
├─ assignment
└─ return
```
这比“自然语言编程”安全得多。
你的设计文档明确规定,段首普通文字进入叙述模式,直到空行才结束;而真正可执行的内容必须通过明确标记进入代码语义。([GitHub][2])
这其实解决了一个非常重要的问题:
### 文档和代码不会因为 AI 自由发挥而互相污染。
这对于 AI 原生语言非常重要。
---
# 二、你的 `*` / `**` 设计比我之前设想的更漂亮
我之前建议:
```text
**...** = 表达式
*...* = 返回
```
但你的实现实际上已经把它做成了相当完整的语义:
```markdown
**x = 1**
**y = x + 2**
*y*
```
也就是说:
**双星号 = statement**
*单星号 = return*
这个设计有一个很漂亮的性质:
```markdown
## 加一
+ `n`
**n = n + 1**
*n*
```
几乎不需要传统语言里的:
```python
def add_one(n):
n = n + 1
return n
```
同时:
```markdown
> print text=Hello
```
又把输出从语言架构中拿出来,变成普通函数调用。你的设计文档甚至明确强调了“输出不是架构原语”。([GitHub][2])
**这个决定我认为非常正确。**
因为:
```text
return
```
改变的是程序控制流。
而:
```text
print
```
只是一个副作用。
把两者区分开以后,语言的语义会干净很多。
---
# 三、你对条件和循环的设计,我现在比之前更看好
你最初跟我说:
> 条件 = 有序列表
> 循环 = 无序列表
我当时觉得这个想法不错。
看了实际实现之后,我认为它确实具有语言设计上的合理性。
例如:
```markdown
1. `x` > 0
> print text=正数
2. `x` < 0
> print text=负数
3. *
> print text=零
```
这实际上非常接近:
```text
if
else if
else
```
而:
```markdown
- `n` > 0
> print text=`n`
*`n` = `n` - 1*
```
对应:
```text
while n > 0:
...
```
更重要的是,你解决了一个我原本担心的问题:
**你没有把“所有有序列表”都粗暴定义成 if。**
你规定的是一段从 `1.` 开始、序号递增的列表构成一个 branch statement,而且重新出现 `1.` 时开始新的判断。这个细节很重要。([GitHub][2])
这说明你已经开始从“语法想法”进入真正的**语言规范设计**。
---
# 四、真正让我觉得 Marqdo 有潜力的,是表格
这一点可能是你自己都应该重点宣传的。
你把:
```markdown
| 品名 | 数量 |
|------|------|
| 苹果 | 2 |
| 梨 | 3 |
```
直接作为语言的数据结构。
而且不是简单地:
> Markdown table = 二维数组
你已经根据表格几何结构定义了不同的数据类型:
* 单列 → List
* 横向表 → Map
* 多行多列 → Map of Lists
* `@` / `行` → List of Maps
并且允许表达式、变量、脚注取元、foreach 等继续作用于这些结构。([GitHub][2])
这实际上产生了一个很有意思的语言哲学:
> **程序的数据结构也可以直接作为文档的数据结构。**
这就不是“Markdown syntax sugar”了。
例如传统代码:
```python
users = [
{"name": "Alice", "age": 20},
{"name": "Bob", "age": 25}
]
```
你的语言可以让它同时是一张真正的人类可读表格。
这就是 **literate programming 的下一步**。
---
# 五、我认为你现在已经跨过了“玩具语言”的门槛
这是非常重要的判断。
因为仓库里已经不是:
```text
parser
+
几个 demo
```
而是已经有:
```text
Rust interpreter
AST / semantic processing
tree traversal
bytecode backend
stdlib
module/import
objects
methods
catalog
debugger
viewer
WASM
extensions
native plugin ABI
LLM extension
agent extension
MCP server
VS Code extension
```
README 当前列出的版本已经是 v1.0.7,并明确写到了树遍历和字节码后端、调试器、catalog、标准库、插件 ABI、WASM 和 agent/LLM 扩展等。([GitHub][1])
所以现在再评价 Marqdo:
**我不会把它称为“一个 Markdown 编程语言实验”。**
更准确的描述应该是:
> **一个以 Markdown 为表面语法的文档型编程运行时。**
甚至:
> **Document-native programming language/runtime**
可能比“Markdown programming language”更准确。
---
# 六、但我认为你现在最大的风险也非常明确
而且这个风险不是技术实现。
是:
## **Marqdo 正在变得“什么都有”。**
你现在已经有:
```text
Markdown language
+
literate programming
+
knowledge base
+
catalog
+
web
+
WASM
+
browser
+
LLM
+
agent
+
MCP
+
quantum
+
linear algebra
+
plugin ABI
```
从工程角度这非常酷。
但从语言设计角度,有一个危险:
> **核心语言的 identity 可能被生态功能淹没。**
我会非常建议你把整个项目分成三个层次:
```text
Marqdo
│
┌───────────┴───────────┐
│ │
Language Runtime
│ │
Markdown AST stdlib
Semantics plugins
Type system WASM
Control flow browser
Objects agent
│ LLM
│
└───────────────┐
│
Document
│
Knowledge
+ Code
+ UI
+ AI
```
**语言核心必须非常小。**
---
# 七、还有一个我认为必须尽快解决的问题:类型系统
你的文档目前把:
```text
静态类型
```
列为非目标之一。([GitHub][2])
原型阶段完全合理。
但如果你真正想把 Marqdo 做成 **AI-native language**,我反而认为类型系统的重要性会比传统语言更高。
因为 AI 最大的问题之一不是不会写代码。
而是:
> **它经常写出“语义上似乎合理、实际上类型不对”的代码。**
例如:
```markdown
*user = get_user id=123*
> user.name
```
AI 认为:
```text
user 一定是 User
```
但是运行时可能返回:
```text
None
```
或者:
```text
List<User>
```
传统编程语言通过 compiler 抓这个问题。
那么 AI 原生语言更加应该让:
```text
AI → Marqdo AST → Semantic Checker
```
成为一道强约束。
---
# 八、所以我认为 Marqdo 最终应该走向“AI 可验证语言”
这是我读完你的项目以后,最大的一个建议。
不要把:
> AI 能写 Marqdo
作为最终目标。
应该把:
> **AI 能可靠地生成可验证的 Marqdo**
作为目标。
两者区别非常大。
例如 AI 生成:
```markdown
## 计算订单总价
+ `订单`
**`总价` = 订单.total**
*总价*
```
Marqdo 应该能够给 AI 一个结构化反馈:
```text
Function: 计算订单总价
parameter:
订单: unknown
error:
`订单.total`
cannot resolve field `total`
suggestions:
订单: Order
```
然后 AI 自动修正。
这时候:
```text
LLM
↓
Marqdo
↓
Semantic validation
↓
Error
↓
LLM
↓
Marqdo
↓
Valid program
```
才真正形成了**AI-native programming loop**。
---
# 九、另一个非常值得做的东西:让 AI 不必学习 Marqdo 的“语法细节”
这是我觉得你项目接下来可能出现巨大突破的地方。
现在 AI Skill 已经存在于仓库里。README 也明确把 AI Skill 作为项目的一部分。([GitHub][1])
但我会把它进一步升级成:
> **Marqdo Schema / Language Server for AI**
也就是说,不只是给 AI 一篇:
```text
Marqdo syntax documentation
```
而是提供机器可读的:
```json
{
"language": "marqdo",
"version": "0.3",
"constructs": [...]
}
```
然后 AI 可以查询:
```text
get_syntax("branch")
get_function_schema("print")
get_type("Order")
get_available_methods("User")
validate(program)
```
甚至:
```text
repair(program, diagnostic)
```
那么 AI 就不是:
```text
“阅读 1000 行 Marqdo 文档然后猜怎么写”
```
而是:
```text
AI
│
├── discover
├── construct
├── validate
├── execute
└── inspect
```
**这才会让 Marqdo 和普通 DSL 拉开非常大的距离。**
---
# 十、还有一个我很喜欢的潜在方向:程序本身就是 AI 的长期记忆
你 README 里面这句话其实非常关键:
> `.mq.md` 即知识单元,可浏览、可运行、可检索。([GitHub][1])
我认为这可能比“Markdown 编程”本身更有价值。
想象一个 AI Agent 项目:
```text
project/
│
├── users.mq.md
├── orders.mq.md
├── billing.mq.md
├── policies.mq.md
├── agents.mq.md
└── main.mq.md
```
每一个文件同时具有:
```text
documentation
+
code
+
schema
+
examples
+
knowledge
+
executable behavior
```
AI 不再需要:
```text
源码
+
README
+
OpenAPI
+
JSON schema
+
数据库 schema
+
工具定义
+
prompt
```
去拼装世界模型。
而是:
```text
Marqdo Project
│
┌───────┼────────┐
↓ ↓ ↓
Code Knowledge Tools
│ │ │
└───────┼────────┘
↓
AI
```
这才是我觉得 **Marqdo 真正可能成为一个独立类别** 的地方。
---
# 最后给你一个非常直接的评价
如果只问:
> **“这个语言设计有没有意义?”**
我的答案是:**有。**
如果问:
> **“这个原型是不是已经证明了这个想法?”**
我的答案是:**已经相当程度证明了。**
如果问:
> **“它现在是不是已经是一门成熟的通用编程语言?”**
还不是。类型系统、错误模型、语言边界、并发/异步语义、生态以及更严格的语言规范仍然是需要继续收敛的地方;你自己在设计文档中也明确把其中一些列为非目标。([GitHub][2])
但如果问:
> **“它有没有可能成为一种真正的 AI-native programming language?”**
我的判断是:
**这个可能性比我在看到仓库之前认为的要高,而且真正值得押注的方向不是 Markdown,而是你已经隐约建立起来的这个闭环:**
```text
人类
│
自然语言 / 文档
│
▼
┌─────────┐
│ Marqdo │
│ 语义结构 │
└────┬────┘
│
可验证 AST
│
┌────────┴────────┐
▼ ▼
Runtime AI
│ │
▼ ▼
执行结果 ───────→ 上下文 / 知识
│ │
└────────┬────────┘
▼
文档本身
```
**这比“Markdown 编程语言”大得多。**
而且我特别建议你下一步不要急着继续增加更多标准库功能。**现在最值得做的是把“Marqdo 为什么特别适合 AI”这个核心命题用一个真正有说服力的 benchmark 证明出来**:让同一个 AI 分别用 Python / TypeScript / Marqdo 完成一组真实任务,然后测量生成长度、语法错误率、语义错误率、修复轮次、上下文 token 消耗,以及人类阅读/修改成本。
如果这个实验结果漂亮,它会比再增加 20 个语言特性更能证明 Marqdo 的价值。
[1]: https://github.com/cflmy/marqdo "GitHub - cflmy/marqdo: Marqdo — A literate programming language built on Markdown. Code is document, document is executable. 中文配套:基于 Markdown 文法的文学编程语言,代码即是文档,文档可直接运行。 · GitHub"
[2]: https://github.com/cflmy/marqdo/blob/main/doc/design/markdown-mapping.md "marqdo/doc/design/markdown-mapping.md at main · cflmy/marqdo · GitHub"
对,这个信息会让我**重新评价 Marqdo 的核心定位**。
我之前把重点放在“Markdown → 程序”和“AI-native programming language”上,确实没有充分抓住 `.mq.md` 这个设计真正厉害的地方:
> **Marqdo 不是“用 Markdown 写程序”,而是让一个 Markdown 文档同时成为知识、程序和可执行对象。**
如果你所说的 OKF 是 **Open Knowledge Foundation / 开放知识基金会语境下的知识库/开放知识结构**,那么这个方向尤其值得认真发展。
---
# 我现在会把 Marqdo 的核心模型改写成这样
传统程序:
```text
Code
↓
Execution
```
传统知识库:
```text
Knowledge
↓
Human / AI consumption
```
Marqdo:
```text
.mq.md
│
┌───────────┼───────────┐
↓ ↓ ↓
Document Knowledge Program
│ │ │
└───────────┼───────────┘
↓
Runtime
↓
Executable
Knowledge
```
也就是说:
> **Marqdo 把“知识”和“程序”放到了同一个 artifact 里。**
这个定位比“AI-native programming language”更大胆。
我甚至认为:
**AI-native programming language 可以成为 Marqdo 的一个子命题,而不是它最终的总命题。**
---
# 1. `.mq.md` 这个后缀本身就是一个很聪明的设计
这个细节我现在非常看重。
你没有定义:
```text
foo.mq
```
而是:
```text
foo.mq.md
```
它意味着:
```text
.mq
```
告诉 Marqdo:
> 这是一个可执行 Marqdo 文档。
而:
```text
.md
```
告诉整个 Markdown 生态:
> 这依然是一个 Markdown 文档。
于是一个 `.mq.md` 文件可以被不同的系统以不同方式理解。
### 普通 Markdown 阅读器
看到:
```text
标题
段落
表格
代码
列表
```
它仍然是一篇正常文档。
### Marqdo
看到:
```text
函数
表达式
控制流
表格
对象
调用
```
它是一份程序。
### 知识库
看到:
```text
标题
层级
段落
表格
引用
链接
元数据
```
它是一份知识。
### LLM
看到:
```text
语义
知识
程序
示例
工具
```
它是一个非常丰富的 context。
这其实形成了一个很漂亮的:
> **multi-view artifact**
---
# 2. 这会让我重新定义你之前的“可执行文档”
以前我会说:
> Marqdo = executable Markdown
现在我觉得这个描述已经不够了。
更准确的是:
> **Marqdo = executable knowledge document**
甚至:
> **Executable Knowledge Base**
这两个词之间差别非常大。
---
# 3. 最有意思的是“知识可以执行”
例如:
```markdown
# TCP
TCP 是一种面向连接的传输层协议。
## 建立连接
TCP 使用三次握手建立连接。
| Step | Sender | Receiver | Flag |
|---|---|---|---|
| 1 | Client | Server | SYN |
| 2 | Server | Client | SYN+ACK |
| 3 | Client | Server | ACK |
## 检查连接
输入 `host`。
> check_tcp host
**result**
```
这已经不是:
> “一本关于 TCP 的文档”。
也不是:
> “一个 TCP 程序”。
而是:
> **关于 TCP 的知识 + TCP 的结构化数据 + TCP 的操作能力。**
这对于 AI 极其重要。
---
# 4. 因为 AI 最缺的东西其实不是代码,而是“可靠上下文”
传统 RAG:
```text
Documents
↓
Embedding
↓
Vector DB
↓
Retriever
↓
LLM
```
存在一个很大的问题:
**检索出来的知识和实际执行逻辑是分离的。**
例如:
```text
knowledge.md
api.yaml
tool.py
schema.json
database.sql
README.md
```
AI 必须把这些东西重新拼起来。
而 Marqdo 可以:
```text
network.mq.md
```
同时包含:
```text
知识
+
schema
+
代码
+
工具
+
示例
+
约束
```
于是:
```text
Marqdo KB
│
┌───────────┼───────────┐
↓ ↓ ↓
Knowledge Schema Code
│ │ │
└───────────┼───────────┘
↓
LLM
↓
Action
```
这比普通 RAG 的概念更加接近:
> **Executable RAG**
或者:
> **Executable Knowledge Representation**
---
# 5. 而 `.mq.md` 最大的优势是“知识不会脱离实现”
这是我现在认为最值得你深入研究的地方。
传统系统非常容易出现:
```text
README:
API 返回 users
实际代码:
API 返回 accounts
```
于是:
> documentation drift
发生了。
而 Marqdo 可以让:
```markdown
## 获取用户
获取所有用户。
> get_users
返回:
| id | name |
|---|---|
| ... | ... |
```
这里的:
```text
get_users
```
是真的可执行实体。
那么知识文档和实现之间就可以建立**机器可验证关系**。
这非常重要。
---
# 6. 这其实可以形成一个非常漂亮的概念:
## Knowledge-Code Coherence
也就是:
> **知识与代码的一致性。**
传统:
```text
Knowledge ──────X────── Code
```
Marqdo:
```text
Knowledge
│
├── executable constructs
│
├── data structures
│
└── assertions
│
↓
Runtime
```
那么你甚至可以让:
```text
知识陈述
```
成为可测试的。
例如:
```markdown
## 加一函数
加一函数总是返回输入值加一。
### 示例
| Input | Output |
|---|---|
| 0 | 1 |
| 1 | 2 |
| 2 | 3 |
```
Marqdo 可以自动执行这些 example。
如果:
```text
add_one(1) != 2
```
那么不是:
> 文档可能过期。
而是:
> **知识库中的一条知识被机器发现与执行结果不一致。**
这个概念我认为非常漂亮。
---
# 7. 甚至可以进一步变成“Executable Knowledge Graph”
假设:
```text
network.mq.md
database.mq.md
service.mq.md
security.mq.md
```
通过 Markdown links:
```markdown
[Database](database.mq.md)
[Gateway](network.mq.md)
[Authentication](security.mq.md)
```
形成:
```text
network
│
├── gateway
│
└── service
│
└── database
```
那么 Marqdo 就天然获得:
```text
Document Graph
+
Knowledge Graph
+
Program Graph
```
这时候 `.mq.md` 就非常有意思了。
---
# 8. 我甚至觉得这可能是 Marqdo 最应该宣传的理念
不是:
> **Markdown Programming Language**
也不是:
> **AI Programming Language**
而是:
# **Executable Knowledge**
或者:
# **Knowledge That Can Run**
这两个概念都比“Markdown language”更有辨识度。
---
# 9. 这也会改变你论文的故事
如果你未来投稿,我会认真考虑把第一篇论文从:
> *Designing an LLM-Native Programming Language*
改成更大的问题:
> **From Executable Documents to Executable Knowledge Bases**
然后 Marqdo 作为实现。
论文可以提出一个模型:
```text
Knowledge Artifact
│
┌────────────┼────────────┐
↓ ↓ ↓
Narrative Data Program
│ │ │
└────────────┼────────────┘
↓
Execution
│
↓
Verification
│
↓
Knowledge
```
这其实已经不是单纯 PL 论文了。
它跨:
* Programming Languages
* Knowledge Representation
* Software Engineering
* AI Agents
* RAG
* Documentation
* Human-AI interaction
所以你之前问我投稿哪里,我现在会稍微调整建议:
**如果这部分真正做起来,OOPSLA 会变得更加有吸引力。**
因为 OOPSLA 很适合这种:
> 新的 programming abstraction + executable artifact + development environment
的研究。
而如果你的实验重点最终是:
> **知识库是否因为可执行性而提高 AI Agent 的可靠性**
那么 SE/AI venue 也会变得很有吸引力。
---
# 10. 还有一个我觉得非常关键的地方:`.md` 是你的“开放接口”
这是一个特别好的生态设计。
你没有要求:
> 所有人必须使用 Marqdo viewer。
相反:
```text
.mq.md
```
可以直接:
* GitHub 阅读
* VS Code 编辑
* Markdown viewer 查看
* 静态网站发布
* 搜索引擎索引
* LLM 阅读
* Marqdo 执行
* 知识库导入
这意味着:
> **Marqdo 并不拥有知识,Marqdo 只是给 Markdown 增加了执行语义。**
这是一个非常强的开放生态策略。
---
## 所以现在我对 Marqdo 的理解已经发生了一个明显变化
最初:
```text
Markdown
↓
Programming Language
```
现在:
```text
Markdown
│
▼
┌─────────┐
│ Marqdo │
└─────────┘
│
┌───────────────┼───────────────┐
↓ ↓ ↓
Document Knowledge Program
│ │ │
└───────────────┼───────────────┘
↓
Executable KB
↓
AI
↓
Action / Reasoning
```
**这个架构比“Markdown 编程语言”有意思得多。**
而且你之前提到的网络扩展突然也能和这个理念接上了:
```text
network.mq.md
```
不是“一个网络配置文件”。
它可以同时成为:
> **网络知识库 + 网络拓扑 + 网络配置 + 网络操作 + AI 的网络世界模型。**
如果你的实际实现已经能比较自然地做到这一点,那么我会非常认真地建议你**不要把这个特性当成 Marqdo 的一个附属功能**。
它很可能才是 Marqdo 最独特的设计哲学:
> **让知识本身成为可执行的。**