[00:00:00] 好我们继续讲生成式软件工程
[00:00:03] 上一节课我们讲了一点版本管理
[00:00:05] 然后今天我会正式开始软件工程部分的内容
[00:00:09] 所以现在算是真正的软件工程课了
[00:00:11] 虽然当时版本管理也是啊软件工程
[00:00:14] 当然在上课之前
[00:00:16] 我可以先分享一些最近一周发生的新闻
[00:00:19] 当然因为这个热度已经高到一定程度了
[00:00:21] 所以我相信大家多多少少都已经
[00:00:24] 看过了
[00:00:25] 比如说这个TypeSafe AI最新发布了一个
[00:00:32] 可以实时玩DOOM的这样的一个模型
[00:00:38] 算是基础模型吧
[00:00:39] 我觉得它我猜盲猜
[00:00:41] 它是一个prefill-only的一个
[00:00:43] 就像就像只能出一个token的transformer
[00:00:46] 那它可能是别的架构
[00:00:48] 然后他可以输入一个
[00:00:49] 比如说输入一个JSON
[00:00:51] 在这里应该是他把这个毁灭战士的
[00:00:54] 状态变成一个JSON文件
[00:00:55] 然后让他给一个决策
[00:00:57] 然后他大概可以在毫秒级或者百毫秒级
[00:01:00] 就基本上是一个准人类实时的
[00:01:04] 这样的你看底下有一个决决策
[00:01:07] 然后来做一个输出一个token
[00:01:08] 然后这个token应该是他特微调过了
[00:01:11] 你可以理解成微调或者训练过了
[00:01:13] 反正他不说人话
[00:01:15] 他不说人话
[00:01:16] 但是他可以做决策
[00:01:18] 就像训练一个神经网络
[00:01:19] 但是一个通用的
[00:01:20] 介于大语言模型和这个以前的那种
[00:01:23] 比如说决策树
[00:01:24] 你们可能学过一个非常小的模型之间
[00:01:26] 但是它又可以真的可以干事
[00:01:28] 你可以看他真的是可以玩游戏的
[00:01:30] 然后这个反正这个新闻火了火了
[00:01:35] 然后他给自己一个名字叫System One
[00:01:38] 叫真正人类意义上的实时决策
[00:01:41] 其实这不是一个很新的技术
[00:01:42] 而且你们过去如果关注过这个赛道的话
[00:01:46] 会看到
[00:01:47] 确实也有一些人试图做这种非常快的这个模型
[00:01:51] 但是这次火了以后
[00:01:52] 他就正式把这个赛道打开了
[00:01:54] 把这个赛道打开意味着什么
[00:01:57] 你们作为AI native时代的年轻人
[00:02:00] 如果有一个模型可以在100ms
[00:02:03] 当然你乐观一点
[00:02:04] 如果模型可以裁的更小一点
[00:02:05] 可以在50ms或者更短的时间里面
[00:02:08] 做实时的决策
[00:02:10] 那你可以用它来干什么
[00:02:13] 你可以用它来感知这个周围的环境
[00:02:16] 比如说为什么人和人沟通
[00:02:18] 和人和机器沟通
[00:02:19] 你会感觉到有很大的差别
[00:02:22] 前两天好像我看到一个大家在传
[00:02:25] 说和AI演员对话
[00:02:27] 然后那个AI演员突然就开始说广东话了
[00:02:31] 然后那个另外两个就在他们英语对话的时候
[00:02:33] 突然就说广东话
[00:02:35] 而且这个AI的生成的数字
[00:02:37] 人和人之间是有很大的延迟的
[00:02:40] 但如果你有一个100ms
[00:02:42] 200ms的小的决策模型
[00:02:44] 你可以做什么
[00:02:45] 你可以让它做决策
[00:02:47] 然后是实时生成脸上的微表情
[00:02:50] 根据你说的话
[00:02:51] 然后这样的话
[00:02:52] 你就可以得到了
[00:02:53] 一个非常有实时性人感的东西
[00:02:56] 这是一个非常好的
[00:02:57] 就以前的大语言模型
[00:02:59] 在那个延迟下
[00:03:00] 他可能有这个能力做
[00:03:01] 但是做的就不是那么好
[00:03:03] 但是你今天就可以得
[00:03:04] 你看他能打打游戏
[00:03:05] 它就可以生成这个有人感的人
[00:03:07] 然后他可以甚至可以哄这个小朋友睡觉
[00:03:10] 因婴儿睡不着的难题就彻底解决了
[00:03:13] 所以他开了一个非常非常大的赛道
[00:03:16] 至少这次火了以后
[00:03:18] 我们看到这件事
[00:03:19] 当然也许已经之前已经也有人
[00:03:21] 也有人看到对所以其实我要说的是
[00:03:28] AI的进化速度其实非常非常的快
[00:03:32] 这个视频完全是由GPT-6啊生生成的
[00:03:39] 大概是从你看到
[00:03:40] 从1956年到58年到1960年
[00:03:44] 感知与规划机器走出实验室
[00:03:47] 然后到70年到90年代的人工智能的寒冬
[00:03:50] 然后这个寒冬到97年的时候
[00:03:52] 我们是用搜索算法
[00:03:53] 第一次击败了人类的世界冠军
[00:03:55] 97年你看这个经历了很长时间的发展
[00:03:58] 然后到后面你突然发现从2012年开始
[00:04:02] 这个AlexNet开始
[00:04:03] 这个世界就发生了很大的变化
[00:04:09] 发展的速度真的是始料未及
[00:04:13] 到2016年那个时候我在现场看直播
[00:04:17] 2017年的时候
[00:04:18] 我们也关注
[00:04:19] 那时候我在读PhD
[00:04:20] 我也在关注像词向量
[00:04:22] 这个transformer
[00:04:24] BERT
[00:04:25] 这些可以用来干什么有趣的有趣的事情
[00:04:30] 那你看短短的2017年
[00:04:31] 那个时候你们是在上高中吗
[00:04:34] 还是在上初中
[00:04:37] 都没有
[00:04:38] 现在已经2026年了
[00:04:39] 这已经是接近10年以前的事情了
[00:04:42] 然后到2020年的时候
[00:04:45] 他们训练了GPT-3
[00:04:47] 然后GPT-3当时是一个大家都觉得很吃惊
[00:04:52] 我们为什么要做一个那么大参数的模型
[00:04:54] 然后直到2022年的时候
[00:04:55] 我们知道为什么为什么需要了
[00:04:57] 这个到现在也不过是4年的时间
[00:05:01] 很快的从2020年到2023年
[00:05:03] 他就可以可以看图了
[00:05:05] GPT-4o在生成的时候
[00:05:06] 它可以生成就可以识别语音
[00:05:09] 它可以多个多个模态
[00:05:11] 然后到开源模型
[00:05:14] Gemini
[00:05:18] 诶生成视频你们很难想象
[00:05:21] 就今天你看到这个抖音
[00:05:22] 上面全是这个短AI生成的短视频
[00:05:25] 然后我们那个计算机学院楼下的那个那个板上
[00:05:27] 也是AI生成的
[00:05:28] 就2024年的时候
[00:05:30] Sora才第一次发布
[00:05:32] 2024年9月的时候才有的
[00:05:33] chain of thought的o one的模型
[00:05:34] 2024年9月
[00:05:37] 你还能想象从2024年9月到现在
[00:05:40] 这个GPT-6s pro
[00:05:41] 就在这么短的时间里面发生了
[00:05:44] 这么多的事情
[00:05:45] 第一个开源的这个chain of thought DP c卡one
[00:05:59] 对这是刚刚发生的事情
[00:06:03] Millennium problem
[00:06:05] 哼
[00:06:05] 然后就这么被暴力大力出奇迹给啊解决了
[00:06:21] 对最后的彩蛋是这个视频完全是
[00:06:24] 但不知道是哪位博主直接用GPT-6 + Sora制作的
[00:06:27] 然后我也我也我也会想
[00:06:29] 如果我们有一个比较好比较大的素材库
[00:06:31] 其实本身比如说YouTube或者哔哩哔哩
[00:06:34] 你本身可以下载
[00:06:35] 你可以用工具来下载
[00:06:36] 你就拥有了这个世界上所有的所有东西的入口
[00:06:39] 然后你创作创造任何东西都会变得
[00:06:44] 很容易
[00:06:45] 然后你们你们有没有同学看过这个这个剧
[00:06:50] 这个Silicon Valley
[00:06:53] 这是个是个第一S1的101的名场面
[00:06:57] 他大概是几个
[00:07:01] 几个伙伴们
[00:07:03] 他们要去做一件改变世界的事情
[00:07:09] 千百年来我们这种书呆子一直都被欺负
[00:07:13] 在人工智能时代终于可以可以出人头地
[00:07:18] Ok anyway
[00:07:19] 这个这个这个不重要
[00:07:21] 但是可以看到的是
[00:07:24] 这个世界的发展在在加速
[00:07:26] 就这世界发展的速度可能比比大家想象的要快
[00:07:29] 所以可能我们要
[00:07:32] 要可能要回过头来想一想
[00:07:34] 在就业市场上面临的挑战
[00:07:36] 但这也同样意味着
[00:07:37] 这个世界上有很多的机遇
[00:07:38] 就比如说这个Jev带带火的这样的
[00:07:42] 一种我能看到的生态
[00:07:44] 不知道是它一瞬间就会到来
[00:07:46] 还是可能要等几年再等技术成熟一下
[00:07:49] 也许要等到一年跟上
[00:07:51] 但是我们不知道
[00:07:52] 就你看到今年春晚的时候
[00:07:54] 那个没有人敢的那个人形机器人
[00:07:57] 然后你到明年的时候
[00:07:58] 你就能看到一个非常有人感的
[00:08:00] 能够实时做出非常棒的微表情的啊机器人
[00:08:03] 有点可怕对
[00:08:05] 然后最近也有一个这个Noam Brown的访谈
[00:08:09] 来自来自OpenAI
[00:08:12] 他跟我的判断
[00:08:13] 可能我不知道他泄露了泄露了多少
[00:08:16] 就是他觉得可能虽然现在的
[00:08:20] AI模型的短板是也是品位
[00:08:24] 也就是说他对这个问题的定义是说
[00:08:27] 模型对接下来应该做什么的
[00:08:30] 直觉做的还不够好
[00:08:31] 我们说模型被训练成了这个prompt的舔狗
[00:08:34] 你做什么
[00:08:35] 他就会盯着你那个就疯狂的做
[00:08:37] 然后同时他也有一点点这种reward hacking的倾向
[00:08:40] 会快速用最快最脏的方式把你要的任务完成
[00:08:44] 因为对他来说
[00:08:45] 他把任务完成才得到reward了
[00:08:47] 那他就不会不断的会往这个方向去强化
[00:08:51] 那么有的时候它生产的东西
[00:08:54] 从长期主义角度来看
[00:08:55] 它是可能不满意的
[00:08:57] 这就是一个对接下来该做什么的直觉
[00:08:59] 他现在因为强化训训练有学习有反馈的信号
[00:09:02] 他就会执着的去做立即有反馈的东西
[00:09:06] 但是同样我觉得没有什么道理
[00:09:10] 根本道理
[00:09:11] 我们不能用更多的合成的数据去告诉模型
[00:09:15] 你在做这件事情的时候
[00:09:17] 你可以想的更远一点
[00:09:18] 无非就是你chain of thought时候
[00:09:20] 那头几个token决定你要
[00:09:22] 你要你要做什么
[00:09:23] 然后他也提到了可验证和不可验证的边界
[00:09:26] 比如说你觉得可能品味是一个不可验证的东西
[00:09:28] 但也许没有那么难
[00:09:30] 但你觉得数学是一个可验证的东西
[00:09:32] 是可能验证也没有那么的容易
[00:09:35] 因为你就算是把它formalize了
[00:09:37] 你的auto formalization
[00:09:38] 再从你的一个自然语言描述的
[00:09:41] 问题到这个形式语言描述的问题之间
[00:09:45] 还是有gap的
[00:09:46] 就像啊前段时间有一个很有意思的笑话
[00:09:49] 有人声称证明了哪一个黎曼猜想
[00:09:51] 还是P等于NP好像P不等于NP
[00:09:53] 然后但是后来大家发现
[00:09:54] 他那个形式化证明里面
[00:09:56] 等于说它定义那个问题
[00:09:57] 就是一个nothing不存在的定义
[00:09:59] 然后他说我证明了一个
[00:10:00] 就证明了一等于一这样的东西
[00:10:02] 然后最后他写了大概几千页的证明
[00:10:04] 然后最后证明一等于一有这个感觉
[00:10:07] OK
[00:10:09] 所以对我觉得对我们的启发来说是
[00:10:12] 比如说OpenAI
[00:10:13] 他说他有all in on RSI
[00:10:16] 然后那我们就回头再想
[00:10:19] 其实the bitter lesson到今天就是the scaling law
[00:10:23] 到今天可能还没有停止
[00:10:26] 就比如说我看到GPT-6
[00:10:28] 它发布以后
[00:10:30] 我最大的感受就是
[00:10:32] 可能OpenAI摸到了一个门道
[00:10:35] 这个门道我不知道这个应该怎么叫
[00:10:39] 大概就叫我可能叫它数据分布工程
[00:10:42] 也就是说GPT-6它有我前面说过
[00:10:47] 它有非常惊人的空间推理能力
[00:10:49] 它可以理解一个图片里面的空间关系
[00:10:53] 然后从而他在画图方面
[00:10:55] 在生成模型方面都做的的都做的非常好
[00:10:58] 那毫无疑问是因为他
[00:11:00] 在训练的时候肯定加入了这部分的数据
[00:11:02] 可能基模训练的时候就加了这些数据
[00:11:04] 然后同时他在后训练的时候
[00:11:05] 强化学习的时候
[00:11:06] 也有更多的数据帮助他去理解这个空间
[00:11:11] 给他反馈
[00:11:12] 说这样做是好
[00:11:13] 这样做是不好
[00:11:13] 或者对和错
[00:11:14] 那另外一个维度的scaling law就变成了以前以前
[00:11:20] 我们说好大模型
[00:11:21] scaling law 是说
[00:11:22] 我有更多的训练数据
[00:11:23] 他就可以基模就可以变得更好
[00:11:25] 所以Anthropic去买书
[00:11:26] 然后去烧书
[00:11:27] 他只要买了书
[00:11:28] 烧了书
[00:11:28] 他有了绝版的数据
[00:11:30] 他就可以比别人别人更强
[00:11:35] 我觉得他们看到一点
[00:11:36] 如果我们有一个基模
[00:11:38] 他已经做的很好了
[00:11:40] 我们可以再加一个他没有见过的领域
[00:11:43] 然后强化学习
[00:11:44] 然后他就会在所有的任务上都做得更好
[00:11:47] 这是一件非常恐怖的事情
[00:11:48] 你看到就刚才我们看了那个视频
[00:11:50] 说模型是一代一代怎么怎么发展过来的
[00:11:54] 那最早的时候模型就完全就是语料
[00:11:58] 它是这个语言的token large language model
[00:12:01] 然后他是先训练了语言
[00:12:04] 然后再训练了可能视觉的多模态训练了一部分
[00:12:08] 然后他训练了数学
[00:12:10] 你看这人工智能就是大语言模型
[00:12:12] 它发展的脉络是先从语言到数学语言
[00:12:16] 然后再到多模态
[00:12:17] 他学会了数学以后
[00:12:19] 他才再学会空间感知的关系
[00:12:21] 然后他可能就不需要那么多数据
[00:12:23] 因为如果你从零开始训练一个
[00:12:25] 比如说巨型智能的模型
[00:12:26] 它很容易什么
[00:12:27] 你会先要有大量的模拟器数据
[00:12:29] 然后模拟器数据我们的模型是一个reward hacker
[00:12:32] 它就很容易根据你的模拟器里面的
[00:12:34] 比如说光照的那种渲染的一点非常细微的
[00:12:37] 比如说那个角上的光像素点是亮还是不亮
[00:12:40] 它就能够得到这个reward hack的反馈信号
[00:12:43] 它不能泛化
[00:12:44] 但是如果你是一个大模型
[00:12:46] 一个基座很大的基座模型
[00:12:47] 它既会语言
[00:12:48] 又会数学
[00:12:49] 还会写歌写程序
[00:12:52] 那如果你在这样的一个好的基础基座模型上面
[00:12:55] 再给它做空间感知的训练
[00:12:57] 可能就不需要那么多数据了
[00:12:59] 所以每加一个就我猜测
[00:13:01] 你每加一个新的人类的领域
[00:13:03] 他需要的数据不是更多
[00:13:05] 反而是更少
[00:13:05] 它就能达到一个泛化的效果
[00:13:08] 这是件非常恐怖的事情
[00:13:09] 然后人跟模型是反过来的
[00:13:11] 人是先学的世界模型
[00:13:13] 就我们在刚讲刚婴儿出生的时候
[00:13:16] 我们就和这个世界交互
[00:13:17] 先学的是世界模型
[00:13:19] 然后
[00:13:20] 你看他要到
[00:13:21] 训练一年两年3年的世界模型以后
[00:13:24] 他才能开始说话
[00:13:25] 你那幼儿园的时候小朋友都还说话都说不利索
[00:13:28] 他是先有世界模型再训练语言
[00:13:31] 再训练数学
[00:13:31] 再比如说变成我这读一个PhD
[00:13:34] 训练这个research taste
[00:13:35] 然后大语言模型反过来
[00:13:37] 但我们看到的是
[00:13:38] 不管按照什么顺序训练
[00:13:40] 只要你有足够多的数据
[00:13:42] 你有scaling law这个模型就能训成
[00:13:45] 当模型成功了
[00:13:46] 人也成功了
[00:13:47] 所以他们可能看到了这个数据分布
[00:13:49] 工程上的这样的一个飞轮
[00:13:52] 它只要决定在什么时候给模型
[00:13:55] 按照什么样的比例注入数据
[00:13:57] 模型的架构不重要
[00:13:59] 算法不重要
[00:14:01] 只要训练不崩掉
[00:14:02] 只要这个训推能够一致
[00:14:04] 我不能训练出一个参数推理的时候
[00:14:06] 他这个参数参数变了
[00:14:08] 只要这些工程性的问题能解决
[00:14:11] 它只要有十倍100倍的数据
[00:14:12] 这个问题就解决了
[00:14:14] 可能算法就你用一个更好的算法
[00:14:15] 用更好的模型结构
[00:14:16] 可能会能够有一定程度的提升
[00:14:18] 但是对他来说
[00:14:19] 只要这个飞轮还在
[00:14:21] 只要他有钱
[00:14:21] 他就可以无限的scale下去
[00:14:23] 所以这是一个非常恐怖的事情
[00:14:24] 基模厂说
[00:14:26] 一一方面我们看到比如说AI 顶会
[00:14:28] 今年投稿的数量到达新的巅峰了
[00:14:31] 就学术界更多的用这个AI slop来充满
[00:14:35] 这个对
[00:14:37] 因为同学们都想发论文
[00:14:38] 你们你们如果还想保研的话
[00:14:40] 你们都一定会想发一篇论文
[00:14:41] 然后另外一个方面是
[00:14:42] 这个基模厂已经不care这些东西
[00:14:44] 他说你们你们在一个小规模上做任何实验
[00:14:46] 对他来说都没有意义
[00:14:47] 因为因为他看到了另外一个维度的scaling law
[00:14:51] 然后你不在基模厂
[00:14:52] 你没有没有这个没有任何资源可以做这件事
[00:14:54] 你对这个分布
[00:14:55] 比如说在什么时候
[00:14:56] 加进这个数据一无所知
[00:14:58] 然后你就算是能做一些实验
[00:15:00] 在一些小规模上有一些非常酷的想法
[00:15:03] 可能你也不需要写一篇paper
[00:15:05] 你只只要写一个blog post
[00:15:06] 然后你今天只要写个blog post
[00:15:09] 然后他们的那个AI看到这个blog post就可以
[00:15:12] 他们到他们的数据上去试一试
[00:15:14] 他们他们有RSI的loop
[00:15:16] 就他们先要构成一个人工智能上面
[00:15:19] RSI（recursive self-improvement）的一个循环
[00:15:22] 然后他靠这个人工智能循环
[00:15:24] 那就可以去做任何事
[00:15:25] 然后飞轮就蹬起来了
[00:15:27] 有点恐怖
[00:15:28] 我觉得就这是一个他们要做自动化的能力
[00:15:33] 能力产生
[00:15:35] 一旦这个这个闭环被他们探索的
[00:15:38] 基本上接近收敛
[00:15:39] 而且在AI的帮助下
[00:15:40] 这个闭环我觉得肯定会很快的收敛
[00:15:43] 因为AI比任何一个人类都要强
[00:15:44] 他就可以去发现找一个新领域
[00:15:46] 我不知道下一个领域是什么
[00:15:48] 情感计算还是这种化学
[00:15:51] 因因为我听说这个看到消息说
[00:15:54] Anthropic要做一个这个wet lab
[00:15:59] 去做这个生物工程的实验
[00:16:01] 那也许生物工程
[00:16:05] 或者比如说甚至预测这个老鼠的行为
[00:16:08] 你就成为了一个下一个scale的领域
[00:16:10] 然后他在这个领域上面可以建立反馈
[00:16:13] 优化训练分布
[00:16:14] 就把这个领域以一个插件的形式
[00:16:17] 插进它的基模训练里
[00:16:19] 然后这个飞轮转起来
[00:16:21] 这就非常恐怖了
[00:16:22] 他每次就是说我要新建一个实验室
[00:16:24] 投资几10亿美元
[00:16:25] 新建一个实验室
[00:16:26] 然后他的模型能力就往上抬一个台阶
[00:16:28] 这是一个几乎可预见这个能够有收益的
[00:16:33] 而不是像我们现在学术界
[00:16:35] 比如说要写个paper
[00:16:36] 就是我随机的想一个idea
[00:16:38] 这个有没有用
[00:16:38] 不知道
[00:16:39] 然后我要去发一篇paper
[00:16:41] 然后接受这个peer review
[00:16:42] 然后这个我觉得这个体系马上就要崩溃了
[00:16:44] 这个但每个同学都可以想一想
[00:16:47] 在这个崩溃的体系下
[00:16:49] 我们还能啊还能剩下什么对
[00:16:52] 然后我也理了一些
[00:16:54] 可能我跟AI聊了一会儿
[00:16:56] 然后比如说啊这些至少这些都是可以
[00:17:01] 作为一个小的
[00:17:02] 可能是一个小的领域来做验证的
[00:17:05] 比如说你可以在系统架构上面
[00:17:08] 去训练品位
[00:17:09] 让他做出好的系统设计
[00:17:11] 然后很快这个
[00:17:12] 可能到我这个学期结束的时候
[00:17:16] 他们突然推出了下一版的模型
[00:17:18] 把系统设计加进去了
[00:17:20] 然后然后然后你就看到我
[00:17:22] 我你对我经常在在课上面说
[00:17:24] 你笑话AI生成的这个slop code
[00:17:27] 说你看它架构多么多么糟糕
[00:17:29] 我1+1个需求他就崩溃了
[00:17:30] 然后但这些事情可能就永远都不会发生了
[00:17:33] 对
[00:17:35] 很有意思
[00:17:36] 但不管怎么样
[00:17:37] 我们还是需要上课的
[00:17:38] 需要上课
[00:17:39] 是因为你还是不能完全的依赖AI
[00:17:43] 或者说你人类是一个竞争的社会
[00:17:46] 它和生物生我们就我们所在的环境
[00:17:50] 生物的进化很像是
[00:17:51] Survival of the fittest
[00:17:52] 你是适者生存的
[00:17:54] 所以这个斩杀线就毫无疑问
[00:17:55] 这个斩杀线是不断的向向上移动的
[00:17:58] 然后你每一个人就会就说我
[00:18:00] 我最终怎么样才能逃离这个斩杀线
[00:18:02] 然后在最后还没有被斩杀的时候
[00:18:05] 搭上最后一班车
[00:18:06] 因为人类就我觉得从人类的角度来讲
[00:18:09] 人类肯定不希望自己消亡
[00:18:11] 不管是Anthropic还是OpenAI还是DeepSeek
[00:18:14] 他们都希望的是靠人工智能
[00:18:16] 去推动人类的进步
[00:18:17] 当然这个斩杀一定程度上会使很多人的生活
[00:18:21] 没有生命
[00:18:22] 变得没有意义
[00:18:22] 但是我们成为一个更好的人
[00:18:25] 我们就可以更好的找到这个意义
[00:18:27] 那这也这也是没有办法的事
[00:18:28] 我们每个人都是这样
[00:18:30] 包括我也是
[00:18:31] 我也我也是这样
[00:18:32] OK
[00:18:33] 所以我们还是回到技术上的内容
[00:18:35] 我们上一次讲了版本管理
[00:18:37] 然后我花了好多次课来给大家说
[00:18:41] 我们的软件软件所面临的问题是我们的intent
[00:18:45] 就是你想要什么
[00:18:46] 我们的specification
[00:18:48] 我们的implementation
[00:18:50] 它这三个之间是有是有是有gap的
[00:18:52] 然后就是因为有这个gap
[00:18:54] 所以构造软件就成为一个世纪性的难题
[00:18:57] 也有了
[00:18:58] 软件工程
[00:18:58] 然后我们起了个头说
[00:19:00] 如果你现在就要从零开始构造一个系统
[00:19:02] 那我们就需要管理软件
[00:19:04] 所以我讲了一些这个版本控制的东西
[00:19:07] 那接下来就是如果我们真的想要构造软件
[00:19:12] 而且版本管理也有了
[00:19:14] 那我们到底应该怎么
[00:19:16] 怎么构造
[00:19:17] 当然我也起了一个头
[00:19:18] 有一个答案
[00:19:19] 就今天的答案是直接做一个这个
[00:19:22] Minimum
[00:19:22] Minimum
[00:19:23] Viable product
[00:19:24] 一个MVP
[00:19:25] 一个最小原型
[00:19:26] 这件事情对大家来说是非常直观的
[00:19:28] 我们做的多就错的多
[00:19:31] 我做的少我就错的少
[00:19:34] 所以我做一个最少的
[00:19:35] 但是又和我最终的那个product最接近的
[00:19:39] 那应该是收益比较大的
[00:19:41] 因为它可以帮助我去补上这个intent specification
[00:19:44] implementation的这个gap
[00:19:46] 因为我做一个MVP
[00:19:47] 首先是AI生成的slop
[00:19:49] 所以所以他也不怎么花钱
[00:19:50] 这个integration我随时可以扔掉
[00:19:52] 这个不重要
[00:19:53] 但是它能够帮我知道我的intent哪里没有弄对
[00:19:57] 然后我的specification
[00:19:59] 比如说架构还有没有可以改进的空间
[00:20:01] 然后再做几个版本的迭代
[00:20:03] 最后再去啊再去出来
[00:20:04] 比如说比如说我那天晚上
[00:20:08] 做了这样的一个东西
[00:20:10] 做这样的一个东西
[00:20:11] 所有东西都是AI slop
[00:20:13] 我就是开着豆包输入法
[00:20:15] 然后开了几个终端
[00:20:16] 然后来回骂过来骂我一圈一圈骂过来
[00:20:21] 这是一个和物理世界有交互的这个东西
[00:20:26] 我有一个标签打印机
[00:20:27] 它他就把标签就打出来了
[00:20:31] 就是之前买的各种各样的设备
[00:20:33] 然后然后每个设备大家都要用
[00:20:36] 就大家都用那个设备自带的软件啊去使用
[00:20:40] 然后那个软件用起来就像吃屎一样
[00:20:43] 所以所以我们干脆这个就不要
[00:20:47] 就不要这个这个软件了
[00:20:49] 我就把所有的这些软件都屏蔽掉
[00:20:51] 当然这也是AI做的
[00:20:52] 相当于做一个抽象
[00:20:54] 哎这其实是有哎sorry
[00:20:56] 这其实是有一些软件工程智慧的
[00:20:59] 我们有一台计算机
[00:21:02] 然后这个计算机上总线上连了一些设备好
[00:21:04] 这就是操作系统课程
[00:21:06] anyway不重要
[00:21:06] 扫描仪
[00:21:07] 打印机
[00:21:07] 各种各样
[00:21:08] 你能想象的
[00:21:09] 想象任何东西
[00:21:10] 然后这个码是可以扫的
[00:21:11] 这个这个我会就整个流程它会自动
[00:21:13] 你们不需要扫码
[00:21:14] 这个就是这是一个这个白的咳
[00:21:17] 他会上传到这个
[00:21:19] 我们ISS自己的那个那个主页上
[00:21:24] 我们为什么不能对他做一个抽象
[00:21:29] 他就是一个就我们说
[00:21:31] 我上操作系统课时候说什么是设备驱动
[00:21:33] 把一个设备抽象成read write I/O control的一个接口
[00:21:36] 那我能不能把它抽象成一个更好用的接口
[00:21:38] 比如说扫描仪
[00:21:40] 我就是一个scan
[00:21:43] 我希望的是我是正面向上还是反面向上
[00:21:46] 然后我要单面还是双面
[00:21:48] 我dpi是多少
[00:21:48] 我就给他一个更干净的接口
[00:21:50] 然后我的这个这个打印机也是的
[00:21:52] 我的接口就是一个print
[00:21:54] 一个image
[00:21:57] 当我有这个接口以后
[00:22:00] 我的实设计和实现就完全解开了
[00:22:03] 然后我的软件层就可以工作
[00:22:05] 在这个这个接口层上
[00:22:07] 对这是一个非常典型的软件工程里的你的设计
[00:22:10] 然后这样我就再也不用
[00:22:11] 不需要去用那些不好用的软件了
[00:22:14] 然后这就是一个self service
[00:22:16] 然后你看到的是什么AI出现以后
[00:22:19] 而且我特意试用的是国产的模型
[00:22:21] 因为正好那个那个他我额度额度是空的
[00:22:25] 然后我就正好把五个小时额度
[00:22:26] 基本上全部登完了
[00:22:27] 然后就得到看起来是个非常可用的
[00:22:31] 就跟你在你在食堂或者宿舍楼下
[00:22:33] 看到那个机器达到了某种这个产品级的
[00:22:39] 效果的这样的东西
[00:22:41] 所以所以就是以后
[00:22:43] 软件公司就是面临一个非常彻底的消亡
[00:22:48] 你想他
[00:22:50] 我不知道你们有没有没有装过这种
[00:22:52] 比如说标签打印机都会给你一个驱动
[00:22:53] 给你一个软件
[00:22:54] 它的开发成本是非常高的
[00:22:56] 然后像我的这个扫描仪是佳能的扫描仪
[00:22:59] 然后这个扫描仪的成本
[00:23:02] 软件成本也是非常高的
[00:23:03] 他要开发
[00:23:05] 要跨平台的驱动等
[00:23:08] 但是在今天这些全通通都不需要了
[00:23:11] 啊这里有代码
[00:23:20] 我直接让他解释一下打印机和
[00:23:27] 但我只让AI帮我解释
[00:23:29] 实际上这个打印机
[00:23:32] 这个照片打印机是个非标的东西
[00:23:35] 就没有
[00:23:37] 就我不知道它是什么
[00:23:38] 其实我不知道它是什么
[00:23:40] 也是相当于是一个杂牌的
[00:23:42] 你看他是一个叫easy scan
[00:23:45] 不算是一个特别标准的设备
[00:23:49] 然后我就直接让告诉AI说
[00:23:53] 我就想要把这个打印机驱动起来
[00:23:56] 他都不知道
[00:23:57] 就比如说这个打印机里面有一个有一个选项
[00:24:00] 它是热转印的
[00:24:01] 就那种标签
[00:24:02] 你们看的那种贴固定资产的标签
[00:24:04] 然后那个标签它是一个碳粉袋
[00:24:06] 然后那个碳粉袋会加热
[00:24:08] 就是就相当于是在有像素的位置加热
[00:24:11] 然后把那个碳粉烫上去
[00:24:13] 这样热转印的一个打印机
[00:24:14] 然后那个热转印打印机有一个参数是
[00:24:17] 大概是加热的程度或者就是深度吧
[00:24:23] 就是图像的深度
[00:24:24] 然后我们不知道这个参数是多少意思
[00:24:26] 应该设什么
[00:24:27] 然后AI就不停的打标签
[00:24:30] 他先打一个上面有数字
[00:24:31] 比如说这是第15次尝试15
[00:24:34] 然后15
[00:24:35] 然后问我是淡了还是浓了
[00:24:36] 他看不到
[00:24:37] 但这个完全如果接个摄像头
[00:24:38] 它就可以不用
[00:24:39] 我把一个摄像头对着那个他就不需要
[00:24:41] 甚至连我都不需要他自己一张一张一张打它
[00:24:44] 就可以完全自动的把这个东西给完成
[00:24:49] 这是一个
[00:24:50] 他一开始尝试的是试试图用这个 LPD
[00:24:53] 因为能识别到这个
[00:24:54] 但是后来他发现
[00:24:55] 他可以直接用这个PCL的驱动
[00:24:57] 去一个一个generic的打印
[00:24:59] 把它当成一个通用的打印机
[00:25:01] 然后来处理好
[00:25:04] 就我就完全没有监管
[00:25:06] 我只是问他要一个结果
[00:25:08] 是一个可验收的结果
[00:25:09] agent就可以一轮一轮一轮一轮一轮的去把
[00:25:11] 去把这个事搞定
[00:25:12] 然后搞定了以后
[00:25:14] 就然后在外边一个界前端界面
[00:25:17] 我就是用嘴输出
[00:25:19] 就啊就可以
[00:25:20] 所以你看到这个软件会发生根本性的变化
[00:25:23] 最近也发布了豆包手机
[00:25:25] 豆包手机也是一个我觉得非常好的工程产品
[00:25:28] 因为它也体现了同样的软件工程智慧
[00:25:31] 他说的是我们这些app
[00:25:35] 都不重要了
[00:25:37] 这些app都不重要
[00:25:38] 如果我们有一个Jev 这样的模型
[00:25:41] 我觉得Jev和豆包手机真的是非常配
[00:25:43] 就是一个决策
[00:25:44] 但是又是接近实时的
[00:25:46] 所以我觉得他走在前面
[00:25:48] 他赌这个模型
[00:25:49] 当然可能我们也都看到这点了
[00:25:50] 就他赌模型可以在有一个时间点快到
[00:25:54] 可以和人一样快点手机
[00:25:55] 虽然当时他做这个豆包手机的时候还不能
[00:25:58] 但这件这一天很快就会来
[00:26:00] OK
[00:26:02] 所以所以他就把app抽象成了各种各样的接口
[00:26:05] 然后这个接口反正他有computer use去调用
[00:26:08] 我要点外卖
[00:26:09] 我要点外卖他就直接好应用
[00:26:12] 就沦为了一个点外卖的接口
[00:26:14] 留下了一个查询数据的接口
[00:26:16] 所以这app是不是有一天全部都要死掉了
[00:26:18] 因为他只要提供接口就行了
[00:26:21] 他提供一个API是给
[00:26:23] 是提供一个app是给人用的
[00:26:25] 但他如果只要提供一个API就可以给agent内容
[00:26:28] 所以你看到比如说阿里在疯狂做这件事
[00:26:31] 阿里在疯狂的把他的所有旗下的服务
[00:26:34] 都整合整合
[00:26:35] 像agent整整合
[00:26:37] 试图用一个千问这样的应用
[00:26:38] 当然千问我觉得有点生不逢时
[00:26:40] 他太想把这个产品推出了
[00:26:43] 然后那个时候他模型它的算力可能也不够
[00:26:45] 也没有
[00:26:47] 他们可能自己也没有一个Jev这样的
[00:26:49] 智力又足够
[00:26:50] 而且有足够快的模型来帮帮你
[00:26:52] 完成各种各样的任务
[00:26:53] 所以所以拿出来像一个未来的半成品
[00:26:56] 但是这也意味着
[00:26:57] 未来总有一天肯定肯定会来的
[00:27:00] 然后软件整个软件公司就彻底消亡
[00:27:02] 你想这个产业链上养活了多少人
[00:27:06] 多少外包公司
[00:27:08] 你在就这个标签打印机
[00:27:11] 我看
[00:27:11] 标签打印机对
[00:27:14] 我找一帧稍微好没有
[00:27:17] 没事就这样的一个标签打印机
[00:27:19] 它为了推出
[00:27:20] 就你想象你是一个
[00:27:23] 你毕业了要去想要去创业
[00:27:25] 然后你想要去创业
[00:27:27] 你说我要卖一个就找到一个细分市场
[00:27:30] 比如说你发现每一个学校都
[00:27:32] 每个单位都需要一个这样的标签打印机
[00:27:34] 那这是一个不错的市场
[00:27:35] 你可能卖几百块钱一台
[00:27:37] 还是相当有利润可赚的那硬件上
[00:27:41] 因为因为中国供应链很好
[00:27:43] 中国你基本上这种成熟的硬件你肯定能找到
[00:27:46] 找到供应链
[00:27:47] 然后你就需要软件
[00:27:48] 然后软件开发的成本
[00:27:49] 在pre-AI的时代是非常高的
[00:27:51] 它需要驱动Windows的驱动
[00:27:54] 然后Windows驱动完了以后
[00:27:55] 他还需要这个做Mac的驱动
[00:27:59] 因为因为你现在越来越多的人用Mac
[00:28:02] 然后他说Mac没驱动
[00:28:03] 它就会抱怨
[00:28:04] 然后你的产品可能就卖不了
[00:28:06] 卖卖不那么好
[00:28:07] 但是到今天全部都直接被啊AI啊杀死
[00:28:12] 比赛
[00:28:12] 你可以看一下这个label print就是一个
[00:28:19] 我都完全没管
[00:28:21] 这些都是都是AI自己啊自己生成的
[00:28:25] 他自己probe了这个
[00:28:27] 打印机的参数
[00:28:28] 和我现在当前插入的这个这个标签
[00:28:31] 完全是定制化的
[00:28:33] 也是说我想要什么
[00:28:34] 以我最舒适的方式来帮我定制
[00:28:37] 不要通用
[00:28:39] 因为以后生产软件
[00:28:40] 生产intelligence的成本会非常非常的低
[00:28:49] 好那当然这是未来会发生的事情
[00:28:52] 你们已经生在这个时代了
[00:28:53] 就已经生在软件死掉了的时代了
[00:28:55] 那为什么我们还要讲软件工程
[00:28:59] 因为曾经的软件工程不是这样的
[00:29:02] 你们透过软件工程的历史
[00:29:04] 就虽然今天确实是就你们我下一个实验
[00:29:09] 我现在还没有布置
[00:29:09] 我下一个实验就会要求大家
[00:29:12] 把你们的第一个实验的那个assistant
[00:29:15] 和一个physical device联系起来
[00:29:17] 就让它能够驱动一个任何一个你的
[00:29:20] 可能是你的手表
[00:29:22] 也可以是一个你
[00:29:23] 你就你宿舍里面任何一个已有的东西
[00:29:25] 也许是一个你就想买一个
[00:29:27] 花几200块钱买一个什么什么小设备
[00:29:30] 然后那个设备就也是非标的
[00:29:32] 他可能也没有Linux驱动
[00:29:33] 但是你就想把它搞起来
[00:29:37] 比如说我的办公室里面有一个电子墨水屏
[00:29:42] 然后电子那个电子墨水屏
[00:29:45] 他也是一个Android的app烧写
[00:29:47] 然后那个app极度难用
[00:29:49] 当然我可以用豆包手机的方式来用
[00:29:50] computer use的方式来用它
[00:29:52] 然后我当时干了另一件事
[00:29:54] 我用Claude Opus 4.6
[00:29:57] 直接把那个Android app的APK丢进去
[00:30:00] 然后让他解包
[00:30:02] 让它逆向那个蓝牙的协议
[00:30:04] 就是就因为它是还是个标准蓝牙设备
[00:30:06] 然后然后知道这个它是怎么就根据代码
[00:30:09] 怎么写到这个
[00:30:11] 怎么把这个屏写进去
[00:30:13] 然后我也得到了一个一样的这个这个这个东西
[00:30:16] 你们可以可以借助一下现在手头的啊模型
[00:30:19] 来做这样事
[00:30:21] 虽然今天我们已经生在这个时代了
[00:30:23] 但是软件软件工程的智慧
[00:30:26] 其实是没有还是没有没有消失的
[00:30:28] 所以所以从今天开始
[00:30:29] 我会讲一讲这些你看到的世界上
[00:30:32] 你看到这些软件它到底是怎么来的
[00:30:35] 我们在软件构造的历史当中
[00:30:37] 大家发明了什么
[00:30:38] 然后用这些理念可以更好的指导你
[00:30:41] 今天和agent的协作
[00:30:43] 成为一个更好的agent
[00:30:44] native的
[00:30:46] 软件开发者对
[00:30:47] 所以所以今天我来讲软件工程
[00:30:51] 首先软件工程是怎么诞生的
[00:30:54] 在软件还是一个新事物的年代
[00:30:56] 比如说我们回到1960年
[00:30:58] 虽然1960 年有点太早了
[00:30:59] 1960年的时候
[00:31:00] 硬件比码农要贵得多
[00:31:02] 他一个一个计算机就要占一个很大的房间
[00:31:06] 虽然不至于一层楼楼那么高
[00:31:07] 但是一个计算机确实会非常大
[00:31:10] 而且作为这个最先进的设备
[00:31:11] 它的制造成本也是很也是很高的
[00:31:13] 尤其尤其现在这个厂家都懂得
[00:31:16] 怎么样偷工减料
[00:31:18] 最新的消息是这个iPhone 18 Pro采用了QLC的闪存
[00:31:23] 颗粒
[00:31:24] 好像也没有关系
[00:31:25] 因为iPhone他的主张是你
[00:31:27] 你应该把所有东西都存在iCloud上
[00:31:30] 所以所以你的你的数据坏了
[00:31:32] 它也就也就这样
[00:31:34] 他不会不对你的数据负责
[00:31:36] 可能在保修期内那个闪存坏了
[00:31:38] 他就再给你换一个
[00:31:39] 换一个主板
[00:31:40] 但是你是应该把重要的数据放到iCloud上
[00:31:44] 1960年的时候
[00:31:46] 大家还不知道怎么造计算机的时候
[00:31:48] 是不敢偷工减料的
[00:31:49] 就像你刚开始造建筑的时候都是要猛堆料的
[00:31:54] 所以成本成本非常高
[00:31:56] 那码农当然也是很贵的
[00:31:57] 因为越早这个编程的工具越不成熟
[00:31:59] 这个码农是一个非常高智力需求的工种
[00:32:03] 就更像一直到那个Silicon Valley
[00:32:05] 那个电视剧里面都仍然是
[00:32:08] 仍然是这样的
[00:32:10] 我们看到今天看到了一些
[00:32:11] 可能你们现在没有了一些以前
[00:32:14] 比如说以前写汇编
[00:32:15] 写机器代码的时候
[00:32:16] 大家的要求
[00:32:17] 比如说要画流程图
[00:32:18] 你们你们现在肯定不画流程图了
[00:32:20] 因为因为那个时候你写的是机器代码
[00:32:23] 你如果不画一个流程图
[00:32:25] 你直接写机器代码
[00:32:26] 就跟今天大模型直接写汇编一样的
[00:32:28] 你看这大模型大模你可以做到
[00:32:30] 就直接二进制序列写汇编羊
[00:32:32] 但你做不到
[00:32:33] 你需要
[00:32:34] 你需要过度的预训练
[00:32:36] 才能才能才能做到这一点
[00:32:38] 同时不仅码农是一个很贵的东西
[00:32:42] 而且各位这个在985大学
[00:32:49] 认为是经历了层层筛选的高智商人群
[00:32:53] 那么你们多多少少你数学训练训练多了以后
[00:32:58] 都会缺少对客户的同理心
[00:33:00] 对商业的理解等这样的软技能
[00:33:02] 多多少少会有一点不是说这个
[00:33:05] 大家就没有
[00:33:06] 其实我见过很多
[00:33:07] 这个在各方面都很强的六边形战士
[00:33:09] 但我的观察是在理工科专业里面
[00:33:12] 更多这种nerdy的人会多多多一些
[00:33:14] 他们可能不care业务
[00:33:15] 他只想要造世界上最好的操作系统
[00:33:18] Linux那样的那样那样的人
[00:33:20] 他就不是一个很好的这个客户经理
[00:33:24] 但是软件企业依然需要承担这个把implementation
[00:33:32] spec和intent之间的gap给补上的这样的一个职责
[00:33:36] 这是公司
[00:33:36] 他作为一个公司
[00:33:37] 他需要签订合同
[00:33:39] 说我希望这个1000万美元
[00:33:41] 给你开发一个操作系统
[00:33:43] 这个这天文数字在今天看
[00:33:46] AI说我给你50 美元
[00:33:47] 我也可以给你开发一个操作系统
[00:33:49] 呵呵今天不是星期四
[00:33:51] 客户就是软件企业面对的客户
[00:33:55] 那个时候客户也不知道计算机能做什么
[00:34:00] 比如说DARPA 的官员
[00:34:01] 当然那个时候比如说NASA
[00:34:03] 可能他们工程师还会有一些有一些概念
[00:34:05] 他们要把人类送上月球
[00:34:07] 他面对的都是这样的需求
[00:34:09] 或者飞机上面要做一个飞控系统
[00:34:11] 那他们的客户可能也不完全知道
[00:34:14] 他们想要什么
[00:34:17] 然后程序员还是一个非常年轻的职业
[00:34:21] 这个Dijkstra1957年在登记结婚的时候
[00:34:23] 要登记职业
[00:34:24] 然后这个程序员不被承认为是一个职业
[00:34:28] 最后还登记成了这个理理论物理物理学家
[00:34:33] 就在那个时候
[00:34:34] 那个时候
[00:34:37] 客户已经对计算机或者说软件产生了
[00:34:41] 非常过度的遐想
[00:34:43] 然后这个是一个来自1968年杂志
[00:34:45] 我特意但这个这你可以看一下
[00:34:48] 在这
[00:34:52] 所以AI还是就是我的
[00:34:56] 我的slides是AI PPT生成的
[00:34:58] 我这里有一个有一个两个中括号
[00:35:01] 然后这个中括号就代表了
[00:35:03] 这里面的话是我教给AI的
[00:35:05] 然后AI看到了
[00:35:06] 他就会把它就这就上面是我写的
[00:35:09] 就是上面这些是我自己写的
[00:35:10] 你看他基本上是verbatim copy的
[00:35:12] 这可能会修复一下我的typo
[00:35:14] 然后像这些就是他自己发挥我
[00:35:17] 我有我的那个make slides 的 skill
[00:35:19] 自自己发挥
[00:35:20] 然后他就找到了这个
[00:35:22] Boys' Life tomorrow school
[00:35:23] 那时候大众就其实已经对计算机开始了
[00:35:26] 各种各样的想象
[00:35:28] 人是怎么样
[00:35:29] 这个终端及时判分
[00:35:31] 针对薄弱环节辅导
[00:35:33] 让学生按自己的节节奏学习
[00:35:35] 到今天都没有实现
[00:35:37] 你们还在这里上两节课
[00:35:39] 每节每节课50分钟的这个这个课程
[00:35:42] 1968年的时候
[00:35:44] 你看Boys' Life 9 月号就已经唱响了这件事情了
[00:35:49] 所以这个gap就越来越大了
[00:35:51] 在那个时候的可能一个客户
[00:35:55] 他想软件公司给他画了个大饼
[00:35:58] 然后这个客户说我要投1000万美元
[00:36:00] 做一个什么跨时代的软件系统
[00:36:02] 但他脑子里面是这样的东西
[00:36:04] 然后你回到1968年的时候
[00:36:07] 程序员脑子里是什么
[00:36:08] 脑子里就是汇编
[00:36:10] go to
[00:36:12] 那这个gap就毫无疑问是非常非常大的
[00:36:18] 然后你就是因为有这个这个gap
[00:36:21] 我们的软件是要实现物理世界需求
[00:36:24] 在信息世界里面的
[00:36:26] 投影使得软件工程和其他的
[00:36:28] 比如说像桥梁工程
[00:36:30] 这个炼钢这样的工程有很大的区别
[00:36:33] 他们的需求就是因为自然物理世界
[00:36:36] 我们只能适应
[00:36:37] 我们不能改造
[00:36:39] 就他的物理结构
[00:36:41] 这个材料的强度有多少
[00:36:43] 那在它出厂的时候就已经确定了
[00:36:45] 然后这个楼要盖起来
[00:36:47] 它要盖几层
[00:36:48] 要容纳多少人
[00:36:49] 人有多大
[00:36:51] 这都是由这个自然界选择下来的
[00:36:53] 结果已经决定了的事情
[00:36:56] 那我们只能按照自然规律
[00:36:58] 那桥就应该做成这样
[00:36:59] 一代一代一代一代迭代
[00:37:01] 所以所以他们是遵循比较强的模式
[00:37:04] 然后做一些小小改进
[00:37:06] 不断的往上创新
[00:37:07] 往上创新
[00:37:07] 往上创新
[00:37:07] 一个一个这个彻底推导的一个大的改进和创新
[00:37:11] 对他们来说是非常困难的
[00:37:12] 是一直都是比较比较incremental的
[00:37:15] 但软件不一样
[00:37:16] 软件的需求完全是拍脑袋想出来的
[00:37:18] 你看1968年的时候
[00:37:19] 他就可以想出这个东西来
[00:37:20] 那需求因为是高度定制化的
[00:37:23] 所以把它投影到计算机世界
[00:37:26] 也是一个一直以来都认为
[00:37:28] 是高度需要人类智慧的活动
[00:37:31] 我们一直说软件是人类智慧的巅峰
[00:37:35] 也确实是一个事实吧
[00:37:36] 你看像这个操作系统
[00:37:38] 编译器这些非常难的软件
[00:37:42] 你去学它都需要
[00:37:44] 确实需要这个多年的这个专业
[00:37:47] 专业积累它很复杂
[00:37:49] 然后复杂
[00:37:52] 以至于甚至你的制定就是想
[00:37:57] intent的人都没有想好
[00:37:59] 这个各种各样的corner case应该怎么样
[00:38:02] 比如说他就想做一个选课系统
[00:38:05] 那选课系统到底应该是先得先到先得
[00:38:08] 还是抽签
[00:38:09] 还是按专业保留
[00:38:10] 这都是AI给我YY出来的
[00:38:12] 不满足先修课要求的时候
[00:38:14] 老师能不能特批
[00:38:17] 这种都很容易在需求
[00:38:18] 就你在做需求的时候
[00:38:21] 我领导说跟软件公司说好
[00:38:24] 我们的这个课程是要有先修课程的
[00:38:28] 那也是知道的
[00:38:28] 你们在系统里面都能看到
[00:38:30] 比如说你要选修操作系统
[00:38:31] 你必须要先修计算机系统
[00:38:32] 基础好
[00:38:34] 那就糟糕了
[00:38:35] 这是一个硬的限制
[00:38:37] 还是一个软的限制
[00:38:38] 谁能override
[00:38:40] 最后你到最后一秒钟毕不了业的时候
[00:38:42] 所有的口子学校都能给你开
[00:38:44] 你最后就差这门课的时候
[00:38:46] 这个你马上就能选上这门课
[00:38:48] 那这就是一个例外性的需求
[00:38:51] 所以软件的需求是一个高度定制化
[00:38:53] 非常复杂的链接了
[00:38:55] 连接了物理社会人的偏好等的东西
[00:38:58] 所以做软件很难做软件
[00:39:01] 在那个时候就大家就发现了
[00:39:03] 进度成本质量是一起失控的
[00:39:05] 开发进度不能预测软件开发成本崩溃
[00:39:07] 而且要延期
[00:39:09] 延期交付
[00:39:10] 然后那个时候其实computer scientist已经观察到了
[00:39:13] 各种各样软件里面有趣的东西
[00:39:15] 比如说啊这个Dijkstra的图灵奖的Dijkstra
[00:39:19] 也是
[00:39:21] 非常有意思
[00:39:22] 叫go to statement
[00:39:24] considered harmful
[00:39:32] 我们今天不需要这个在
[00:39:36] 就这样吧
[00:39:37] 让他
[00:39:38] 让他读一下
[00:39:39] 但anyway
[00:39:40] 这个
[00:39:43] 大家都听说过go to是harmful
[00:39:45] 但你们同时也看到这个Linux内核里面有好多
[00:39:48] go to
[00:39:49] 这是C的一个为数不多的一个比较
[00:39:52] idiomatic的用法就是你最后有go to release
[00:39:55] 然后在release的时候
[00:39:56] 你会逐个检查你在函数里面申请的所有的资源
[00:39:59] 然后一一释放
[00:40:00] 这样他就可以保证保证你就你在任何时候
[00:40:04] 你在中间要申请一个资源的时候
[00:40:06] 你都在release的地方加一个释放检查和释放
[00:40:10] 然后你在写代码的时候
[00:40:12] 你永远不能在中途退出
[00:40:15] 在中途想要退出的时候
[00:40:17] 必须go to release
[00:40:18] 那这个程序就能基本上就能就能正确了
[00:40:21] 呵他有一个非常就跟我说的
[00:40:26] 没有token要退学一样
[00:40:27] 他先发表一个暴论
[00:40:28] 对他说
[00:40:29] 程程序员的水平随着go to的密度上升而下降
[00:40:34] 它其实背后是有一定的道理的
[00:40:37] 它不绝
[00:40:40] 然后肯定台还各各种告诉你应该怎么样用
[00:40:42] 用goto诶
[00:40:45] 这就
[00:40:49] 这就go to statement considered harmful
[00:40:52] 这个这个大家在学编程的时候都学过
[00:40:55] 因为大量的goto会让你的程序变得很难理解
[00:40:58] 所以他讨论的其实不是go to
[00:41:00] 到底harmful不harmful
[00:41:02] go to可以不harmful
[00:41:03] 如果作为一个正确的机制使用的话
[00:41:06] 只允许你这样用
[00:41:07] go to它就不 harmful
[00:41:08] 它挺好的
[00:41:09] 它解决了C语言里面一个很大的
[00:41:12] 你随时申请从不释放的问题
[00:41:14] 你们在做OJ的时候留下的坏习惯
[00:41:18] 那他背后考虑的是这样的一个
[00:41:20] 一个希希望你能够写出人能读的代码
[00:41:26] 那只有你人能读
[00:41:27] 它才有可能能够维护的下去
[00:41:29] 从而OK让这个世界还能够正常的
[00:41:35] 软件世界能够相对来说正常一点的
[00:41:38] 去运转OK
[00:41:41] 然后在1972年的时候也
[00:41:54] 有他的这个Turing Lecture
[00:41:57] 就是他得图灵奖以后的这个演讲
[00:42:03] 叫The Humble Programmer
[00:42:05] 然后我觉得这就现在很好
[00:42:07] 我们可以直接去消这个digest原始的文稿
[00:42:13] 我们可以在AI的帮助下直接去阅读
[00:42:20] 原始的文稿
[00:42:22] 你看他就谈到了这个为什么会有软件危机
[00:42:27] 如果你永远写这个online judge的小程序
[00:42:31] 就不会有软件危机的
[00:42:32] 你就算一个东西
[00:42:34] 算完就完了
[00:42:35] 你一旦把这个程序调对
[00:42:36] 你就永远不需要去维护它
[00:42:41] 但是机器变强以后
[00:42:43] 你的软件的需求是不断的膨胀的
[00:42:46] 然后你要承担越来越多
[00:42:47] 就你机器越强
[00:42:49] 你承担这个现实世界的intent越多
[00:42:51] 然后intent越多
[00:42:52] 这个不确定性就越多
[00:42:53] 然后实现就会变得越复杂
[00:42:55] 然后越来越复杂以后
[00:42:56] 这个
[00:42:58] 应该
[00:43:00] 应该怎么样
[00:43:02] 然后他提了一些这个他对软件的思考
[00:43:05] nicely factored solutions
[00:43:07] 然后就这样的想法
[00:43:09] 在你构造任何软件系统的时候
[00:43:12] 都在不断的发现
[00:43:14] 就比如说你看我就写一个这个live mate
[00:43:19] 帮我驱动我的标签
[00:43:21] 打印机和扫描仪
[00:43:22] 它也是一个nicely factor的solution
[00:43:25] 一个良好的分解
[00:43:26] 我们无时无刻都在用这样的这个想法
[00:43:30] 来组织啊我们的软件
[00:43:35] 然后他还有一些有意思的这个观点
[00:43:38] 保守力量主要来自教育机构与
[00:43:40] 舍不得重写旧程序序的用户对
[00:43:44] 这都是放到今天
[00:43:45] 依然是你
[00:43:46] 你觉得能够啊觉得醍醐灌顶的这个
[00:43:50] 确实Dijkstra那个时候1972年执一个
[00:43:53] 只一个图灵奖对
[00:43:54] 然后在那个时候其实就大概就在那个时期
[00:43:57] 软件工程就会就成为了大家关注的一个焦点
[00:44:00] 因为软件开始开始失败了
[00:44:02] 所以在1968年的时候
[00:44:04] 有一个NATO软件工程的会议
[00:44:06] 你们也可以去直接去读这个
[00:44:08] 原原summary
[00:44:09] 我就我就不读了
[00:44:10] 我就我就开一个开这个
[00:44:13] 让他再在后台后后台跑起来
[00:44:18] 然后也他们差不多在那个时候
[00:44:20] 这个Hamilton和他的团队
[00:44:24] 提出了软件工程这样的啊概念
[00:44:28] 这个帖子我觉得大家也可以读一下
[00:44:31] 这是一个非常有标志性的照片
[00:44:32] 在诶
[00:44:39] 应该是载入载入史册的
[00:44:42] 照片
[00:44:43] Vista polo code
[00:44:44] 1969
[00:44:45] 这个Apollo的
[00:44:48] 代码uh sorry
[00:44:56] 然后我们也可以
[00:45:02] 让他来读一下
[00:45:03] 这个可能要读一下
[00:45:04] 这个代表了软件工程学科的啊诞生
[00:45:11] 2019年8月
[00:45:13] 经过不懈的排查错误
[00:45:15] 这位最初的软件工程师把宇航员啊送上了月球
[00:45:19] 然后他有一个这个他的传记
[00:45:25] 然后这个软件工程
[00:45:28] 你们看到今天你们都要防御性编程
[00:45:30] 你们在第一节
[00:45:31] 比如说学SICP的时候
[00:45:32] 他就告诉你写软件的时候
[00:45:33] 你要写他的assertions
[00:45:35] 写specifications
[00:45:39] 他把一个绝对不能发生的假设都当成可能
[00:45:43] 一种防御性的为未来思考的这样的一个智慧
[00:45:47] 他假设这个软件在在在任何时候
[00:45:49] 他都要甚至违背违反假设
[00:45:52] 说这个软件依然要能够能够工作这个
[00:46:00] 他才设计了一个成功的成功的软件
[00:46:05] 那我们也可以让他这个
[00:46:11] 啧
[00:46:13] 如当然我不确定他会不会做web search
[00:46:16] 就DeepSeek有没有没有足够的知识
[00:46:18] 如果是一个足够大的模型的话
[00:46:21] 他可以去做
[00:46:22] 他可能去做web search
[00:46:23] 它可能在在这里
[00:46:25] 就有对
[00:46:28] The never going to happen
[00:46:30] Can happen
[00:46:31] 我觉得这就是你看软件工程
[00:46:33] 当当我们回头去看这个原作的时候
[00:46:38] 你发现这些思想在今天反而更容易理解
[00:46:41] 比这个教科书上面经过了好多层的这个一手
[00:46:45] 二手三手四手消化的
[00:46:47] 时候要这个
[00:46:50] 要好得多
[00:46:52] 然后他比如说你可能要假设
[00:46:54] 这个硬件也是不可靠的
[00:46:58] 然后
[00:46:59] 我无论如何
[00:47:00] 都要在这个软件里面做一个兜底的机制
[00:47:03] 当你的程序crash了以后
[00:47:05] 这个整个系统依然要啊能够工作
[00:47:08] 其实这就是软件工程的起点对
[00:47:11] 所以你看这里有一个能工作
[00:47:13] 还包括发生意外的时候就有一个
[00:47:17] 登月阿波罗11登月下降的时候发生警报
[00:47:21] 然后但是这个软件因为有这个优先级和和recovery
[00:47:25] 让关键的下下降控制任务得以继续
[00:47:27] 就那个时候还没有软件工程的时候
[00:47:29] 他们就从first principle去思考
[00:47:32] 如果
[00:47:33] 如果我们这个时候要构造一个真正好的
[00:47:36] 高质量的软件
[00:47:37] 我们应该应该怎么做
[00:47:39] 它的the first principle就是这个never going to happen
[00:47:43] can happen
[00:47:44] 好有意思
[00:47:47] 软件软软件的工程
[00:47:49] 然后这就这然后在这个意义下
[00:47:51] 这个软件工程就诞生了
[00:47:52] 就在那个差不多那个时间点
[00:47:54] 因为在时成本时间
[00:47:57] 各种各样团队的约束下
[00:47:59] 交付软件
[00:48:00] 在那个时候已经成为了一个很大的挑战
[00:48:03] 那怎么样做这件事
[00:48:04] 就是软件工程
[00:48:07] 在成本时间约束下
[00:48:08] 把人的意图
[00:48:09] 人的意图
[00:48:10] 你想要设计你要做的产品或者是客户的要求
[00:48:13] 变成一个可以工作的
[00:48:15] 可以维护的
[00:48:16] 可以生存的
[00:48:18] 你随着时间的推演的需求可能会变化
[00:48:21] 这个never going to happen
[00:48:23] 有点这个感觉吗
[00:48:24] 你们你们做OJ的时候
[00:48:26] 你假设题目是对的
[00:48:30] 这是一个隐藏的假设
[00:48:31] 你假设题目是对的
[00:48:32] 假设题目是能做出来的
[00:48:33] 这个本身假设就是不对的
[00:48:35] 就当你反复强化的时候
[00:48:37] 你overfit这个假设的
[00:48:39] 你应该假设的是
[00:48:40] 你面对的是一个开放的世界
[00:48:41] 这个题目可能是错的
[00:48:43] 这个题目的条件随时可能会变化
[00:48:45] 这个题目甚至可能会变成另外一个题目
[00:48:48] 那你怎么做一个软件来解决它
[00:48:52] 当然编程是一件事
[00:48:54] 你通过训练这个online judge
[00:48:55] 训练的是你的逻辑思维
[00:48:56] 算法思维
[00:48:57] 这个你的chain of thought能力
[00:48:59] 当然对于设计软件理解
[00:49:00] 比如说理解这些东西是有是有好处的
[00:49:04] 所以你看到这个
[00:49:05] IEEE
[00:49:06] 他说是把工程
[00:49:08] A systematic discipline quantifiable
[00:49:11] Approach to the development operation and maintenance of software
[00:49:14] That is application of engineering
[00:49:16] 工程化
[00:49:17] 它把它把软件变成一个你
[00:49:19] 你不再是一个个人英雄主义
[00:49:22] 那个时候Hamilton的那个时代
[00:49:23] 他需要一个好的leader
[00:49:25] 就如换一个人
[00:49:26] 这个项目就失败了
[00:49:28] 变成可以拿到一个checklist
[00:49:30] 这个checklist
[00:49:31] 如果你123456789十全部都满足了
[00:49:34] 那你至少这个软件可能不能保证你的软件成功
[00:49:37] 但是失败的概率会小很多
[00:49:41] 有纪律可量化覆盖整个软件的整个生命周期
[00:49:46] 对所以在AI还没有大杀四方的时代
[00:49:50] 软件工程这个学科
[00:49:52] 从刚开始的大量的失败
[00:49:54] 或者说是从数亿美金的教训得到的
[00:49:59] 什么炸一个火箭这种
[00:50:00] 很多时候都是可能是跟软件工程有关系的
[00:50:03] 既其实积累了很多的智慧
[00:50:06] 大家看到成成功
[00:50:08] 看到失败
[00:50:08] 多多少少就会从中总结出一些经验和和教训
[00:50:12] 然后当然如果我们回到这个pre-AI时代
[00:50:14] 大家其实也非常清楚这个intent spec implementation
[00:50:18] 这样的这样的gap
[00:50:20] 如果你接到一个开发任务
[00:50:22] 你肯定不能立即按照去安排说哎
[00:50:24] 大家去干吧
[00:50:26] 任何一个leader都不应该干这样的事儿
[00:50:29] 即便最终的产物一定是码农
[00:50:33] 写出来的
[00:50:33] 因为不同的人他看到的是不一样的部分
[00:50:36] 甚至如果这个软件要分分开的话
[00:50:40] 你的leader都需要指派哪一个部分
[00:50:43] 由哪一个人来人来做
[00:50:45] 就像我做这两个的时候
[00:50:46] 打印机和扫描仪
[00:50:47] 那个时候我已经同时接到我的电脑上了
[00:50:50] 那我就是起了两个agent
[00:50:53] 开了两个窗口
[00:50:53] 一个取景像打印机
[00:50:54] 一个取景像扫描仪
[00:50:56] 这很这很这很正常
[00:50:58] 需要一个划分任务的这样的过程
[00:51:01] 不能是一个self self organized
[00:51:04] 那如果我们涉及到划分任务
[00:51:07] 也就是说刚开始我们从一个
[00:51:10] 空的repo的时候
[00:51:11] 空的 repo的时候
[00:51:12] 那我们怎么样去做
[00:51:16] 是直接去开发
[00:51:17] 就直接把这个一句话交给他做MVP
[00:51:19] 那个时候还没有这个minimum
[00:51:21] 你想1970年
[00:51:22] 这是1970年的论文
[00:51:24] 1970年的时候
[00:51:25] 软件工程这个刚刚诞生
[00:51:27] 还没有minimum
[00:51:30] Viable product
[00:51:30] 没有大语言模型
[00:51:32] 那一个思考怎么按时不超预算的交付大型软件
[00:51:37] 那就有一个软件工程领域的开山之作
[00:51:40] 这个Winston Royce的Managing the development of large software systems
[00:51:45] 然后今天你们
[00:51:46] 有些同学可能学过这个软件工程
[00:51:49] 这门这门课
[00:51:50] 然后你们可能学过哎
[00:51:52] 我可以开个浏览器
[00:51:56] 应该多多少少一定是我们搜索百度诶
[00:52:04] 诶好
[00:52:08] 搜索一个瀑布模型
[00:52:11] 我觉得大家如果学过任何学过一点软件工程
[00:52:17] 我就我就不打开秒懂百科了
[00:52:19] 这个有点搞笑
[00:52:21] 放大一些
[00:52:23] 都有一个这样的
[00:52:25] 就你们见过很多时候见过这样的
[00:52:30] 见过这样的图
[00:52:31] 大概长这样
[00:52:32] 图一个waterfall model
[00:52:34] 从上从上到下
[00:52:35] 你们只要是computer science或者software相关的
[00:52:39] 你们一定在软件工程课上面见过
[00:52:43] 见过这样的图
[00:52:44] 然后这个图来自哪里
[00:52:46] 这个图就来自这个
[00:52:48] Winston Royce的这一篇经典的文章
[00:52:51] 当然你看我
[00:52:52] 我读文章的方式
[00:52:53] 和你们读文章的方式有些不一样
[00:52:55] 这个是我昨天在备课的时候
[00:52:59] 我需要这篇文章
[00:53:00] 我就直接找到了这篇文章的链接
[00:53:02] 然后直接和我的agent说入库这个paper
[00:53:06] 然后你我就得到了这个
[00:53:08] 这是一个文字文字整理版的
[00:53:11] 我记得我给大家可能展示过一次
[00:53:13] 啊read space
[00:53:17] 我可能没有在这个课
[00:53:18] 好像没有在这个课上展示过
[00:53:19] 比如说这个article70
[00:53:25] 他是个这样的
[00:53:26] 我暗夜切割
[00:53:27] 就我的AI梗同学
[00:53:28] 然后会把所有的图片
[00:53:30] Markdown的图片都直接嵌入嵌入进来
[00:53:33] 然后我有一些工具
[00:53:34] 比如说我有一个命令行的工具可以去
[00:53:40] 我有一个命令行的工具可以去唉
[00:53:43] 这个有点宽
[00:53:44] 可以可以去打印文本
[00:53:46] 也可以去提取图片等
[00:53:47] 也有一个这个类似于less的工具
[00:53:50] 这是vibe code的
[00:53:50] 就我什么也没有说
[00:53:52] 来帮我
[00:53:55] 帮我去解去
[00:53:57] 直接在命令行里面读论文
[00:54:00] 然后瀑布模型就来自来自这里
[00:54:04] 瀑布模型
[00:54:05] 然后实际上啊实际上有意思
[00:54:09] 最有意思的是我们都讲
[00:54:12] 比如说软件工程学
[00:54:13] 学软件工程师都学瀑布模型
[00:54:14] 可实际上这篇文章是批判瀑布模型的
[00:54:18] 所以你还得就是这种还得还得去原文
[00:54:23] 就当一个东西好多次
[00:54:26] 这个经过了消化以后
[00:54:28] 你得到的东西可能就不是那个东西了
[00:54:30] 因为其实在那个时代对
[00:54:33] 1970年大家真的是只什么也没有
[00:54:36] 只能从first principle去思考
[00:54:38] 这个in space好
[00:54:49] 啧我直接让他帮我读这个
[00:54:54] 对我有一个rise scale
[00:54:58] 试一下
[00:55:06] 需要一点点的时间
[00:55:07] 没事我们我们继续读
[00:55:09] 如果你看到这
[00:55:10] 那这就是一个经典的瀑布模型
[00:55:12] 你看啊需求到系统的需求
[00:55:16] 软件的需求分析设计代码测试
[00:55:19] 然后去上线
[00:55:22] 上上线
[00:55:23] 因为哎我有一个这个
[00:55:26] 但这个我还没还可以继续
[00:55:28] 继续调
[00:55:30] 你看他说后被称为瀑布模型的原始出处
[00:55:33] 也是被误读最严重的一篇
[00:55:35] 所以应该是一个最早可能有一两个article它错误的
[00:55:39] 就没有没有描述所有的这个文章里面的
[00:55:43] 观点
[00:55:46] 然后我给了一个
[00:55:48] 他我还可以重述
[00:55:50] 在现代意义上重重述
[00:55:52] 说一个程序小到能被践踏的人
[00:55:55] 自己用两步就够了
[00:55:57] 所以你看这就是你们的online judge
[00:56:01] 如果你站在今天的
[00:56:03] 就是你站在今天你做的所有的软件的practice
[00:56:06] 你依然很能够很好的对上对上这个文章里面
[00:56:11] 当时他们的一些思考
[00:56:13] 这个这个OK没问题
[00:56:15] 但是但是啊这个很容易失败
[00:56:20] 如果啊如果你把这样的一个流程
[00:56:22] 扩展到这样的一个瀑布
[00:56:24] 瀑布模型是因为测他的观点
[00:56:28] 因为测试是整个链条上第一个物理事件
[00:56:31] 就你在你在设计的时候
[00:56:34] 你有报告
[00:56:34] 然后你在这个program真正被写出来之前
[00:56:37] 它都是不能运行的
[00:56:39] 这是一个first principle
[00:56:41] 也就是说当这种不能运行的东西在的时候
[00:56:44] 你都会随便做
[00:56:46] 这就是人
[00:56:47] 文档反正文档文档你我就你叫我写文档
[00:56:51] 我就写一个
[00:56:52] 你们你想你们写这个实验文档的时候
[00:56:57] 你们对它的正确性有guarantee吗
[00:57:01] 当然有同学会认真一点
[00:57:03] 或者说我有个best effort guarantee
[00:57:05] 但实际上你是没有guarantee的
[00:57:06] 你文档或者先写就写了
[00:57:08] 然后写的就放在那
[00:57:09] 然后可能你代码改了
[00:57:11] 设计改了
[00:57:11] 文档不一致
[00:57:12] 也就放在那
[00:57:13] 所以这些东西是没有这个一个很强的这个约束
[00:57:17] 在很强约束下做的
[00:57:18] 然而只有在你测试的时候
[00:57:21] 这个程序才真正跑起来
[00:57:23] 你才真正知道他的行为是什么
[00:57:25] 虽然你可能在这个编码的时候
[00:57:29] 就已经感觉到可能有一些有一些不对了
[00:57:32] 但是但是一旦你的
[00:57:35] 比如说你的从intent到specification到implementation
[00:57:40] 发生了漂移
[00:57:41] 你到测试的时候再发现的时候
[00:57:44] 就意味着你要回头去
[00:57:46] 这我记得应该也有一个图的
[00:57:48] 你要回头去这个回到前面去修改
[00:57:51] 那这个就会带来成本
[00:57:53] 所以就是超期或者超支的源头
[00:57:57] 你看到你看这些图
[00:58:00] 就如果你真的读过原文
[00:58:02] 读过原文
[00:58:03] 他很好理解
[00:58:04] 而且非常的就你站在今
[00:58:07] 尤其你今天有今天的软件工程实践以后
[00:58:09] 去理解它其实非常的非常的舒服
[00:58:12] 既然风险最终都在测试的地方爆炸
[00:58:15] 那所有的补救的本质
[00:58:17] 都是把发现问题的时间点提前
[00:58:21] 就非常自然的一个想法
[00:58:24] 设计先行文档做两遍
[00:58:26] Doing it twice
[00:58:27] 这个是它里面的一个
[00:58:30] 一个非常非常经典的观点
[00:58:35] 对应该是对这个词
[00:58:38] 你看他用了
[00:58:39] 我这里总总结了一下叫preliminary pilot program
[00:58:46] 他说我们先要做一个不完备
[00:58:49] 但是能够体现这个系统功能的设计
[00:58:53] 然后再把这个这个东西可能会失败
[00:58:56] 但它迭代的成本会变得很低
[00:58:58] 迭代成本变得很低
[00:58:59] 他就可以去reflect到这个系统的设计上
[00:59:03] 然后你看这是什么
[00:59:04] 这就是minimum viable product
[00:59:07] 然后然后他有各种各样的模型
[00:59:09] 他后面应该在论文的最后可能是这个对
[00:59:12] 就是就是他所想的一个software development model
[00:59:17] 然后你就算是在今天这个vibe coding的时代
[00:59:20] 你回去它还是提供了很多的软件工程的智慧
[00:59:25] 即便他在那个时候是在
[00:59:27] 比如说像航天器的任务规划
[00:59:30] 把人送上月球
[00:59:31] 在这些背景下写的
[00:59:35] 写的程序
[00:59:36] 瀑布模型
[00:59:37] 它他先提出的这个瀑布模型
[00:59:39] 然后说了
[00:59:40] 这个瀑布模型在软件工程中是怎么失败的
[00:59:43] 他分析了一个具体的失败
[00:59:44] 然后这个流程在今天开发软件时
[00:59:48] 也是完全一样的
[00:59:48] 因为你总是从空的项目开始
[00:59:51] 不管你是用什么样的版本控制工具
[00:59:53] 你都需要经历先想清楚你要干什么
[00:59:57] 然后再大概想我架构应该怎么做
[01:00:00] 再去写代码
[01:00:01] 不管这个写代码的是软件工程师还是AI
[01:00:05] 这个流程依然是成立的
[01:00:07] 所以他的这个都是成立的
[01:00:10] 所以你看到了这个在现在AI的时代
[01:00:15] 每个人都可以阅读一手的信息
[01:00:17] 你可以直接回到这个历史的背景上
[01:00:19] 而且AI既知道过去
[01:00:20] 又知道现在你还有那个历史的原文
[01:00:23] 然后你会发现有些东西你在书上读不懂的
[01:00:26] 就你两页纸
[01:00:27] 那个书看起来不长
[01:00:28] 两页纸
[01:00:29] 讲瀑布模型读了两遍还没搞懂
[01:00:32] 然后你回去看这个原文
[01:00:33] 马上就看懂了
[01:00:35] 所以知识的压缩就是过去过去
[01:00:39] 比如说像我上学的时候或者再早的时候
[01:00:42] 这个如果你要查证一个知识网络
[01:00:45] 是几乎不可能的事情
[01:00:46] 你要去图书馆翻很多的资料
[01:00:48] 图书馆的索引机制建的也不好
[01:00:50] 虽然图书馆确实也有索引机制
[01:00:52] 如果你要找到那个精确的资料
[01:00:54] 你要花去无穷多的时间
[01:00:56] 所以你那个时候
[01:00:57] 你是不可能通过一手资料来学习的
[01:01:00] 你必须要经过教科书做知识的有损压缩
[01:01:03] 那有经验的人会
[01:01:05] 所以大家就是有的教科书写的好
[01:01:07] 有的教科书是防自学的
[01:01:08] 教科书写的好的人
[01:01:09] 他就可以
[01:01:11] 他读过一手的信息
[01:01:12] 他也他可能也能共情
[01:01:14] 我觉得好的
[01:01:15] 好的老师可以共情学生
[01:01:16] 他知道学生想要什么
[01:01:18] 学生什么地方会不明白
[01:01:19] 所以他把这一手的信息做一个压缩
[01:01:21] 同时对于阅读者的损失是很小的
[01:01:25] 但今天这些东西也都不要了
[01:01:27] 因为你可以直接就说我作为一个
[01:01:31] 我作为一个老师
[01:01:33] 我觉得我不需要再做压缩
[01:01:35] 因为我做压缩对每个人的压缩都是有损的
[01:01:39] 而且对不同人压缩损失了不同的部分
[01:01:41] 如果我一对一的教学
[01:01:43] 我就可以做最合适你的压缩
[01:01:45] 但不需要你现在直接对着你的圆
[01:01:50] 我只要把这个知识的脉络
[01:01:52] 把知识拆解开来
[01:01:53] 拆解成很多的
[01:01:54] 这个我好像有一次课的时候讲过我
[01:01:56] 我怎么理解这个世界的知识
[01:01:59] 把知识拆成一个一个的发现的点
[01:02:01] 然后把这个你只需要把这个点和它的原文拿到
[01:02:05] 然后做一个属于你自己的压缩就可以了
[01:02:09] 所以有些有些东西
[01:02:10] 比如说我们花了很大的代价去
[01:02:14] 比如说我的
[01:02:16] 我们有很多这个导师
[01:02:17] 老师也在这个这个计划里去建设
[01:02:21] 这个比较先进的课程
[01:02:23] 然后很然后我觉得比较比较有趣的一件事
[01:02:27] 是这样的
[01:02:29] 这个其实是个很好的计划
[01:02:30] 因为在在查证知识网络非常费时的时候
[01:02:35] 如果有真正的专家能能够帮你做好的压缩
[01:02:39] 那这种毫无疑问是有价值的
[01:02:41] 但是在AI的时代就是AI是摧毁性的对一
[01:02:45] 整个领域
[01:02:47] 你可能在里面投入了这个百万千万
[01:02:51] 甚至上亿的人民币
[01:02:52] 但最后都是一个模型
[01:02:53] 就把你轮子就碾就碾掉了
[01:02:55] 一个可能是个DeepSeek这样的
[01:02:57] flash这样的模型刚才在帮我
[01:03:00] 你有任何的问题我都可以直接问他
[01:03:07] 比如说你能了解一下
[01:03:11] 解释一下这个瀑布模型在软件工程里
[01:03:17] 到底是为什么怎么误读了
[01:03:21] 你会产生疑问产生疑问
[01:03:26] 然后你就直直接跟他跟他对话
[01:03:28] 然后他可以在这个过程当中
[01:03:30] 注意找到更多的原文
[01:03:33] 找到甚至找到这个整个误读的链
[01:03:36] 怎么样
[01:03:36] 这个教材一级一级一级一级一级
[01:03:38] 最后最后到一个你手上拿的这个软件工程
[01:03:41] 灌水教材上面是怎么一步一步的
[01:03:49] 曲解这个诶他有一呵
[01:03:59] 哼这个解释还挺挺make sense的
[01:04:02] 虽然可能也许你也许选择不相信AI再去追问
[01:04:05] 或者用一个更好的模型让它联网更好
[01:04:07] 瀑布好话好背好
[01:04:08] 出题可以作为第一个模型讲
[01:04:10] 然后而且这个每一个新方法都说这个
[01:04:14] 瀑布是这个史上最好用的反派
[01:04:16] 哎他说的很
[01:04:17] 就真的是这样
[01:04:19] 因为本身他就是错的
[01:04:21] 本身这个1970年的文案已经告诉你
[01:04:23] 不能瀑布
[01:04:23] 就1970年就告诉你要做MVP呵
[01:04:28] 而且确实不成熟
[01:04:31] 虚构
[01:04:31] 在在在这里对
[01:04:34] 挺好的
[01:04:35] 有意思对这是这是关于这个这个文章
[01:04:42] 当当然我已经带着大家读过这个文章了
[01:04:44] 所以这几页就AI生成的
[01:04:46] 也不那么重要了
[01:04:48] 里面文章告诉我们叫do it twice
[01:04:50] 一个很重要的工程理解
[01:04:52] 但今天就是做
[01:04:54] 做MVP
[01:04:55] 那其实你也可以在不同的各种各样的
[01:04:58] 现在的软件开发的背景下去了解
[01:05:02] 比如说那如果我们用TDD叫test driven development
[01:05:07] 叫叫这个测试驱动开发
[01:05:10] 去理解这个工作
[01:05:14] 如何解释
[01:05:15] 如何用这个工作来解释TDD
[01:05:19] 他都是互相的
[01:05:20] 我们今天的概念
[01:05:23] 就今天正确的practice可以映射到过去
[01:05:26] 然后过去正确的这个first principle
[01:05:28] 也可以用来映射到今天
[01:05:30] 我们来看这个
[01:05:32] 一个7B的小模型是什么样的
[01:05:37] 说Royce 他讲了一件事
[01:05:39] 他说缺陷被发现的时间
[01:05:42] 越晚它带来的返工代价就越大
[01:05:45] 显然这个事是成立的
[01:05:47] 就跟你们做OJ都会出现这个事
[01:05:50] 你们一开始的时候脑子一热
[01:05:52] 想一个算法
[01:05:52] 这个算法不对的
[01:05:54] 然后就去写代码了
[01:05:55] 写代码写完以后发现样例不对
[01:05:57] 然后你对着样例跑了你的那个算法
[01:05:59] 你发现哎呀完了我这个算法整个就错了
[01:06:02] 这就是呵
[01:06:04] 这就是一个典型的瀑布模型的失败
[01:06:06] 然后你在TDD的意义上
[01:06:09] 你看设计先行
[01:06:11] 那你设计先行的时候
[01:06:13] 你就干脆你就先把测试用例定好
[01:06:16] 你输入这个它就应该经历这个流程
[01:06:19] 输出这个
[01:06:20] 然后你马上就对
[01:06:21] 还有一些敏捷开发等的概念
[01:06:23] 就可以用上了
[01:06:24] 所以实际上实际上这个
[01:06:30] 现在做的事情不完全颠覆过去的经验
[01:06:33] 这些老的东西我一直说这个我很喜欢这些
[01:06:37] 很多图灵奖的工作
[01:06:39] 他为什么能得图灵奖
[01:06:40] 就是因为他确实是在一个
[01:06:42] 完全大家不知道的情况下
[01:06:44] 确立了一个first principle
[01:06:46] 告诉大家这件事情应该这么做
[01:06:48] 不仅是图灵奖
[01:06:48] 就这个就这个奠定了软件工程基础的
[01:06:52] 这个Royce 的这个
[01:06:54] 瀑布我们叫它瀑布模型
[01:06:56] 开玩笑叫瀑布模型的paper
[01:06:58] 不是瀑布模型
[01:06:59] Managing the development of large software systems
[01:07:01] 这样的一个经典的文章
[01:07:03] 他就给我们很多的启发
[01:07:05] 在它上面长出了这个世界的很多分支
[01:07:08] 当然也有更多好玩的是
[01:07:09] 你有一天发现他一开始有个地方方向想错了
[01:07:12] 然后把全人类都带歪了
[01:07:14] 如果全人类从某一点开始
[01:07:17] 这个能够换一个方向
[01:07:20] 那这个全人类
[01:07:22] 也许就立即快速走上了正确的道路
[01:07:24] 比如说直流电和交流电
[01:07:26] 爱迪生和这个特斯拉OK
[01:07:29] 这是three twice
[01:07:31] 然后你也可以用敏捷开发去理解这个
[01:07:34] do do it twice
[01:07:36] 你不需要把pilot理解成一个完整的流水
[01:07:40] 而是所谓的敏捷就是你的第一个版本
[01:07:44] 你不是doing it twice
[01:07:45] 你是你是doing it
[01:07:46] Infinite many times
[01:07:47] 你上来第一个版本
[01:07:50] 哪怕它只有一个hello world
[01:07:51] 它只是
[01:07:52] 打印一个你的流
[01:07:54] 或者说就是每个模块都自报一下家门
[01:07:56] 能把这个模块串起来
[01:07:58] 这也是一个好的product
[01:08:00] 然后在在这个意义上不断的把软件向后
[01:08:04] 向后向后演进
[01:08:06] 让关键假设尽早遇到证据
[01:08:09] 你一开始不确定的东西
[01:08:11] 立即因为你有一个原型了
[01:08:14] 有一个敏捷的原型了
[01:08:15] 你就可以立即验证它
[01:08:16] 所以你看这个first principle
[01:08:18] 在这么多年软件工程发展的实践当中
[01:08:22] 都还是存在的
[01:08:23] 所以说AI第一个AI来的很焦虑
[01:08:26] 就是AI确实学会了AI
[01:08:27] 也许他品味有一天也学会了
[01:08:30] 就他可以从这些论文里面学到这个品味
[01:08:32] 那我们很焦虑AI能帮我们做事
[01:08:35] 但是我们仍然
[01:08:37] 或者说现在人类还有一种傲慢
[01:08:40] 觉得我们还是希望能够理解AI到底做了什么
[01:08:43] 能够判断AI到底做的
[01:08:45] 就真的到那一天
[01:08:46] AI做的所有东西都是都是远超人类
[01:08:49] 都是对的
[01:08:49] 然后就只有人会犯错误
[01:08:51] AI不会犯错误的时候
[01:08:52] 那
[01:08:53] 那就那就我们就没有
[01:08:54] 我们就不要去理解它了
[01:08:55] 我们也理解
[01:08:56] 可能也放弃就去放弃理解它
[01:08:58] 但至少在今天
[01:08:59] 这AI虽然才智在增长
[01:09:01] 但我们还是至少能驾驭
[01:09:05] 能理解AI的人能活下来
[01:09:07] 那大家在这个斩杀线上上升的基础上
[01:09:09] 你就知道我们怎么样用好AI怎么样
[01:09:13] 去理解这个里面的软件工程的啊智慧
[01:09:16] 那我是怎么理解这个啊Royce 的这个pilot的model
[01:09:21] 我因为我是一个computer science的人
[01:09:25] 我们往前一点
[01:09:27] 对坎贝尔3141点
[01:09:28] 然后我说
[01:09:32] 我把这个Royce 的模型理解成一种data dependency
[01:09:39] 然后修改是有代价的
[01:09:42] 这样可以吗
[01:09:44] 你就可以跟他跟他聊
[01:09:45] 当然这是我自己的理解
[01:09:47] 我觉得还是还是自洽的
[01:09:48] 你看这个瀑布的模型
[01:09:51] 他说从需求分析到系统设计
[01:09:53] 到系统实现到测试验证到交付维护
[01:09:55] 你可以把它想象成每一个过程
[01:09:57] 都想象成是一个program
[01:09:59] 就人
[01:09:59] 我现在把人想象成程序
[01:10:01] 人和程序就是等价的
[01:10:03] 我的人脑人
[01:10:04] 我就神经网络
[01:10:04] 然后我可以我可以做chain of thought
[01:10:07] 我也学会了
[01:10:08] 我先学会了语言
[01:10:09] 我学会了说话
[01:10:10] 然后你们在内心
[01:10:12] 我不知道你们是怎么样的
[01:10:13] 至少我自己在想问题的时候
[01:10:15] 我还是会对齐到语言上
[01:10:17] 我哪怕不说话
[01:10:18] 我依然会说
[01:10:19] OK我要我要这样或者怎么样怎么样
[01:10:21] 这样会有什么样的后果
[01:10:22] 我还是用语言来对齐
[01:10:23] 我的我的内脑内的这个思维链的思考思考的
[01:10:27] 所以chain of thought 是一个我觉得很有意思的机制
[01:10:30] 然后这就是一个如果你把它产生程序和artifact
[01:10:34] 那就是一个data dependency graph
[01:10:36] 他是一个有向无环图
[01:10:38] 如果我在就我可以把这个稍微展开一点
[01:10:40] 比如说我在做需求的时候
[01:10:42] 我需求里面有好几个点
[01:10:44] 这些当然也有之间可能也有相互的关联
[01:10:46] 那有些可能是没有关联的
[01:10:47] 那我在做设计的时候
[01:10:49] 我的这个设计可能就和这些需求的点是关联的
[01:10:52] 我做的这个设计
[01:10:53] 然后我做这个设计又是关联的
[01:10:56] 又是关联的
[01:10:57] 然后这个关联关系会传递
[01:11:00] 关联关系会传递
[01:11:03] 诶然后我有一个这样的这个data
[01:11:06] Flow graph
[01:11:08] 那就意味着如果我这种一头扎下来一旦发现
[01:11:14] 所以你看跟这跟这个跟 Royce的解释
[01:11:16] 又是又是一样的
[01:11:18] 如果一旦发现这个test错了
[01:11:21] 然后错了
[01:11:22] 如果我们一路往上追溯
[01:11:24] 发现这个这几个design错了
[01:11:27] 那就惨了
[01:11:28] 所有依赖他的东西全部都毁掉了
[01:11:31] 所以这就解释了为什么cost 很高对
[01:11:36] 所以你看你可以用自己的每一个人
[01:11:38] 就我相信每一个人对这个模型的理解
[01:11:41] 都是都可以是不一样的
[01:11:44] 也就是为什么我们非常需要这个一个
[01:11:49] 非常非常需要一个个性化的教学
[01:11:52] 每一个人都有自己的diversity
[01:11:55] 他成长的经历不同
[01:11:56] 然后我就觉得
[01:11:57] 因为我是做还算是一个做过一点PL的
[01:12:01] 操作系统人
[01:12:02] 所以我就用会很自然的用我在computer science里面
[01:12:04] 习得的概念去解释这个解解释这个世界
[01:12:08] 这个这基本就是软件工程后来真正采用的
[01:12:12] 形式法方式
[01:12:13] 这也是一个first principle
[01:12:15] 然后他解释了这个
[01:12:17] 解释了这个
[01:12:21] 解释了这个这个模型
[01:12:22] 那如果我们知道
[01:12:26] 如果我们知道这个data dependency
[01:12:29] 一旦这个改
[01:12:31] 如果这个触及到它上游的东西需要修改
[01:12:34] 那我们应该怎么办
[01:12:37] 那我们很自然的
[01:12:39] 我们可以把它割小
[01:12:41] MVP就来了
[01:12:42] 我们不要一次性的产生大量的dependency
[01:12:45] 而是我们我们从一个这个宽度优先
[01:12:48] 这是一个BFS
[01:12:50] 你的一个用BFS的方式构建软件
[01:12:53] 先做第一层再做第二层
[01:12:54] 再做第三层
[01:12:55] 我们变成一个DFS
[01:12:59] 这不就是敏捷开发吗
[01:13:00] 这不就是敏捷开发吗
[01:13:02] 这个我们先做一个minimal viable product
[01:13:07] 把一些重要的优先级最高的这个dependency
[01:13:11] 流程走通哎
[01:13:13] 走通了以后
[01:13:14] 在不断的向右扩展扩展
[01:13:15] 扩展一个DFS
[01:13:16] 一个一个迭代的
[01:13:19] 这就这就对了
[01:13:21] 这就这就对了
[01:13:21] 这就所以这就是软件软件工程
[01:13:23] 没有什么
[01:13:25] 没有什么真正真正真正困难的
[01:13:27] 这个我们越早能够得到反馈
[01:13:31] 我们就越能把这个路线上面的不确定性
[01:13:34] 这个gap
[01:13:35] 因为我们每一个每一个阶段这个瀑布模型
[01:13:38] 所以Royce 模型里面其实有insight的
[01:13:40] Royce 模型里面它
[01:13:42] 比如说前期的阶段
[01:13:43] 比如说需求阶段
[01:13:44] 它就对应的我们要把intent确定
[01:13:48] 要把intent的确定
[01:13:49] 然后在设计设计阶段
[01:13:52] 我们要把spec基本上确定
[01:13:53] 当然可能比如说这个SPA spec
[01:13:56] 也会在是这个需求的阶段
[01:13:58] 也会也会稍微做一点
[01:14:00] 然后最后到到这个编码测试的时候
[01:14:03] 才是implementation
[01:14:04] 然后因为我们知道这个东西是有gap的
[01:14:07] 然后这个gap就意味着
[01:14:09] 每一个intent都会拆成好多个小点
[01:14:11] 而且会对后面产生dependency
[01:14:13] 所以我们应该
[01:14:15] 做这个MVP或者应该做敏捷开发
[01:14:19] 或者应该做TDD
[01:14:21] 它是显然是一个正确的啊事情对
[01:14:24] 所以所以我觉得是阅读这些经典的著作
[01:14:28] 是啊真的是非常有启发性的
[01:14:31] 也是一个非常值得大家学习的
[01:14:34] 学习方式
[01:14:35] 因为一般经典来说
[01:14:37] 经典都是里记录了一个领域
[01:14:39] 最初遇到的也是最重要的那个根本性的问题
[01:14:43] 然后他在方向上找到一个出路
[01:14:45] 尽管可能我在
[01:14:47] 我在事后我也可以援引其他的概念
[01:14:50] 比它解决的好
[01:14:51] 就比如说我就很喜欢这个data data dependency
[01:14:54] 一会你会看到data dependency
[01:14:55] 在整个这个那软件工程的发展历史上
[01:14:59] 都是可以
[01:15:00] 你都可以去往这个方向啊去思考
[01:15:02] 然后去导出更多的啊概念
[01:15:05] 这样对好
[01:15:07] 那么这是软件工程的
[01:15:11] 相当于我觉得这个有点像起点了
[01:15:13] 就是你是你学软件工程
[01:15:15] 这个这个first principle
[01:15:16] 是这个就是它开发就这个软件到底是什么
[01:15:19] 你当然可以用定义说是代码和数据
[01:15:22] 但当你从这个视角看的时候
[01:15:24] 你就能继续往后推出更多的东西
[01:15:27] 然后在现在
[01:15:30] 经历了几十年的发展
[01:15:32] 软件工程变成什么
[01:15:34] 为了解决这里的问题
[01:15:36] 他为每一个阶段都创建了方法和工具
[01:15:41] 然而这些方法和工具可以减少你返工的概率
[01:15:46] 比如说我不知道这边有没有软件的
[01:15:49] 软软件的同学
[01:15:50] 软件同学
[01:15:50] 你们学软工课的时候
[01:15:52] 这个在设计阶段它应该是个ISO标准的
[01:15:55] 但其实我对这个印象已经不深了
[01:15:57] 所以我不是做这个方面的软件工程的
[01:16:00] 比如说这个地方它有一个checklist
[01:16:04] 你很烦
[01:16:05] 你上那个软件工程课的时候
[01:16:07] 你老师让你写一个文档
[01:16:08] 然后他大概有个非常长的checklist
[01:16:10] 说这个有没有做到这个有没有做到
[01:16:12] 这个有没有做到有没有沟通过
[01:16:14] 然后然后你就觉得nonsense
[01:16:17] 因为你是做OJ题的
[01:16:18] 你觉得这个checklist的nonsense
[01:16:20] 但checklist实际上是有用的
[01:16:23] 它减少了你返工的概率
[01:16:25] 比如说这个checklist最后总有一个
[01:16:27] 你是不是和这个客户最后沟通过
[01:16:30] 然后你在学习
[01:16:31] 你在上学的时候会觉得诶这个
[01:16:33] 很讨厌
[01:16:35] 但是当你真的和客户沟通过
[01:16:37] 并且给他打勾的时候
[01:16:38] 实际上你大幅减少了这个intent的
[01:16:41] 不符合客户要求的概率
[01:16:45] 这就是一个方法
[01:16:46] 这也是一种工具
[01:16:47] 这是一个
[01:16:48] 一个有人文关怀的工具
[01:16:49] 它没有没有任何的代码
[01:16:51] 然后当然
[01:16:52] 我们现在比如说当我们说
[01:16:54] 比如说现在我们做软件工程研究的时候
[01:16:56] 更多时候说哈是当我们有了代码以后
[01:17:01] 当我们比如说有代码
[01:17:02] 有的代码后能不能做自动的测试
[01:17:05] 无穷多的这个灌水的paper
[01:17:07] 然后有了代码以后
[01:17:08] 里面有没有这个bad smell
[01:17:11] bad smell这个你们你们都知道
[01:17:13] 就比如说你如果看到一个代码
[01:17:15] 它在等号左右从来不写空格
[01:17:19] 你会认为这个代码是不好的代码
[01:17:21] 这个这个规定在AI时代之前都成立
[01:17:28] 但是我发现这个在GPT-6发
[01:17:30] 这个学会省token以后
[01:17:32] 这件事情变了
[01:17:33] 他会写出这个极为无法理解的代码
[01:17:36] 然后把很多的语句放到一行里
[01:17:38] 然后那个代码就是对的
[01:17:39] 然后我不知道他是怎么弄对的
[01:17:41] 但是反正它是对的
[01:17:42] 然后也许我们永远不应该去读那样的代码
[01:17:47] 这是个有意思的观察
[01:17:50] 但至少我们知道的是什么
[01:17:51] 是软件工程
[01:17:52] 当有了这样的一个起点
[01:17:54] 为了把这个大的工程系统性的工程扶起来
[01:17:57] 软件工程里面还有很多很多的细小的点
[01:18:01] 你们如果去读研究生
[01:18:02] 如果要选这个
[01:18:03] 比如说软件工程方向
[01:18:04] 你们大概率会在这个里面
[01:18:06] 那个非常小的一点
[01:18:08] 比如说针对这个软件开发流程当中
[01:18:11] 编码的这个过程当中
[01:18:14] 这个Java代码的这一种类型的
[01:18:17] bad smell的一个什么样更好的检测
[01:18:20] 去做一个什么东西
[01:18:22] 当然你在就你在做深的过程中
[01:18:25] 你不要忘记去看这个树林
[01:18:28] 去看这些经典的东西
[01:18:31] 你就会有更好的认知
[01:18:32] 就是对人来说是深度和广度都是
[01:18:36] 你要在深度里面训练
[01:18:38] 你才有更长的思维链
[01:18:39] 你在广度里面训练
[01:18:40] 才有更好的对整个这个世界的啊感觉
[01:18:44] 然后还有意思
[01:18:46] 你就会发现所谓的软件工程
[01:18:48] 为了在每一个阶段创建方法学和工具
[01:18:51] 它就需要在不同的阶段用不同的语言
[01:18:54] 比如说在checklist的时候
[01:18:56] 你是不太可能
[01:18:58] 尤其是在大语言模型时代之前
[01:19:00] 你是不太可能用一个编程语言
[01:19:03] 去做一个checklist的
[01:19:05] 虽然今天我们都用Markdown
[01:19:06] 但那个时候真的就是一个docx的文档
[01:19:08] 然后你把这个文档打印出来
[01:19:10] 然后要存档
[01:19:11] 你可能是手写的
[01:19:12] 跟客户沟通的那个哪个哪个记录
[01:19:16] 然后你到这个编程的时候又有编程语言
[01:19:18] 然后在编程语言和之前
[01:19:21] 你想马上就看到了一个gap
[01:19:24] 那个时候没有大语言模型这种万能的编译器
[01:19:27] 你只要有自然语言
[01:19:27] 就可以把它编译成任何一种语言
[01:19:29] 它在不同的阶段你会发现
[01:19:32] 马上你就发现有些在有些比如在设计阶段
[01:19:39] 我们没有一个语言来帮助你做设计
[01:19:42] 再比如说在1970年的时候
[01:19:44] 在设计的时候
[01:19:45] 那大家用的都是自然语言
[01:19:48] 就是一个文档
[01:19:49] 是一个设计文档
[01:19:50] 你们学软件工程
[01:19:51] 我记得我那个时候学软件工程就是写设计文档
[01:19:53] 然后你写先写需求文档
[01:19:55] 需求文档写完写设计文档
[01:19:56] follow那个瀑布的啊模型诶
[01:20:00] 你马上就会想文档的最大缺点是什么
[01:20:05] 最大缺点是写文档的是人人会产生幻觉
[01:20:10] 人会产生typo
[01:20:12] 人和人之间
[01:20:13] 当我们讲同一件事的时候
[01:20:15] 是无法对齐的
[01:20:16] 这件事情在你和室友之间已经发生过无数次了
[01:20:19] 你说的是这个室友理解成了那个
[01:20:21] 你花了很多的时间跟他沟通和啊对齐
[01:20:24] 当然我觉得跟比如说跟女朋友对齐
[01:20:26] 会比跟室友对齐更困难
[01:20:27] 这个这个不重要
[01:20:30] 你作为一个软工人
[01:20:33] 你在first principle上
[01:20:34] 如果你想要应用这句话
[01:20:38] 为设计阶段创建一个方法
[01:20:40] 学创建工具去减少返工的概率
[01:20:44] 那你要你要做什么
[01:20:46] 你要做的是一个介于自然语言和编程语言
[01:20:50] 之间的一个设计语言
[01:20:53] 当然也是一个domain specific language
[01:20:56] 哎你们想到什么了
[01:20:58] 你们想到了软件工程课上面讲的
[01:20:59] 各种各样的东西
[01:21:01] checklist就这个checklist
[01:21:04] 虽然它是自然语言
[01:21:05] 但实际上它也是一种中间语言
[01:21:08] 因为它有格式的规范
[01:21:09] 它要求你必须是一条一条一条的
[01:21:12] 每一条必须要打勾或者打叉
[01:21:14] 它已经是介于一个自然和形式化
[01:21:16] 它是有语义的
[01:21:17] 它是有一定的语义的
[01:21:18] 这个语义当然是虽然是由人来检查的
[01:21:21] 但人待遇对于勾和叉来说的对齐
[01:21:24] 就比我直接写一个文档的对齐
[01:21:26] 要来的更formal一点
[01:21:28] 所以你看他这个formal的程度
[01:21:30] 就是它有确定性的语义的程度
[01:21:33] 是从设计的阶段到下面越来越formal的
[01:21:39] 这也迎合了
[01:21:40] 从intent到spec到implementation之间的这个gap的解决
[01:21:46] 所以你就开始理解软件工程这个学科了
[01:21:49] 那我们学的时候呢是什么
[01:21:50] 怎么学
[01:21:51] 我们是bottom-up的
[01:21:52] 我们是先学编程
[01:21:55] 因为你所有的你看计算机软件工程
[01:21:57] 你们第一第一件事是先学工程
[01:21:59] 额
[01:22:00] 先先学怎么做一个码农
[01:22:02] 因为你不理解代码
[01:22:04] 你就没有办法理解整个过程
[01:22:07] 但是AI来了以后
[01:22:08] 我觉得变了
[01:22:08] 你可以先从产品经理开始做
[01:22:11] 哎产品完了
[01:22:15] 我脑子卡壳了
[01:22:18] 产品是这个产吗
[01:22:19] 呵啊不是这个哎我脑子突然卡壳了
[01:22:25] 就product ok
[01:22:28] 短路了
[01:22:29] 我上年纪了
[01:22:30] 这个
[01:22:32] 但anyway不重要
[01:22:33] 这个你是可以先先了解这个整个过程的
[01:22:37] 就是我觉得我们软以后肯computer science
[01:22:40] 如果要可能我要来改的话
[01:22:43] 要这个
[01:22:45] 就是产product
[01:22:47] 就第一个学期就可以做
[01:22:49] 因为反正你后面所有的事情都是vibe coding
[01:22:52] 然后你不去控制它的质量
[01:22:53] 你也不需要知道
[01:22:55] 如果我上第一门课
[01:22:56] 我不去
[01:22:56] 你不需要控制这个质量
[01:22:57] 因为你根本就不知道不理解代码
[01:22:59] 不理解后面是怎么运作
[01:23:01] 但你依然可以设计设计好的好的产品
[01:23:04] 你只要有好的想法就可以做对
[01:23:08] 然后在这个过程当中
[01:23:09] 其实诞生了很多的有软件工程智慧的方法
[01:23:13] 和和工具
[01:23:15] 比如说这个checklist
[01:23:17] 然后它不仅有checklist
[01:23:18] 还有一些像这种决策表
[01:23:19] 就那种决策树
[01:23:20] 就说他有一个就很好玩
[01:23:22] 就是就你们有大家觉得我是个理科生
[01:23:26] 我在软件工程学院学软件学院学文科
[01:23:29] 他给我一个checklist
[01:23:31] 说只有当所有的这个勾都打上了
[01:23:35] 你才能进入下一个阶段
[01:23:38] 这是什么
[01:23:38] 对我来说是nonsense
[01:23:40] 但是这个nonsense 赋予了
[01:23:42] 这个形式的语义避免了遗漏和矛盾
[01:23:45] 他会要求你
[01:23:47] 他甚至会有这种checklist
[01:23:48] 要求你把所有的文档两两摆在一起审查一遍
[01:23:52] 你会想我靠
[01:23:53] 我才不想做这个事儿
[01:23:54] 我是写程序的
[01:23:55] 但就是这样的这个两两摆在一起检查一遍
[01:23:59] 避免了这个gap的漂移
[01:24:01] 这都是智慧
[01:24:02] 但是他失败过了
[01:24:03] 他失败过
[01:24:04] 然后在管理团队的过程中形成的管理学的经验
[01:24:06] 这个软工人
[01:24:08] 也可以学也可以学好
[01:24:11] 然后还有各种就是比如说在在这个测试上面
[01:24:14] 也有很多经典的工作
[01:24:15] 比如说QuickCheck
[01:24:16] 基本上可算是
[01:24:17] 我们整个测试领域的这个开山鼻祖之一了
[01:24:21] 让人描述性质
[01:24:22] 由工具生成
[01:24:23] 输入寻找反例
[01:24:25] 然后这是什么
[01:24:26] 这体现了一个什么逻辑
[01:24:28] 你做任何事都会错
[01:24:30] 你写代码就你做任何翻译
[01:24:32] 从上到下的翻译都会错
[01:24:34] 你从specification翻译到代码
[01:24:36] 尤其你有些隐含的specification
[01:24:38] 比如说你的这个程序不能crash
[01:24:41] 不要有null pointer
[01:24:42] 资源
[01:24:42] 不能泄露这些隐藏的你代码里面的这些specification
[01:24:45] 你也要遵守
[01:24:46] 那你有没有可能我在代码里面就写一个property
[01:24:52] 然后这个property可以自动变成好多
[01:24:54] 好多的测试用例
[01:24:55] 然后如果全部都通过了
[01:24:57] 我对代码就有更大的信心
[01:24:59] 你做你现在做的软件就是这样的
[01:25:02] 你写一份代码
[01:25:03] 你永远不知道它
[01:25:05] 但是如果你做了测试
[01:25:06] 你观察过它的结果
[01:25:08] 你这就对他信心会多一点
[01:25:10] 当你独立做的质量保障做的越多
[01:25:13] 你对他的信心越大
[01:25:15] 除非是你最终写了一个证明形式化的证明
[01:25:18] 说证明这个程序你的情形可能是更大的
[01:25:22] 然后这就是软件工程里面人研究的各种各样的
[01:25:25] 有意思的这个啊东西
[01:25:29] 然后再比如说这个需求追踪矩阵
[01:25:32] 我前面上课的时候讲过一个概念叫traceability
[01:25:35] 这个是软件软件里面很重要的一个概念
[01:25:39] 然后这个traceability做的是什么
[01:25:42] 做的就是把这个data dependency graph里面的
[01:25:46] 以前是没有的
[01:25:47] 如果如果你从文件系统或者项目的角度来看
[01:25:52] 这个软件
[01:25:55] 那这个软件就是好多的文件
[01:25:57] 什么/docs下的什么什么什么点MD
[01:26:00] 然后src 下的一个什么什么点ts
[01:26:03] 然后又有一些其他的什么什么什么东西
[01:26:05] 还有个README
[01:26:08] 我说这是一个为因为文件系统一开始大家用了
[01:26:11] 而不得不做的一个work around
[01:26:14] 然后这个东西其实承载了这个东西
[01:26:18] 他是这个
[01:26:19] 它承载了整个软件软件
[01:26:21] 而traceability要求你要用链接
[01:26:23] 或者用什么文档
[01:26:24] 或者用什么样的方式
[01:26:25] 要求你的每一个代码和每一个需求点
[01:26:29] 都能对得上需求和需求之间也能对得上
[01:26:33] 需求和设计之间也能对得上
[01:26:35] 如果所有这些都能对得上
[01:26:36] 他有这种独立的互相的交叉检验
[01:26:39] 你对你软件的质量就更有信心了
[01:26:42] 他也是没办法
[01:26:42] 就是人的能力是有限
[01:26:44] 他假设就你我们的每一个人
[01:26:47] 我们在上大学的时候学这个软件工程
[01:26:50] 总是觉得我是一个最
[01:26:52] 我要把自己变成世界上最厉害的码农
[01:26:55] 这个那就够了
[01:26:56] 如果我是世界上最厉害的码农
[01:26:57] 那我就保证能在软件企业里面
[01:26:59] 找到一个很好的工作
[01:27:01] 这是这是这个社会给你的contract
[01:27:03] 然后但是从资本家的角度来看
[01:27:06] 或者说从你要完成一项任务的角度来看
[01:27:10] 他更重要看到的是
[01:27:11] 没有一个码农能够单独完成他的项目
[01:27:15] 他只能说我码农有好有坏
[01:27:18] 我得花多少钱雇多少码农
[01:27:21] 然后最终能把我的项目给交付
[01:27:24] 所以你看现在每一个人都当产品经理
[01:27:26] 你第一门课就要学做产品
[01:27:29] 你要调动
[01:27:31] 假设你有好多码农了
[01:27:32] 而且你现在马上就有
[01:27:34] DeepSeek算
[01:27:35] 我觉得DeepSeek绝对算是一个相当资深的码农了
[01:27:40] 绝对不是这种本科毕业生级别的这个
[01:27:42] 那你马上就可以有2500 并发的低薪码农
[01:27:46] 你手上有2500人
[01:27:47] 你怎么管
[01:27:49] 你高中毕业的时候
[01:27:50] 你做梦都没有想过
[01:27:52] 你刚刚高考完
[01:27:53] 你接受了高考的这个训练以后
[01:27:55] 你马上就能管2500个人
[01:27:57] 这个mindset可能要改一改对
[01:28:00] 所以在这个里面
[01:28:01] 就诞生过很多很多好玩的东西
[01:28:03] 比如说这些都是你们如果上软件工程课
[01:28:09] 可能可能可能会讲
[01:28:11] 比如说叫design by contract
[01:28:13] 叫面向契约的
[01:28:14] 契约的编程
[01:28:16] 这里有一个文章我就不打开看了
[01:28:18] 这个Eiffel的这个语言
[01:28:21] 在一应该是1986年左右吧
[01:28:23] 1986年
[01:28:26] 他就说我要把这个Hoare 三元组直接写到代码里
[01:28:29] 你看这样的一段上古上古语法就知道了
[01:28:33] 你看他叫function function
[01:28:35] 然后它那个赋值还有冒号
[01:28:37] 等于就是这个是
[01:28:39] 当然这个一路也沿袭下来
[01:28:41] 有很多语言也采用这个采用了这条线
[01:28:47] 很自然语言
[01:28:48] Function is
[01:28:49] 你在这里写
[01:28:50] 先写文档
[01:28:52] 这个函数是干嘛的
[01:28:54] require它的前置条件
[01:28:58] do这是代码的实现
[01:29:00] ensure做完了以后
[01:29:02] 他能够保证什么
[01:29:04] 他说好
[01:29:05] 你可以先就他鼓励你先不要写这个度流控
[01:29:12] 然后把这个软件的各个模块文档
[01:29:15] pre condition post condition给写出来
[01:29:19] 比如说在你有一个账户的取款
[01:29:22] 当你在写这个precondition post condition的时候
[01:29:26] 你就会自然的去关联到你的设计
[01:29:29] 比如说余额不足到底应该怎么样处理
[01:29:35] 在你如果写第一个MVP的时候
[01:29:37] 你一定不会管这些事
[01:29:38] 你肯定是说直接让他crash或者怎么
[01:29:40] 你就假设这件事情永远不不会发生
[01:29:43] 排除在你的specification space之外
[01:29:45] 但是当你的软件不断的向后演进的时候
[01:29:48] 那么OK你的这个contract就变得非常重要
[01:29:54] 所以他希望能够在编程语言里引入这个
[01:29:58] 所以你看到这么多年软工人做的事情
[01:30:01] 就是在这个spec上面横跳
[01:30:04] 从自然语言到几个半自然的语言
[01:30:08] 可以可以接纳设计的
[01:30:10] 有一些逻辑公式的语言
[01:30:12] 它可以没有代码单纯的检验这个逻辑
[01:30:15] 比如说函
[01:30:16] 我中间如果要函数调用这个逻辑能不能成立
[01:30:19] 然后到再到现在的这个啊编程语言
[01:30:22] 然后今天其实依然是一个非常活跃的方向
[01:30:24] 而且我觉得软件工程未来会发生很大的变化
[01:30:27] 因为LLM 来了
[01:30:30] 自然语言对不齐的问题解决了
[01:30:32] check list不好检查的问题也解决了
[01:30:35] 我们只剩下这个gap
[01:30:38] 只有是我没有想清楚
[01:30:40] 我没有说清楚
[01:30:41] 一旦我想清楚说清楚
[01:30:43] 可能真的就都能解决了
[01:30:45] 因为我们现在比如说你看像Eiffel
[01:30:47] 它催生了很多现在的项目
[01:30:49] 比如Dafny、Verus这些形式化验证的这个工具
[01:30:54] 你可以就说大家的梦想
[01:30:58] 大家梦想都是我如果写一个这样的程序
[01:31:02] 我可以自动的证明
[01:31:04] 我的函数在前置条件满足的时候
[01:31:06] 后置条件就会满足
[01:31:07] 无论我写什么就能证明
[01:31:09] 然后而且我还要证明整个系统
[01:31:12] 把所有的前置条件
[01:31:13] 后置条件连起来
[01:31:14] 它就能够满足我的intent intent
[01:31:17] 然后我其实在ChatGPT出来之前
[01:31:21] 我上上操作系统课的时候
[01:31:23] 我就预言当时我预言30年
[01:31:24] 说30年以后
[01:31:27] 那可能2020年左右的时候
[01:31:29] 还是2022年左右的时候
[01:31:32] 你如果你的一个程序
[01:31:36] 过不了编译
[01:31:38] 说错了
[01:31:38] 如果你一个程序里面有个assert
[01:31:40] 然后这个assert就随便你写的assert也可以写
[01:31:42] 这种前置条件
[01:31:43] 后置条件可以写断言
[01:31:44] 就是说我的函数要满足
[01:31:47] 这个link list的左边右边就linked list
[01:31:50] 往左走
[01:31:51] 再往后走
[01:31:51] 或者往后走再往前走
[01:31:53] 这个总之能回到自己
[01:31:55] 然后就写一个
[01:31:56] 然后任何的assert可以和业务逻辑相关的assert
[01:31:59] 这个assert只要我写出来
[01:32:02] 它不能证明
[01:32:03] 或者说就是就这个东西是无法证明的
[01:32:06] 这个程序不能编译
[01:32:07] 它
[01:32:08] 编译百分之百保证这个东西才能证明
[01:32:10] 然后这我就
[01:32:12] 这个软件的gap就代码开发的这种
[01:32:15] 我还需要这种property-based test吗
[01:32:17] 我不需要
[01:32:17] 我只要直接把这个property写进去
[01:32:19] 他帮我证明了就可以了
[01:32:20] 然后现在从现在来看
[01:32:22] 可能不需要30年
[01:32:22] 可能从那个时间点算
[01:32:24] 10年或者15年就可以
[01:32:27] 就可以解决这样的问题了
[01:32:29] 然后在这个过程当中
[01:32:30] 有一个集大成者叫UML
[01:32:34] 大家绕不过去的一个名字
[01:32:35] Unified modeling language
[01:32:37] 他的想法也很简单
[01:32:39] 既然啊这个世界这么复杂
[01:32:42] 在不同的层次上要用不同的语言
[01:32:45] 你实现的时候是C或者Java
[01:32:46] 你在设计的时候
[01:32:48] 当然实现的时候也可以用这个Eiffel
[01:32:50] 也有一些别的专门用来做设计的领域语言
[01:32:53] 然后在做需求的时候是DSR
[01:32:55] 那我们有能不能有一种中间语言
[01:32:57] 统一整个面向对象的世界
[01:33:03] 他要做的是一个非常有野心的事情
[01:33:05] 就是语义的对齐
[01:33:07] 而这件事情
[01:33:08] 人类其实是就其实人类天生没有做好的事情
[01:33:13] 因为人类靠自然语言
[01:33:14] 然后自然语言是直接连接大脑的latent space的
[01:33:17] 当我跟你说的时候
[01:33:18] 说我还是我那个意思说
[01:33:20] 我今天看到一个美女
[01:33:22] 在我latent space
[01:33:23] 你们在每一个人的latent space里面
[01:33:24] 都构造了一个美女
[01:33:25] 但她都不一样
[01:33:26] 这是对不起的
[01:33:27] 如果你要求我们把那个形象3D建模
[01:33:31] Blender画出来
[01:33:32] 这就跟我让这个GPT画一个美女
[01:33:35] 让那个DeepSeek画一个美女
[01:33:37] 用Blender画
[01:33:37] 他们画出来也是不一样的
[01:33:39] 开玩笑
[01:33:39] 这个
[01:33:41] 但好像那个豆包生成的都长一样
[01:33:47] 这个语言就是很难对齐的
[01:33:49] 因为语言直连人类大脑的latent space
[01:33:51] 所以人类发明了数学语言
[01:33:54] 数学语言是一个非常好的
[01:33:56] 全人类都能自然对齐的
[01:33:57] 因为我们知道什么是自然数
[01:33:59] 我们是从公理一点一点构造出来的
[01:34:00] 然后那个公理非常小
[01:34:02] 以至于人类还是基本上可以对齐的
[01:34:04] 一旦对齐完成
[01:34:06] 那我们用那个皮亚诺的公理
[01:34:07] 就把整个计算机世界
[01:34:08] 全部都全部都建构建起来了
[01:34:11] 那在计算机上世界里看到同样的东西
[01:34:15] 它的语义是什么
[01:34:16] 就是绝对齐的
[01:34:17] OKUML想要的是一个非常有野心的目标
[01:34:22] 他想要去对齐那个自然语言世界里面的东西
[01:34:25] 比如说需求设计这些说不清的东西
[01:34:29] 当然你是不可能百分之百对齐的
[01:34:31] 但是他希望把能对齐的部分
[01:34:33] 和不能对齐的部分给剥离出来
[01:34:36] 通过定义模型的元素和它们的语义
[01:34:39] 就有些东西是有语义的
[01:34:40] 比如说你们可能学过UML
[01:34:42] 就打比方类图
[01:34:43] 那类图的语义就是确定的
[01:34:45] 我有个class叫student
[01:34:47] student里面有一个field叫叫name
[01:34:51] 那它就是student name
[01:34:52] 它可以变成源代码里面的一个东西
[01:34:54] 它是有语义的
[01:34:55] 然后比如说sequence diagram
[01:34:57] 他的这个顺序图里面
[01:34:58] 他说我要从前到后按照某一个顺序时序来执行
[01:35:01] 那这个时序的先后就是绝对齐的
[01:35:04] 你不需要用自然语言的
[01:35:06] 如果你写就没有UML你写自然语言先后
[01:35:09] 如果当它发生并发的时候
[01:35:11] 到底谁先谁后
[01:35:12] 能不能并发
[01:35:13] 它就是有歧义的
[01:35:14] 但是UML 就
[01:35:19] 消除了这个其在最大程度减少
[01:35:22] 在没有代码时候的这种语义的漂移
[01:35:26] 当然我觉得今天我觉得UML已经死了
[01:35:28] 这个就是因为呵
[01:35:31] 就所有他的假设都是
[01:35:33] 我们的自然语言和和形式语言是不能对齐的
[01:35:37] 这是他的假设
[01:35:37] 所以他需要一层一层的中间语言
[01:35:39] 然后今天突然间
[01:35:40] 这个自然语言可以和可以和任何东西对齐的
[01:35:43] 反正AI就可以给你问
[01:35:45] 然后
[01:35:46] 所以UML也S也是一个历史里面的东西了
[01:35:49] 但是这个其实它设计时候的这个
[01:35:52] first principles
[01:35:53] 其实一直都在啊指导我们对
[01:35:58] 所以我也特意重温
[01:36:02] 让这个AI帮我
[01:36:04] 帮我重读了一下这个
[01:36:13] 这个就比较恐怖了
[01:36:14] 这个一个700页的文档
[01:36:20] 就是我就你看到我的工具还是可以的
[01:36:22] 就是我特别做了这个可以scale
[01:36:25] 长的文档
[01:36:26] 几千页的文档也没有
[01:36:27] 也没有问题
[01:36:29] 这个就跟PDF是差不多的
[01:36:31] 还是有接近的体验的
[01:36:36] 对正好这个Kimi啊我就不做
[01:36:40] 这
[01:36:40] 这可能算一个广告
[01:36:41] 因为他送了我一个699的
[01:36:43] 这个这个一个月的套餐
[01:36:45] 然后说他说看到了我的视频
[01:36:48] 然后然后送了我一个699的套餐
[01:36:50] 然后我就直接让这个AI帮我读了
[01:36:55] 就直接让AI帮我读了这个整个UML spec
[01:36:58] 就是刚才你看到的就这个dump
[01:37:02] 然后dump完了以后
[01:37:03] 我直接让AI帮我备课
[01:37:05] 直接对着那个
[01:37:07] 我大概我大概让AI这样就是分subagent
[01:37:10] 然后分division的每个agent的读50页
[01:37:13] 结果我把一个非常长的文档
[01:37:16] 所以我觉得这是一个非常恐怖的
[01:37:18] 我觉得也是一个蛮蛮可怕的事情
[01:37:20] 就我把这个文档切成切成这样的
[01:37:23] 带overlap
[01:37:24] 因为总会有一点
[01:37:25] 然后我让他每一个都提取里面的软件工程智慧
[01:37:28] 把不符合AI时代的这个不必要的东西
[01:37:32] 就把我的我把我的lecture notes全部给他了
[01:37:34] 然后把它把它拿出来
[01:37:36] 然后总结成课件
[01:37:38] 然后他就去读
[01:37:39] 然后花了18%的五小时额度
[01:37:42] 大概折算成这个699套餐的五块三
[01:37:46] 所以实际上我觉得这是一个
[01:37:50] 值得我们思考的问题
[01:37:53] 就是当你拥有了更好的模型
[01:37:56] 就我相信比如说你现在如果用GPT-6
[01:38:00] 可能你的价格会差不多
[01:38:01] 因为它很省
[01:38:02] token GPT-6 的 token 真的非常省
[01:38:05] 可以得到差不多的
[01:38:08] 价格下可能好得多的质量
[01:38:10] 这就意味着学生群体
[01:38:14] 就哪怕你们是学生群体
[01:38:16] 在拥有好的模型和没有好的模型的时候
[01:38:18] 你们的学习效率
[01:38:20] 学习成本也会有很大的差距
[01:38:22] 然后你的学习就成为了一个就如果还好
[01:38:25] 现在token可能也不算太贵
[01:38:26] 就如果你有一个100刀的这个Codex
[01:38:30] 其实我觉得还算是够用了
[01:38:32] 这个对
[01:38:33] 大家学习来说
[01:38:34] 因为因为什么东西烧token
[01:38:36] 你去维护大项目
[01:38:37] 烧token大项目
[01:38:38] 它你就会在大上下文里载入很多东西
[01:38:41] 然后你100万上下文马上就填满了
[01:38:42] 然后那就那个很费头亏
[01:38:44] 然后但是你现在如果你是一个学习流程的话
[01:38:47] 你其实上下文你不会
[01:38:48] 你不会像我这样去干干这个
[01:38:51] 把整个UML spec都放进来
[01:38:53] 你可以用这个digested version
[01:38:55] 然后但这个值得我们思考的是
[01:38:58] 我们以后还学得起
[01:38:59] 学不起来
[01:39:00] 这真的是一个就非常现实的现实的问题
[01:39:03] 因为如果让所有人都评教育平权
[01:39:05] 那我们没有那么多算力
[01:39:07] 没有那么多资源
[01:39:08] 那怎么办
[01:39:09] we don't know
[01:39:10] 这个这可能是一个社会性的社会性的问题
[01:39:14] 但anyway
[01:39:15] 这是这是UML这他总结的一些UML
[01:39:19] 但是一句话
[01:39:23] 796页的spec从头到尾回答一个问题
[01:39:26] 哪些intention必须定死
[01:39:28] 哪些留白
[01:39:29] 它构造了一个形式语言
[01:39:31] 半形式的语言去告诉你
[01:39:33] 哪些东西可以确就是可以在语义上确定下来
[01:39:37] 哪些可以不用他做解决的
[01:39:40] 就是对齐的问题
[01:39:42] 人和人之间
[01:39:43] 你甚至和下一时刻的自己
[01:39:45] 你不deterministic
[01:39:46] 你今天想的和明天想的就不一样
[01:39:48] 所以你跟你自己对不齐
[01:39:50] 那有趣的东西
[01:39:53] 你可以自己
[01:39:53] 大家自可以自己回去看一下这个slides好
[01:39:58] 那今天下课