Dave Plummer:编程、自闭症与微软旧日故事 | Lex Fridman Podcast #479
Microsoft 1990年代的护城河,是人才密度与分发能力的结合,而不是产品复杂度。 Plummer 称 Microsoft 是他加入过的“最具杀伤力的聪明人集合”,而 Gates 持续推动每张办公桌上都有一台电脑,并招聘“和他一样聪明或比他更聪明的人”。MS-DOS 本质上只是一个命令启动器,但把它做成 PC 标准后,Microsoft 得以将这一杠杆复利数十年。
当一个开发者端到端负责可靠性时,微小的防御性软件也能变成基础设施,Task Manager 就是例子。 Plummer 最初为 NT 4.0 编写的应用约87K,拒绝链接 C runtime——按他的估算,这大约还能省下96K——并将可能阻塞的调用放到独立线程,只重绘发生变化的单元。他说,原始代码仍藏在如今约4MB的层层扩展之下,而使用量已经达到“每月20亿次左右”。
稀缺性迫使工程师形成一套现代富裕环境可能掩盖的纪律。 在 MS-DOS 时代,浪费10K意味着“全世界每台机器现在都少了10K”;调试 NT 则要在 Intel、MIPS、Alpha 和 PowerPC 上阅读汇编,没有源码级调试,也没有 Git。Plummer 估计自己的职业生涯是20%创造、80%调试,把修复 bug 的能力变成了稀缺的组织资产。
Plummer 一再把个人工具转化为产品、分发渠道,最终变成 Microsoft 的功能。 HyperCache 以$20或$40卖出几千份,帮助他从 Saskatchewan 冷邮件进入 Microsoft;Visual ZIP 则为他买下一辆二手红色1993 Corvette,后来成为 Windows ZIP 文件夹。此后,一场1万美元、无上限的 banner 投放带来约3.8万美元销售,展现了软件经济学的强大——也说明优化如何迅速越过监管和声誉边界。
Windows 之争归根结底,是平台广度究竟会复利信任,还是复利维护成本。 Lex 认为,高级用户定制能力会营造被用心对待的感觉并吸引开发者;Plummer 则反驳,每增加一个任务栏位置,就会扩大代码、测试、人员和安全攻击面,砍掉功能或许能让重写版本提前4个月发布。他们都同意,持续的 UI 变动会阻碍打磨;当“推荐设置”让人感觉系统试图替用户做决定时,操作系统会失去长期 goodwill。
Plummer 把自闭症视为一种拥有极强专注力、但要求明确沟通的运行模式,而不是低共情的同义词。 他的框架是单向兴趣(monotropism):一个“连续单任务者”可以把极强的投入带到有回报的工作中,但可能错过隐含动机、讽刺或情绪线索。因此他的职业建议非常具体——“卖你能做的事,而不是卖你自己”——管理经验则是直接询问,因为每个员工的激励都不同。
AI 已经能让有经验的程序员在陌生语言中获得杠杆,但 Plummer 不接受专业能力已经变得可有可无的说法。 他在构建 Dueling Deep-Q agent 时使用生成的 Python,让它在 Tempest 中达到约36关,而他自己能打到96关,因为他读得懂输出、也知道下一步该要求什么。他对长期趋势的模型是桥梁设计:程序员将移动组件和接口,而不再逐行编写;但“给我一个兼容 Linux 的 Linux kernel”仍超出现有系统能力。
1. 编程始于物理接触,而非课程体系
1979或1980年前后,11岁的 Plummer 骑车去 RadioShack,自告奋勇组装一台尚未开封的 TRS-80 Model 1、Level 1、4K 机器。他当时对电脑一无所知,起初还在 BASIC 里输入英语;
PRINT 2+2能运行,这让他受到鼓舞,随后又输入了解释器根本无法理解的命令。RadioShack 允许他每周四和周六回来,开启了他职业生涯的前半段:“我想做的全部事情,就是骑车回到那里,多和它待一会儿。”回头看,他认为 Commodore 64 高于 Apple II,因为前者销量更高,可能让更多人接触到计算机。
一台故障的 Commodore 64 软驱迫使他改用磁带,并使用没有 assembler 的 machine-language monitor。他用十六进制输入6502操作码,做出了一个 Galaga 克隆版;其顺序执行、不可重定位的结构像是在“编程一盘磁带”:加代码就得跳到别处,完成工作,再跳回来。
他第一次学到数据管理的教训非常惨烈——他把一张空白软盘复制到了数周的工作上。损失带来“巨大的愧疚”,因为起因是赶时间,但那款消失的游戏仍是他直接用机器语言写过的最复杂项目。
2. 人生会被一连串小决定推向不同方向
Plummer 并不是有意识地退学;他只是“越来越少、越来越少、越来越少”地去上高中,直到再回去变得尴尬。他的警告比“辍学”这个标签更尖锐:一次次决定“我今天就是不去上课”,最终会替你做出那个大得多的决定。
没有文凭的他先后在7-Eleven和油漆仓库工作。转折点是在零下40度的环境里,用15或20英尺长的木杆测量汽油罐;木杆滑落时他伸手去接,约1000根木刺扎进手里,他想到:“我不想一辈子做这个。”
21岁时,他说服校长让自己复学,直接回应对方关于名额的疑虑:总会有人退学,所以“就假设你有位置”。后来,他在补修几何课中靠1%的宽恕分数过关,大学生涯几乎因此结束;下学期他“真正地”开始学习,这次是为了自己,动机改变后,成绩也随之改变。
3. 共享软件组合打开了 Microsoft 的大门
Plummer 靠 HyperCache——一款 Amiga 文件系统缓存——支付大学费用。大部分代码用 C 编写,紧凑的传输路径则用68000汇编;其 N-way associative 设计匹配磁盘几何结构,并围绕磁道级访问进行预取。
他最初通过 Usenet 和 Amiga 论坛分发,提供30天试用,随后进入零售库存。有人打电话订购50份、每份$20——约合1989年的$1,000——这让他觉得数额惊人;最终,他根据适用条款,以每份$20或$40的价格卖出几千份。
在帮助一家电话公司把 UBNet 转为 TCP/IP 时,他读到一篇 Microsoft 历史,意识到那正是自己想要的文化。他从 HyperCache 注册卡中寻找 Microsoft 的邮箱地址,给3或4个人发冷邮件,联系上了 Alasdair Banks,之后很可能又联系到 Ben Slivka,最终由后者面试他,进入 MS-DOS 实习岗位。
4. Microsoft 的优势,是集中的智力与简单的标准
Plummer 对 Microsoft 的第一印象令人挫败:那是他见过的“最具杀伤力的聪明人集合”。当地专家那个更聪明的朋友,很可能就在 Microsoft 工作,因此以“小城里的大人物”身份抵达后,他才发现公司内部的标准有多高。
他对 Gates 的解释不是神秘主义,而是专注:让每个家庭、每张办公桌上都有一台电脑,是 Gates 的“特殊兴趣”;他持续追逐这个目标,并招聘和自己一样聪明或更聪明的人。结果是一台“几乎不可阻挡的智力机器”,专门打造技术上可以很简单、商业上却极其精准的产品。
在 DOS 之前,Microsoft 本质上是一家语言公司。Plummer 认为,公司与 IBM 达成协议,让 MS-DOS 随每台 PC 一起提供,而没有向 IBM 收取高额费用,由此建立了一个 Microsoft 复利数十年的标准——这既有运气,也体现出平台位置比最大化首笔授权收入更重要。
MS-DOS 本身“90%”是命令启动器:在目录或路径中找到一个带名称的程序,加载它,再执行。环境变量、脚本和设备访问增加了一些复杂度,但它没有多任务和图形界面;那句著名的“没人会需要超过640K”并不是 Gates 说的。
5. 内存稀缺让每个字节都变成全球产品决策
640K 限制不只是 DOS 开发者可以使用的容量;操作系统消耗的每一个字节,都会从客户手里消失。Plummer 对责任规模的描述很直接:“如果你无谓地用了10K,全世界每台机器现在就都少了10K。”
他的磁盘缓存背景让 CD-ROM 缓存成为顺理成章的第一个任务。CD-ROM 刚开始进入市场,Microsoft Bookshelf 是少数应用之一,智能缓存可以将访问速度提高“几十倍”,把一个实习生的专业共享软件经验立刻转化为平台性能优势。
他还把 SmartDrive、最终包括 DoubleSpace 压缩引擎移入高内存。Plummer 说自己可能把 A20 线的极性记反了,但这项技术使用段与偏移的算术寻址一兆字节以上的空间,将代码放进额外约64K内存,并留下低内存 stub 跳转进去。
6. Windows 95 赢得家庭市场,NT 重建底层基础
Plummer 曾短暂参与 Windows 95 的 OLE presentation cache,保存嵌入 Word 或 Excel 内容的 metafile 渲染结果,从而无需反复加载源应用。Windows 95 在 Windows 3.1 的16位产品线上扩展出32位支持、VxD 驱动和全新 shell;Start 菜单让这次发布显得具有革命性。
他的影响力排名刻意不以消费者为中心:第一是 OS/360,第二是 Windows 95,第三是 Linux。OS/360 的理由是兼容性——按他的例子,一段1962年的 COBOL 程序可以一路运行到 IBM z17;而 Linux 几乎无处不在的服务器覆盖,使它拥有比 Unix 更大的实际触达范围,后者的血统则更偏学术。
NT 更接近一款从零开始设计的工业操作系统。Microsoft 在包括 PRISM 和 MICA 在内的项目取消后,招募了 Dave Cutler 及其他 DEC 工程师;NT 主要用 C 编写,而不是像 OS/2 那样使用汇编,但 Plummer 不确定团队究竟能复用多少 OS/2 代码或设计。
Plummer 所在的 shell 团队把 Windows 95 界面移植到 NT,将8位 ANSI 假设转换成16位 Unicode。移植意味着逐行检查一切——“像闯进别人家里,把他们所有东西都翻一遍”——既包括优雅的公共房间,也包括藏在床头柜里的、满是脏话且宽达200个字符的代码。
7. 老 Microsoft 靠通宵压力测试与裸汇编发布产品
工作日从下载一份固定的 MS Mail 地址簿开始,覆盖约1万至1.5万名员工,使用10-megabit 网络。第一小时被这项工作占用时,开发者会调查那些被“Stress”压垮的机器;这是一个夜间进程,会接管闲置 PC、运行测试,并通过串口线把故障机器接入 debugger。
崩溃分流完成后,Plummer 才回到编码工作——也就是约80%的时间在修 bug 和做移植。他写副项目,部分是为了“把它从我的系统里排出去”;而白天修复别人代码的工作,则提供了异常深入的学习。
调试 NT 时,即使源码是 C,也必须阅读原始汇编调用栈。崩溃可能发生在 Intel、MIPS、Alpha 或 PowerPC 上,每种架构都有不同指令集;Plummer 最擅长 MIPS,因此这类故障自然会流向他。
工具是缺失的放大器。团队使用
diff和手工差异文件;Plummer 认为,如果当时有 Git 和轻松的分支管理,工作会“容易得多”。人是基础,但“工具就是一切”,因为工具决定了这些人能多安全地协调变更。
8. 强势架构师守住质量,但智力也可能变成表演
Lex 把 Cutler 类比为 Linux 世界的 Linus Torvalds;Plummer 认为 Cutler 是 NT 的 kernel architect,也是项目的驱动力。Plummer 形容他既“聪明得邪门”,又“像个农夫”:紧盯工作进展,要求必须完成,拒绝让糟糕代码进入操作系统。这种监工式风格把 DEC 的工程纪律带进 Microsoft,在 Plummer 看来最终收获了回报。
争论仍可能从技术评估滑向地位竞争。他记得有人在 NT 邮件列表公开抱怨 Cairo 的启动体验,随后引发一封精心写就、怒气十足的 flame;他说,有些争执最终变成“技术优劣……只是次要问题”,关键是压过对方。
他至今仍耿耿于怀的一次失败,涉及 MIPS 上可变长度的 shell ID 列表。奇数字节边界迫使系统进行异常处理和手动字符串复制,让读取成本可能增加100至1,000倍;尽管 beta 已经发布,他仍希望 Windows 95 能保证长度为偶数,但争论变成了私人对抗,最终他输了。
Plummer 仍相信,最终形成的 Windows 路径“比应有的速度慢了几千倍”。同样重要的现实让步是:没人关心,因为它仍然足够快。这说明当硬件把成本隐形化后,技术上较差的决策也可以无限期存续。
9. 严格调试始于先断言哪些事情不可能发生
Plummer 估计自己的职业产出是20%创造、80%调试,部分原因是能力越强,越容易被交给最棘手的故障。一个持续一天的 bug,通常要么是令人尴尬的小语法错误——“哦,多了一个分号”——要么是跨线程 apartment 行为之类的真正复杂交互。
Task Manager 偶尔会显示总 CPU 使用率超过100%。Kernel 工程师起初认为这是 user-land 的错误,因此 Plummer 对每一个准备阶段的求和以及最终总数都做了断言;当这些断言始终没有失败时,他把自己的电话号码嵌入断言,以捕捉一次真实运行中的复现。
Stress 最终在 debugger 下捕获了这个事件,证明问题出在 kernel 的计量缺陷。Kernel 团队修复了它,但 Plummer 那行被注释掉的电话号码随产品发布,后来又出现在泄露的 NT 源码中;他于是通过搜索自己的电话号码,在网上找到了 Task Manager 的代码。
他的规则是绝对的:“我不会断言那些我希望不是真的东西。我断言的是我知道不可能为真的东西。”随着每个函数的假设逐渐明确,断言应自然增加——非空指针、有效计数、不可能状态——因为断言触发是帮忙,不是丢脸。
10. Task Manager 能延续下来,是因为它把失败排除在设计之外
Task Manager 起初是 Plummer 在家里为自己想要的工具。原型从注册表读取性能数据;进入 Microsoft 后,
NtQuerySystemInformation和NtQueryProcessInformation等内部调用提供了快速答案,使它得以随 NT 4.0 发布,既是检查工具,也是终止失控应用的机制。可靠性比功能广度更重要。任何可能触碰网络路径、并等待90秒的调用,都会在另一个线程中运行,因此即使依赖项停滞,界面仍保持响应。这种防御式多线程增加了内部复杂度,却能让应用恰恰在系统其他部分不健康时保持可用。
原始可执行文件约87K。Plummer 拒绝链接 C runtime,避免再增加约96K,然后从 dispatch tables 手动调用 C++ 对象构造函数;他把结果描述为“带对象的 C”,通过“大量额外工作”实现了极小、极紧凑的 binary。
行与列都带有 dirty bit,因此只有变化的单元会被重绘;这项技术是他独立想到的,也让他联想到 Hamming code。调整窗口大小依然流畅,32个 CPU 可以在8张图之后回绕;这套设计经受住了当时不存在的硬件。如今的绘图、dark mode 和 XML 层让程序膨胀到约4MB,但他相信大部分原始代码仍然存在。
11. Pinball 与激活功能体现了可靠救火工程师的价值
为证明 NT 能提供响应迅速的图形体验,Plummer 花了约3个月移植 Space Cadet Pinball。大量汇编代码必须改写成可移植 C,以适配 MIPS 等架构;一个约50个入口的状态引擎——包括一个 Easter egg——则作为黑盒保留在他的绘图和声音工作之下。
一个计时 bug 解释了为什么现代 Pinball 感觉不同:它会尽可能多地渲染帧,理论上每秒可能达到5,000帧,而不是约30帧。因此物理计算会被插值数千次;在保留原始游戏逻辑的同时,产生了 Plummer 所说的可能更好、至少不同的行为。
Solitaire 和 Minesweeper 被加入系统,与其说是娱乐,不如说是鼠标训练:Solitaire 训练拖放,Minesweeper 可能训练右键插旗。Pinball 则承担另一种平台任务:用视觉证明这个被认为是工业级的 NT 也可以感觉很快。
Windows XP 后期,一项适配 Office activation 的工作延误后交给了 Plummer,因为他修东西很快。他与 DRM 和研究团队合作,及时交付了 activation;他猜测其收入影响相当大,但并不知道具体数字,并称电话激活对用户和那些需要读取编码硬件与产品密钥数据的运营人员来说都是一只“信天翁”。
12. Visual ZIP 把工艺转化为收购杠杆
1993年,Plummer 看中一栋约30万美元的房子,门外停着一辆 Torch Red 1993 Corvette;他剪下房源照片,贴在显示器上。每晚编程既带来了修 bug 工作中缺失的创造力,也可能打开第二收入来源。
他从一个 shell-folder sample 开始,逐步加入 ZIP 处理功能,并以$19.95或$29.95销售 Visual ZIP。Microsoft 后来冷电话联系这款产品的作者,却不知道他已经是公司员工;直到他问对方自己应该走到哪栋楼,误会才结束。
如果拒绝 Microsoft 的报价,他要么辞职继续销售,要么留下来放弃收入,因此他接受了报价,并买下一辆二手红色1993 Corvette。在内部,Windows 去掉了当时被视为弹药的加密功能,也很可能去掉了多卷支持,以简化这项无处不在的平台功能。
Plummer 认为 ZIP 的需求源于 BBS 时代的 modem 经济,以及 Phil Katz 的 PKZIP;当时可执行文件可能被压缩到原体积的一半左右。旧实现如今暴露出时代局限:在一台“96-core 7995”上,Windows ZIP 解压仍只使用一个核心,“本来可以大幅改进”。
13. 定制化在用户愉悦与永久复杂度之间交换
Lex 对 Windows 11 的抱怨具有战略性,而非审美性:允许用户自由调整任务栏和 Start menu,会奖励高级用户、建立声誉,并传递出一种公司文化——个别工程师可以在细节上投入大量心力。他的类比是一部电影:微妙的处理可能只被少数观众直接看到,却会增强整部作品的气质。
Plummer 的反驳值得保留:自由不是免费的。支持左侧、顶部、右侧、多行和不同布局,会扩大渲染逻辑、测试范围、bug 面和人员需求;Lex 还提出了潜在的安全漏洞问题。删除这些分支,或许能让重写后的任务栏提前4个月发布。
他们更深层的共识是,持续的 ownership 时间才能带来打磨。Plummer 认为,如果 UI 每次发布都变化,一个组件就不可能真正稳定下来;Lex 则反驳,只要管理层允许副项目的能量释放,一个充满热情的个人仍能像 Task Manager 一样迅速做出美好的东西。
Plummer 又提出 Steve Jobs 的问题:提供4种选择,是否意味着设计师没能找到正确的那一种。Lex 接受 Apple 的模式,但认为 Windows 应成为相反的平台——覆盖广泛硬件、兼容 Linux、对开发者开放——其界面也应表达同样的多元主义。
14. 增长黑客可以把需求变现,也会悄悄消耗信任
在 Software Online,Plummer 购买 banner 广告时没有设置上限,回来后发现已经被收取约1万美元。看到约3.8万美元销售额后,震惊转为兴奋:“我只需要把它放大。”此后几年,他不断重复这套循环。
除了家庭和健康问题,监管麻烦是他人生中最可怕的经历。Washington 总检察长提出约12项指控;Plummer 被10项他认为明显不成立的指控吸引了注意,而真正有后果的两项涉及试用期结束后的每日提醒,以及默认配送实体介质。
和解后,提醒频率据他记忆从每天最多一次降为约每周一次,并要求提供一键卸载。一个勾选框会为邮寄光盘增加$3.95或$4.95,因为2000年代初的买家预期会收到实体介质;但 Plummer 说,在 Washington State 默认收取更高价格,从先验上看违反了 negative-option billing 规定。
Plummer 如今理解,以性、恐惧或贪婪为框架的广告,实际效果可能不同于设计意图,尤其是自闭症让他误以为自己的理解具有普遍性。Windows 也触发了同样的信任问题:当“推荐设置”可能恢复 Edge 时,Lex 看到的是被动使用量增加,但声誉受损;Plummer 的表述更简洁:“你不希望自己的操作系统成为对手。”
15. 平台传说往往掩盖了实际的工程原因
约1996年,Plummer 参与了 Windows Media Center 的原型设计,目标是提供一种远距离观看的界面。团队最初只有包括 Raging Rudolph,以及他认为还有原版 South Park Christmas video 在内的 MPEG 文件,后来因为大楼无法接收有线电视,他们在屋顶安装了一只卫星天线。
当不可能的条件——例如非法写入或 double free——让程序继续运行变得危险时,blue screen 是 kernel 最后一道安全动作。NT 的白底蓝字并不是为了方便在实验室里识别:Jon Viert 让它同时匹配 MIPS firmware 和他的 Visual SlickEdit 环境,使编码、启动、崩溃与重启共享同一种配色。
重启“能掩盖很多罪过”。它会释放泄露的内存,也会重置进入罕见、未经测试状态的应用;当多个程序同时处于这类状态时,就会产生 Lex 所说的“meta goofy state”,让一次干净重启异常有效。
Plummer 欣赏的代码包括 NT kernel 异常高的标准,以及 Bob Day 为 Windows 95 共享 shell 内存设计的 named-pipe 替代方案。在各个版本中,他最喜欢 Windows 2000 Server;两位嘉宾都给 XP 极高评价,理由是寿命、完整性、稳定性,以及 Lex 所说的一致性设计,Plummer 则简单称其为“crisp”。
16. 清晰结构与可比基准揭示语言取舍
Plummer 如今会先写出干净的骨架代码,再逐步填充,颠倒了过去先不断堆代码、之后再清理的习惯。太多项目最终会在结构上变得“无法修复”,因此复杂度控制必须在功能压力把错误形状固化之前开始。
他的核心语言是汇编和 C++。他要么使用不含指针或字符字符串的现代 C++ 20——“在我看来,基本和 Rust 一样安全”——要么使用“带 classes 的 C”,在保留 C 心智模型的同时,使用多态和封装。
一台拥有1TB RAM 的机器支持 GitHub Primes:同一个素数筛算法被用约100种语言表达,容器化后每天夜间进行 benchmark。测试会反复筛到1亿,在5秒循环内使用全部核心,每个整数最多允许1 bit,并要求在计时循环内分配内存。
Plummer 上次查看时,Zig 排名领先,但排名会随 C++ 贡献者改进版本,以及“Zig guys 生气了”之后做出回应而变化。多个 C、GCC、Clang/LLVM、PowerShell 和展示性实现,揭示了语言约束与后端共性的双重作用;如今 Rucker 和 Tudor 管理这个项目,因为贡献规模已经超过 Plummer 最初用 Python、C# 和 C++ 做的比较。
17. Tempest 让 AI 编程可以与人类专家直接比较
Plummer 持有 Tempest 世界纪录,能打到96关。这款1980年的矢量游戏是“被包进一个形状里的3D Space Invaders”,包含360度移动、同时发射8发子弹、约11个敌人和尖刺、旋转式光学 spinner、火焰,以及紧急 super zapper。
为训练 agent,他提取并逆向分析 ROM,映射 zero-page 变量和相关游戏状态,然后编写 Lua 代码,在游戏运行时读取内存。Lua 通过 socket 向 Python 发送参数,Python 中则运行 Dueling Deep-Q 系统学习策略。
Agent 能达到约36关——已经超过大多数人类,但远低于 Plummer。Lua 和 Python 各约几千行代码协同工作,他认为项目已完成95%;剩下的不确定性包括模型规模、层数、超参数,以及调优能否跨过学习门槛。
Cursor 对他有帮助,因为 Plummer 刚开始使用 Python:他手写的版本可能比简洁的生成代码长4倍。他称之为“vibe coding”,但仅限于有经验的程序员能够理解输出、判断对错,并知道下一步该下达什么指令。
18. 自闭症集中注意力,也会遮蔽隐含状态
Plummer 的基础模型是单向兴趣(monotropism):他的大脑会高度集中地做一件事,然后再转向另一件事。他是“连续单任务者”,伴有感官敏感和重复行为;当这些特征无法被调节或适应时,他认为它们会升格为影响约1%至2%人口的障碍。
优势在于:面对自己热爱、有回报且能看到进展的工作,他可以拥有异常强的专注力。ADHD 带来一种悖论:获得专注很难,分心却很容易;但一旦“锁定”,他就很难被拉开。
核心社交困难不是不知道别人有什么感受,而是不知道别人正在想什么。Plummer 会玩一场“小游戏式的代理 NPC 推演”,用自己站在对方位置上会有的感受来推测;电话会移除面部线索,因此讽刺和隐含意义比 FaceTime 更难理解。
他故意设计的粗略测试说明了这种模式:谱系人士可能把创造力置于合作之上,也可能在6个人坐下后仍说房间里有10把椅子。小时候,面对“足够大到能装下一匹马”,他想到的是要不要把一匹马带进厨房,而不是意识到这是一种夸张说法。
19. 明确系统可以替代社交直觉
Plummer 的职业建议是“卖你能做的事,而不是卖你自己”。作品集、GitHub 记录、算法、性能结果或音乐录音,能够提供不依赖面试人格表演的雇佣证据。
管理工作暴露出假设别人拥有相同动机的局限。员工可能想要肯定、金钱、有影响力的会议,或决策权;他学会直接询问,因为他们的“希望、梦想、抱负”无法从自己的激励结构中推导出来。
他的“情绪后处理”会在事后反复回放不确定的互动,追问自己错过了什么、是否需要修复,以及下一次该如何应对。一次汽车修复历时3年,十年后他才意识到自己当时显得兴致缺缺,于是发邮件表达感谢;车行老板回复:“我一直想起那一刻。”
Plummer 反对自闭症会消除共情的说法:他可能察觉不到痛苦,但一旦被告知,就能强烈感受到它。他实际需要的是“请说得非常具体”;masking 意味着有意识地制造姿势、表情、动作和语调,而 meltdown 则发生在过载让大脑切入恐慌与 fight-or-flight 状态时。
他31年的婚姻依靠明确的状态确认——“你还好吗?”——答案和语气共同传递信号。两人差异的一个早期迹象是:他曾思考邻居的砖柱是空心还是填了混凝土,而未来的妻子问他:“你的脑子里为什么会有一个位置在意这种事?”
20. 编程会走向更高抽象层,但判断力仍是稀缺层
Plummer 不相信新手可以直接 vibe-code 出可靠的生产系统。用户必须读懂生成的代码、理解领域、发现失败并指挥下一步;但对进入陌生语言的强程序员来说,AI 可以让他们“变得极其强大”。
他的预测像桥梁建造:工程师过去会操作单根梁,现在架构师则在 AutoCAD 中组装更大的预制结构。程序员同样会移动组件和接口、描述交互,而不再逐行放置代码。
限制仍然很大。今天还不能提出“给我一个兼容 Linux 的 Linux kernel”,然后得到整个系统;Plummer 认为这一天终将到来,但表示距离这种复杂度的整体生成“还相当遥远”。
他亲历了从 TTL logic、手工输入机器码,到 C++、Python 和 AI 的演进,形成了一套新人很难复现的分层视角。他对人生意义的简短回答也由此而来:“做酷东西”——复杂、有用、别人可以使用的东西——然后也许养育几个好孩子,把接力棒传下去。
The following is a conversation with Dave Plummer, programmer and an old-school Microsoft software engineer who helped work on Windows 95, NT, and XP, building a lot of incredible tools, some of which have been continuously used by hundreds of millions of people, like the famed Windows Task Manager. Yes, the Windows Task Manager, and the zip/unzip compression support in Windows. And he ported the code for Space Cadet Pinball, AKA 3D Pinball to Windows. Today, he's loved by many programmers and engineers for his amazing YouTube channel called Dave's Garage. You should definitely go check it out. Also, he wrote a book on autism and about his life story, called Secrets of the Autistic Millionaire, where he gives really interesting insights about how to navigate relationships, career, and day-to-day life with autism. All this taken together, this was a super fun conversation about the history and future of programming, computing, technology, and just building cool stuff in the proverbial garage. This is the Lex Fridman Podcast. To support it, please check out our sponsors in the description, and now, dear friends, here's Dave Plummer.
Tell me about your first computer. Do you remember?
I didn't own my first computer for a long time, but the first computer I ever used was a TRS-80 Model 1, Level 1, 4K machine. I rode my bike in fifth or sixth grade, when I was about 11, to the local RadioShack. They had the standard component stereo systems and everything else RadioShack had, but they also had a stack of boxes labeled “computer.”
I asked the people who worked there about it, and they said they had just gotten it and hadn't set it up yet. I was rather precocious, so I figured, “Well, I'll set it up for you.” They said, “Okay, have a shot.”
Did you know what you were doing?
Absolutely not. It's no worse than a component stereo. The only thing is that Tandy, in their infinite wisdom, used the same 5-pin DIN connector for power, video, and, I think, cassette. They were all identical, and if you plugged them in wrong, you'd blow it up.
I read the label and got it working, and wound up playing with it without knowing anything about computers. I was typing English commands into it, and “PRINT 2+2” worked perfectly, but more simple English that you enter into a BASIC Level 1 interpreter wasn't going to get you very far.
So you're trying to talk to it in English?
I didn't know any better. I still have an old foolscap sheet that I wrote on in sixth grade with a program that's kind of illogically correct, but has no chance of working on any interpreter that existed at the time. It took me a while to figure out what was actually going on with computers.
I rode my bike down there every Thursday and Saturday, and they were gracious enough to let me use the machine.
When was this?
'79 or '80.
Okay. What was the state of the art of computing back then? What are we talking about?
The big 3 had come out. There was the TRS-80 Model 1, the PET 2001, and the Apple II, which came out roughly simultaneously.
The Apple II. Would you say that's the greatest computer ever built?
Probably, in retrospect. I would probably give that to the Commodore 64.
You and I agree on this. That was my first computer, probably many years after it was released, but the Commodore 64 was incredible. The Apple II had a huge impact on the history of personal computers.
It's hard to gauge the long-term impact, but I think the Commodore 64 itself probably influenced more people. That's my reason for picking that one.
You think so?
The sales were certainly higher.
So the Commodore 64 sold a lot?
Yeah. The numbers are hard to believe. It depends on which numbers you believe, but even the medium estimates were pretty high.
All right, cool. So you eventually graduated to the Commodore 64. Tell me about that machine. What did you do on the Commodore 64?
The first thing I did was overheat the floppy drive, which was unfortunate because it wasn't a warranty machine. My parents didn't have a lot of money, so we bought it from Computer House as opposed to one of the major retailers. When it died, it had to go back to Germany or somewhere to be fixed.
I was left with no floppy, so I had a cassette deck, which was the best you could do at the time. I was writing small things, and I had a machine-language monitor that you could load from cassette. It didn't have an assembler built in, but it had a disassembler, so you could enter the 6502 opcodes in hexadecimal.
If you were careful about planning, you'd be able to write some basic programs. That's how I learned. The first thing I ever wrote on it was a clone of Galaga. It was a bad clone of Galaga, but it had the major enemies that attacked over time, and it was all written in hand-coded machine language.
You can't relocate the 6502, so if you needed to add code in the middle, you had to manually jump somewhere else, do your work, and jump back to where you were. It was hideous spaghetti code, but it all worked eventually.
I went to make a backup of it to preserve it for future scholars, or whatever the hell I was doing, and I copied my blank floppy onto my data floppy. That was my first experience with data management.
Oh, no.
So I don't have a copy of my first program anymore.
What was that feeling like, doing something, if I may say so, stupid? That's part of the programming experience.
There was a huge amount of guilt because you destroyed several weeks of work, and you knew it was because you rushed, or you did something stupid, or you made an unwise choice.
Yeah.
Can you tell me about the programming involved in that game?
It was literally machine language.
So it's not even assembly?
Not assembly yet, because there was no assembler built in. I should have written an assembler, written in assembler, as my first task, but I wasn't that clever.
How hard is that to do?
Trivial, and it's one of those things that sticks. You do it so many times. If I give you a C issue, there are certain syntactic issues in C that you're never going to forget or get wrong. It's just one of those things.
What are the limitations of programming in machine code, as a programmer?
The biggest issue is that you have to write completely sequentially because, at least in that variant, the 6502, you can't add things later. You can only add things at the end. It's like programming a tape in a way.
What was the most complicated thing you've built with machine language?
That game would be it. In assembly language, I've done a fair bit of complicated stuff, but in actual machine language, I think that game would be the only thing I've actually built.
You literally built a game.
Not a great game, but it worked.
Okay. All right. And then you erased it?
I did.
All right. When did you first fall in love with programming? When did you figure out, “This is something special”?
I think there were 2 stages for me. I always knew immediately that I was fascinated with these machines, starting with the TRS-80 Model 1. All I wanted to do was ride my bike back there and have more time with it. I did that until I wore out my welcome as much as I could.
The other revelation came around the 2nd or 3rd year of university, when I realized, “I love programming, but I have no idea what I'm going to do. Am I going to make the 12 flash on a VCR somewhere, or am I going to go work on an operating system? I have absolutely no idea what I'm going to do after graduation. But I love what I do.”
That was a lot of consolation. It didn't really matter what I was doing at that point, because I loved doing it.
So you'll figure it out, as long as you're following this feeling that's telling you—
I knew I was in the right area, finally.
Yeah. All right. You dropped out of high school.
Yeah. Not the smartest move.
Okay. But you ended up going back to school and being very successful there and, in general, successful as a programmer, developer, and creator of software. How were you able to find your way? Can you tell me that journey of dropping out and then finding your way back?
There's no moment when you drop out. You just go less and less and less until you realize it's going to be embarrassing if you show up because you haven't been there in a long time. Pretty soon, you're just not going, and that's how you drop out of high school. If you find yourself on that path, stop doing that.
That's precisely what I did. Now I'm not at school, and I have to get a job, so I'm working at 7-Eleven, a paint warehouse, and places like that. 7-Eleven is actually an interesting job because I think they keep rotating in people who are smart enough to do the night shift, with all the accounting and administration they make the night shift do, but who have personal reasons that require them to work at 7-Eleven. I was one of those people because I had no high school diploma.
What are some memorable moments from that time at 7-Eleven? Maybe what do you appreciate about the difficulty of that job?
Probably the worst moment for me—I got held up at knifepoint and stuff, and that's all entertaining—but the suckiest part for me was doing the gas dips. We had a long, 15- or 20-foot wooden stick, measured in gradations of inches and feet. You dropped it into the gasoline tanks, brought it back up, and measured where the gasoline sat because there was no electronic sensor.
The first time I did it, I dropped the pole and re-grabbed it. That put about 1,000 splinters of wood into my hands. It was 40 below, and that really sucked.
I realized, “I don't want to do this for my whole life.” I knew that.
Okay. So you stand there frozen with splinters in your hand.
At some point, I have a revelation about my life that next time I’m going to do it differently. Then how ludicrous that is hits me about 3 seconds later, right? I think that was really the moment for me when I realized that I’ve got to do something different.
Even though I was 21, I went and talked to the principal of my local high school, and I was like, “Can you let me back in?” He said, “No, you’re too old and we don’t have room,” was his main reason. I said, “Well, between now and then, somebody’s going to drop out, so you’ll have room. Let’s assume you have room. Can I come back?” He was gracious and let me come back. So I did the 3 or 4 classes that I needed.
Yeah, you know, if you can linger on that—the slow dropping out. That’s a weird thing that you can do with your brain. You realize to yourself that you don’t have to do the thing that everybody else is doing, and that’s a dangerous realization because you kind of have to be part of society to do certain things.
Right.
If you realize you don’t have to do what everybody else is doing, you can either have an incredible life or a really difficult life.
Well, the problem with that process is you’re making a much smaller decision: “I’m just not going to go to class today.”
Yeah.
You’re making that decision, but you do it enough times and you’re making a much bigger decision. That’s the problem.
So it’s better to make the big decision explicitly if you want to live life in a nonstandard way, and then you can stop going.
Yeah.
Don’t allow yourself to make the slip-ups, though.
It’ll be made for you eventually.
Yeah. Okay. Well, you got back, and you eventually went to college and were very successful as a student. You weren’t that good of a student before.
No, I was a terrible student in high school, and even my first semester of college, I still wasn’t taking it quite seriously because I got mercy-passed in Geometry 90, which is the makeup class for the 12th-grade geometry class that I didn’t have. That scared me because I realized that by 1%, or by the grace of the professor who let me through, I just about ended my entire university career.
Fortunately, those marks don’t count on your transcript because they’re remedial classes, so I got a fresh start the next semester and did it for real. I did it for me, and that made all the difference.
What can you speak to, maybe by way of advice, on how to be successful as a student?
Ideally, there’s some aspect of school that you enjoy, whether it’s art, computer science, shop class, or whatever. Go for those classes, and just put up with and do the hard stuff because it’s way easier than having to do it later.
That’s easy to say when you’re 50-something; it’s harder when you’re 15-something, but it makes a lot of sense.
All right. What’s the story of you joining Microsoft? How did we get there from 7-Eleven to Microsoft?
Yeah, it’s a big jump. I had gone back to school, and I think it was in my 3rd year of university. I was working for the phone company for the summer, doing conversions of their UBNet to TCP/IP and modern networking, which really amounted to swapping cards but then figuring out why their CONFIG.SYS didn’t allow Lotus to run anymore because it had 10K less than it used to. It was just a horrible time to be working in computers, but I was doing it.
At lunch, I was sitting in the food court with the old and the bored, and I was reading a book that I had bought called "Microsoft, or Bill Gates, and the Making of Microsoft Hard Drive," I think is the title. It’s a great book. It’s just a matter-of-fact history of how Microsoft came to be, what it’s like, how it operates, and what the people are like there.
I became really entranced by it and fascinated because it sounded like exactly the place I wanted to be. But I was in Saskatchewan, so what was I going to do about it?
What I wound up doing was putting myself through school with a program called HyperCache, which is a file system cache for the Amiga because the Amiga didn’t have one out of the box. It had done reasonably well. I went through my registration cards, because in those days you had a 4-by-6 card that people had to fill out with their name and address and, if they had email, their email address. They’d send it in and get notifications of updates and so on. It was shareware.
I went through the whole stack looking for anybody with a Microsoft email address. I found maybe 3 or 4 people and cold-emailed them. I said, “Hey, I’m an operating systems student in Saskatchewan looking for an opportunity.” I don’t remember exactly what I said.
One guy, Alasdair Banks, wrote back and said, “I know somebody that I can put you in contact with.” He put me in contact, I think, with a guy named Ben Slivka, who did a phone interview and eventually wanted to hire me to work on MS-DOS for the summer. So that’s how I got there.
You put yourself through school with HyperCache. Tell me about HyperCache. You built a piece of software that was sufficiently useful to a large number of people that they would somehow give you money?
Yeah, it made decent money. I sold a couple thousand copies at 20 bucks a copy or 40 bucks a copy, depending on the rules.
What language was it written in?
C.
So there were some assemblers.
The actual, really tight code to do the real work of transferring data to and from the cache was 68000 assembly. Everything else was C.
Okay. This is like file system I/O?
Device block I/O. Any block that got serviced from the drive would go through my cache first, and it was an N-way associative cache. It would try to match the geometry of the drive and do prefetch based on when you’re trying to read a whole track at one time, that kind of thing.
What was it like trying to get your software out there at that time? How were you able to find customers?
It’s interesting. I think I started on Usenet and some of the Amiga forums. I posted, “Here’s my trial version. Try it out for 30 days and see what you like.” Eventually, it got picked up by a few retailers.
I remember I was with my now-wife in her car, and she had a cell phone because her dad was very concerned about her safety. This was the late ’80s, and she had the antenna on the roof and the big box in the trunk, the whole deal. We got a call from one of the software retailers that wanted to buy 50 copies at 20 bucks, which to me was $1,000. In 1989, or whatever year it was, that was a big deal. Eventually, a number of companies just bought inventory.
Let’s go to that time. It’s such an interesting time with Bill Gates and Microsoft. Why do you think Microsoft was dominating the software and personal-computing space at that time, and really for many, many years after?
At the time, it was the single most potent assemblage of smart people that I’ve ever been a part of. I’ve been in academia and I’ve been in industry to a certain extent, and when you’re working at a regular computer company, the one guy who actually knows what he’s doing—his smarter friend? He probably works at Microsoft.
When you get there, you’re the big cheese from your small town. You think you know a lot, and all of a sudden, you’re in an environment where you’re like, “Uh-oh.”
Mm-hmm. Okay. What about Bill Gates himself? What are some qualities of Bill Gates that you think contributed to the success of Microsoft?
I think he was relentless in the pursuit of his one dream, which was his old slogan of “a computer in every home and a computer on every desk.” It was his special interest, and he was a smart guy, super determined, and he hired people who were as smart or smarter than him to help him execute it.
He built an almost unstoppable machine of intellect to go forth and make, let’s say, very simple products. MS-DOS is not a complicated product by any stretch, but it’s exactly what the market needed at that time.
Yeah, MS-DOS changed the game. That’s actually the team you joined, the MS-DOS team, and I think you joined before Windows 95 was released. Tell me about the story of MS-DOS. The success of MS-DOS is probably pivotal to the success of Microsoft.
Before DOS, they were largely a language company, so they had made BASIC for a lot of computers, and they had a Fortran compiler and a Pascal compiler, that kind of thing.
Their deal to have MS-DOS included with every PC effectively set them as a standard that they were able to leverage for decades going forward. To a certain extent, they lucked into that. On the other hand, they were smart to have done it. They didn’t charge IBM a lot of money for it, but making it a standard really played out to their advantage over time.
At that time, MS-DOS had no graphical interface. Can you just speak to what the heck MS-DOS is?
It’s largely a command launcher. You type in the name of a command, and it looks it up to see if it’s in the current directory or on a special path of folders. If it’s there, it loads it into memory and executes it. That’s 90% of what MS-DOS does.
It has environment variables and some complexity and a small scripting language built in, but it’s basically just an operating-system shell that allows you to use the resources of the computer, like the hard drive or the CPU. It doesn’t allow you to multitask, and there’s no graphical interface.
Microsoft did add a text-based graphical interface for things like an editor and QuickBASIC in DOS 5.0, I believe. There was a DOS Shell, which was sort of a graphical file manager, in MS-DOS 4.0. So they experimented with it, but it’s largely a command prompt.
Does it have the ability to communicate with external devices, so drivers and all that kind of stuff? How expansive of an operating system was MS-DOS?
It was limited by the original x86 instruction set, which limited it to 640K.
Right.
And then there were various Band-Aids on top of that to do high memory and then extended memory beyond that. A lot of hoops had to be jumped through to make anything work without consuming base RAM.
Yeah, you programmed on MS-DOS. What was it like? What are some interesting details there? Like you said, there's the memory constraint of 640K.
Yeah, 640K is the maximum that's ever going to be available. It's not what's available to you as an operating system developer, because whatever you use is what the user won't get. So if you use 10K needlessly, every machine in the world now has 10K less. It's kind of a big responsibility.
Is that a true quote from Bill Gates, where he said, "Nobody will ever need more than 640K"?
Yeah.
Yeah, no, it's not him.
Okay.
It's been attributed to him, but it's not real.
David Plummer
Okay.
So what are some interesting aspects of what you were able to do as an intern and when you joined on MS-DOS and beyond?
David Plummer
One of the first things I did was take SmartDrive, the disk cache—I had familiarity with disk caches—and add CD-ROM caching to it, because that was new. CD-ROMs were just coming out. Microsoft Bookshelf was one of the few products you could run on them. As you can imagine, caching a CD speeds it up by dozens of times if you're smart about it, so it was a big performance win and a nice thing to work on.
A bigger part of that was moving a bunch of SmartDrive, and eventually the DoubleSpace compression engine, up into what's known as high memory. Without rat-holing on the technical aspect of it, on the x86 there's something called the A20 line. I probably have this backwards, or I have a 50-50 shot at it, but if you've got the A20 line asserted, then your memory pointers wrap at the 1-megabyte mark. If not, they don't, so you continue going up in memory.
You can address memory above 1 megabyte by combining your segment and offset registers to a number bigger than 1 megabyte, and you get an extra 64K. You put your code in there, and then you just put stubs in low memory to jump to it. You can get another 64K out of the machine that way, and we did that for a couple of products. I had no idea what HIMEM was, because I was an Amiga programmer and I'd never written any x86 code before I got there.
So that was a cool optimization you got to be a part of. What about Windows? There was a parallel development of Windows 95, right? At that time, did you get a chance to interact with those folks?
David Plummer
I actually worked on Windows 95 for about 3 or 4 months. I was on the COM/OLE team doing the presentation cache, which is when you insert, say, a Word or an Excel spreadsheet or chart into a Word document. You don't want Excel to have to be loaded to render it every time, so there's a presentation cache of enhanced metafiles, and I was working on that.
That shipped in Windows 95, but I moved to the Shell team about 6 months after getting to Microsoft, so I worked on NT from there forward.
Okay, and what's 95? What's NT?
David Plummer
Windows 95 is an evolution of the original 16-bit Windows 3.1, which was the first popular version of Windows. It adds 32-bit support, VxD drivers, and a bunch of new technology, as well as an entirely new user interface. It was something that, at the time, was revolutionary. People lined up at night to wait in line to buy the thing.
Can you just take us back to that time and describe why 95 was such a big leap from 3.1? Apple already had a graphical interface. Windows 3.1 had a graphical interface. Why was Windows 95 such a gigantic leap?
David Plummer
I don't want to make it as basic as the Start menu, but I think it's a big part of it. I know when I first saw it, I couldn't quantify what about it was different and awesome, but I realized that I wanted to be a part of it. That's why I started writing a Shell extension, which became Zip Folders at some point.
I was just fascinated by the new Shell, and that's why I wound up working on the team that brought that Shell over to NT and what's Windows today.
Would you say that's the greatest operating system ever? What's the most impactful operating system ever?
David Plummer
Windows 95 would be number 2 for me. I think OS/360 is going to be number 1.
Okay, interesting.
David Plummer
You could take a machine and write a COBOL program for it in 1962, jump in your time machine, go to Poughkeepsie, boot up an IBM z17 mainframe, and run it today. They've been doing it for however many years that is.
It's all on the business side, so we as consumers don't have much access to it, but I think it was probably as influential on the commercial side as Windows 95 was on the home side. Then probably Linux would be number 3 for me.
I put Linux as bigger than Unix, which doesn't work because you can't have one without the other, but the impact of Unix, BSD, and so forth is largely in the academic space. It's by programmers, for programmers.
So, yeah, Linux created—I mean, it was the embodiment of the open-source spirit at its largest scale. It created a community and a spirit of programming that propagates to this day.
David Plummer
That's true. That's true. Scale matters.
Yeah, and its penetration on the server side of things now is—I don't know if it's equivalent to what System/360 achieved, but it's almost ubiquitous.
David Plummer
Yeah, the world—I mean, this is the quiet secret of the universe—is that it runs on Linux.
Okay, so tell me about your workdays. What were they like back then, back in the MS-DOS and Windows 95 days? Take me through a productive day.
David Plummer
Well, your day starts when you come in, and you have to download the address book. Microsoft had between 10,000 and 15,000 employees at this point, and we were all on MS Mail. We were just getting off of the PDP-11 called Miss Piggy, which ran WhizMail, and we were running MS Mail.
But MS Mail had a fixed address book that every user had to download every morning. When there are 10,000 people downloading the addresses of 10,000 people, it gets pretty messy. I think we were on 10-megabit networking at the time, so your first hour was downloading the address book, which was always frustrating.
You'd use that time to look at the crashes that would have happened overnight from a process we called Stress. All the machines that were unused ran tests all night long and tried to crash themselves. If they managed to crash themselves, they would drop into a debugger with a serial cable to another machine, and you could connect to that other machine and remotely debug the crashed machine.
You'd come in, and there would be triaged bugs. There was a crash in the Start menu, so we'd assign that to Dave. You'd connect to the machine, because you had to get it back to the guy who owned it and unlock the machine. That was your first hour of the day: basically triage for bugs that had come up from Stress overnight.
At that point, it was probably back to coding, which unfortunately 80% of the time was fixing bugs. Especially in my career, I was porting code and fixing bugs. I wasn't writing a lot of new code, although there were exceptions. I wrote a lot of new code on the side to get it out of my system.
From the day-to-day grind of always fixing bugs in other people's code, it was an amazing learning experience.
So at Microsoft, you did a lot of the porting of—what is it? Windows 95 code to NT?
David Plummer
Yeah. We took the entire Windows 95 user interface and ported it to NT, which meant making it Unicode, for one thing. Everything that was 8 bits was now 16 bits. It's quite a mess when you switch the code over, as you can imagine.
Can you give us insights into what is involved in porting?
David Plummer
It's like breaking into somebody's house and going through all their stuff, seeing the things in their drawers that they didn't want you to see. You find all the good stuff, the pretty pictures hanging on the wall, and you find some disturbing stuff in the nightstand.
I saw code that was 200 characters wide, with profanity and swears in it. It eventually got cleaned up over the years by the time I left, but it was not always the most professional code in the world.
Right, because every single piece of code you have to go through.
David Plummer
Line by line, so you see it all.
Yeah. I mean, that's the story of programmers. You write a piece of code and you think it'll never be seen by anybody, and sometimes, oftentimes, that code is going to be seen by a very large number of people who come after you, including you 5 years later—yourself looking at your own code.
Okay, so tell me about Windows NT. That was a giant leap too.
David Plummer
It was. It was basically a clean-sheet design. They went and got Dave Cutler from Digital Equipment Corporation, who had done operating systems for them—VMS and RSX-11.
He came over after, I believe, PRISM and MICA were some projects at DECwest that got canceled. So you had a whole team of guys whose project was canceled, and basically, they took a whole bunch of them and came to Microsoft. I don't know the specifics of the deal, but they all showed up.
You had Dave Cutler, Mark Lucovsky, and all these really smart guys from DEC, and they did basically a clean sheet. They also had OS/2 as a starting point. OS/2 was, of course, written in assembly language, and NT was going to be written in C.
To what extent they were able to leverage any of that, I don't actually know, but at least they had a system to start with.
You said that Dave Cutler's the man, the mind behind Windows. Can you explain?
David Plummer
Dave Cutler is the architect of the kernel.
So he is Linus in the Linux world. It's Dave C. in the Windows world.
Yeah. Dave C., okay.
David Plummer
And it's not that there weren't other people who contributed huge pieces to it, but I think he's the driving force behind it and always largely has been. He's still—I think he's 85 now. He still codes every day. He's a Microsoft Fellow. As far as I know, he still goes in to work.
Can you speak to the genius of that guy? What's interesting about his mind, having worked with him and interacted with Dave Cutler?
David Plummer
Well, the dude's wicked smart, but he's also like a farmer. He's the guy who will follow you around and make sure that stuff gets done, and gets done right, to make sure that you're not checking any crap into his operating system. He won't tolerate it. He's a real taskmaster in that regard, but I think it really paid off because it was a very big paradigm shift for Microsoft developers to be subjected to the Dave Cutler, Digital Equipment-style of leadership.
What did you learn from that about successful software teams, where there's a large number of people collaborating? Microsoft had a lot of brilliant engineers back then, and, like you said, Dave Cutler. They had to create completely new systems, many of which we still use today. What have you learned about great software engineering teams from that time?
Tools are everything, I think, for one. People are everything. We'll take that for granted. But the tool set is a huge factor. If we had Git, it would have been immensely easier. We were using diff and manual deltas to do this porting and stuff. Being able to fork a branch of source code would have been a luxury that was new to me.
At the time, it would have been really handy. What were some memorable conversations from that time when you walked over next door and talked to some of these folks?
What I was not present for was somebody complaining. A new hire came into the team and was working on what I believe was called Cairo. Cairo was going to be the next future operating system. It was going to be beautiful and have a whole new user interface, newer than Windows 95, but it never materialized.
While they were working on it, one of the guys working on Cairo was kind of flaming on the open NT dev alias, which had thousands of people, about how awful the NT boot experience was. The response that came back was an epic flame that I wish I had saved. I won't name the guy who wrote it. He knows who he is.
It was a work of art of angry flame mail, kind of like the ones you see Linus send every now and then about kernel stuff. It was a very similar sentiment.
Were there intellectual debates? Was there some heated stuff with the engineers?
Oh, yeah. It got contentious. You've got intellects competing, and eventually, for some people, the technical merits become secondary. It's about besting the other person in that argument, and it's no longer productive at that point half the time. There was a fair bit of that.
Yeah, I've seen those kinds of debates in programming language design communities, like with Guido van Rossum and the leaders of those communities. It can wear them down because you almost forget the mission you're on and start being very nitpicky about the details. Engineering minds get together, and you just go to war over the stupidest syntax subtlety.
Right.
Well, I shouldn't say stupid, but it's a small syntax subtlety for a programming language. I'm sure there were internal battles about specific kernel components.
Yeah, there's one that I lost that still bugs me to this day.
Okay, yeah.
Because I still think I was right. When we were doing the shell, we were porting everything from ANSI to Unicode, so every character that was 8 bits now became 16 bits. The problem is that I'm on a MIPS box because I'm porting it to RISC, and you can't have unaligned addresses.
If you take 2 PIDLs, which are basically path components—you take the one for C:\, take the one for Windows, take the one for System32, and add them together—but if you've got an odd number of characters, now you're at an odd address in this thing. It takes me an immense amount of work to turn on exception handlers, do unaligned byte access, pull the string out, and copy it manually.
It's literally 100 to 1,000 times the amount of work to read a string out of this PIDL list on a MIPS machine because it's unaligned. So I'm making the argument that even though it's late in Windows 95, they've already shipped 1 beta, we should now just guarantee that PIDLs are always an even number of bytes, or do some hack to make sure this never happens, so the code that references them after all this hard work can just blaze through it.
It became a shouting match and sort of a personal match, and I lost that one. I still think—and I know today—that the code running on Windows is thousands of times slower than it has to be. Nobody cares because it's plenty fast, but it could be a lot faster.
Yeah. You mentioned MIPS and RISC. How deeply did you have to understand the lowest level of the software and even the hardware with the stuff you were building? What are the layers of abstraction you had to understand to be successful with all the stuff you were doing with NT and, before that, Windows?
About half your day is going to be spent debugging, and most of the time is going to be spent in call stacks that are in pure assembly language because there's no source-level debugging. It's not like we're in Visual Studio, you hit a breakpoint, and it pops up with the source code. You can go look at the source code, but you're looking at the raw assembly dump from the machine at all times.
So even if you're programming in C, the debugging is in assembly?
Yeah, 100%.
Oh, man.
Better yet, we're doing 4 instruction sets because we're doing Intel, MIPS, Alpha, and PowerPC. Depending on which machine it crashes on, you've got an entirely different instruction set. You get reasonably adept at debugging all 4, but I had more experience with MIPS, so MIPS stuff would come my way.
That's a real endurance event. Can you speak to the torture there, debugging without the tooling associated with it? Programming isn't all about creating beautiful things, right? It's also about fixing things.
I would say that 20% of my professional life has been creating, and 80% has been debugging and fixing. I got a bit of a reputation as somebody who could fix stuff, so stuff like that would flow to me, and I would spend more time doing it. I wasn't renowned as a creative UI genius where I was flowering all these new ideas. I got to fix ugly stuff, but you get really good at that.
I don't mind it until it's one of those things where you've been chasing it for so long that you don't know what to do next, and you can't understand why it doesn't work, or how it ever worked, or whatever situation you happen to be in. After a day of it, it can get pretty trying.
Yeah, debugging can be real torture. It can be really difficult. There's a psychological component, I think, of perseverance.
I think the ones that take you a day resolve in 1 of 2 ways. Either it's like, “Oh, extra semicolon,” and then you finally see it, or it's some horrible manifestation of cross-threaded apartment nonsense that was really hard. But it can go both ways.
I had a bug. It wasn't my bug, actually, but it was a manifestation of a bug in Task Manager where every now and then it would say greater than 100% total CPU usage. That looks pretty silly for Task Manager.
I had tried to resolve it for a long time, and I'd talked to the kernel guys about my issue. They were unsympathetic, let's say, because the kernel guys are a special breed, and they weren't interested in my user-land problems. It was probably some issue in my code, right? They were probably right, but it wasn't in this case, and I was sure of it.
So I kept adding asserts all through the code to make sure that the preparatory steps of adding the stuff together were never more than 100, and that the final sum was never more than 100. Finally, it never asserted. But occasionally, we would still get this bug where people would see it.
I finally put my phone number in the assert. I said, “If you see this message, call DavePL at 425-836,” my phone number. Finally, we did get a catch in the actual stress debugger that I was talking about earlier, where it happened to somebody with a debugger connected. We were able to go through it, and it was actually a kernel accounting issue, not a Task Manager issue.
They just fixed it in the kernel once I was able to prove that it was, in fact, a kernel issue. You'd think we would then remove my phone number, but we just commented it out. So it shipped, and it's in all the damn source code leaks for NT that are out there.
That's how I find Task Manager code: I search for my phone number on Google, and it will reverse-find the NT source code.
But that's awesome. That's fantastic. Can you speak to the assert thing? By the way, I saw—I think you tweeted or said somewhere—that if you want to take your asserts really seriously, you add your home phone number in there.
It's true. It's true.
A little facetious, because it's probably not the smartest thing, but—
No, it's not.
You will find out.
Assert by itself is already a serious thing because it stops all execution. This is one of the reasons I really love asserts: They stop everything and force you to take care of the problem.
Yeah, I'm a little religious about my asserts, too. I don't assert things that I hope aren't true; I assert things that I know cannot be true. I think that's really the intent of an assertion. I'm overstating the obvious, but when an assertion does occur, it's a bug, plain and simple. It's not a warning.
It's fascinating how often that can really help you figure out the problem, because if you put asserts everywhere, you can get very quickly to the source of the problem.
I tend to think it's not something you should go back and add later. It's something you should do organically as you build your code.
As you're building.
For each function, if you've got assumptions—like, “I know that this pointer is never null”—assert that. If you know this count is always less than twice the byte width, assert that. Don't be afraid, because if it asserts, it's doing you a favor.
I think some people are afraid. It's like when you turn out of an intersection and you think maybe there's somebody coming, but you don't look left. Maybe I'm one to do that. People don't assert because they're afraid they're going to fire. No, you want to know.
You mentioned Task Manager. Obviously, we have to talk about this—the legendary program that you created, the Windows Task Manager. Tell me every detail of how you built it. What is Windows Task Manager?
David Plummer
Windows Task Manager is a way to go in and find out which apps on your system are using the computer—using the hardware, the CPU, and the memory—and which ones might be using too much, locked up, or going crazy. It gives you the ability to terminate and kill those ones. It's an inspection and a fixing tool.
It lists all the processes. I mean, it's a legendary piece of software. It's crazy. We just take it for granted. It's like the Start menu, right? It's genius.
David Plummer
I had the great fortune of working on a lot of things that people are familiar with, and Task Manager was one of those side projects that I started as something I wanted for myself and that eventually came in-house.
I started writing it at home and got the basics up and running. I was using, I think, HKey Current Performance or HKey Performance in the registry to get the stats because I didn't have access to the internal APIs. I was working from home, and I didn't call those if I was working from home. When I brought it in-house, I was able to call things like NtQuerySystemInformation or NtQueryProcessInformation and get the real answers very quickly, which enabled it to become a very fast and responsive app.
People have come to rely on it because I wrote it to be as reliable as possible. I wasn't worried about the features. It was a basic set of functionality that I wanted in there, and I got everything I wanted, but I wanted it to be really robust—and small. The original was about 87 KB.
Can you speak to what it takes to build a piece of software like that that doesn't freeze?
David Plummer
You don't assume much. If you're going to call the shell to run an app, that could be a network path on a TCP/IP share that takes 90 seconds to time out. Anytime you do any kind of API call like that—something that could take time—you're going to wind up doing it on a separate thread. The app becomes a little more complex because everything is multithreaded.
What programming language were you working in?
David Plummer
C++.
This was for Windows NT?
David Plummer
Yes.
This shipped initially in NT 4.0?
David Plummer
Yes.
What are some interesting details about this program? You have to get it as simple as possible, but also as robust as possible. What are some interesting optimizations, for example, that you had to implement?
David Plummer
There are a couple of things. They're a little hardcore now, and I'm surprised I did them. I didn't want to link to the C runtime at all, so I made sure never to call a runtime function, and I didn't link to it. That saved me whatever the C runtime was—96 KB or something. It almost doubled the size of the app if you touched any C call.
I was careful not to do that, but I was actually writing in C++, which is “C with objects” more than anything. In order to get it to work, I had to go through and call all the object constructors manually from the dispatch table and stuff because you don't have the runtime to do it for you.
You're working with a compiler that doesn't have its runtime. I don't want to go down a technical rabbit hole on the issues, but it's a lot of extra work to get it to work. When you do, though, it's incredibly small and tight.
That's about the size of the program.
What are some interesting aspects of tracking down every process and how much CPU usage is in that process?
David Plummer
One of the cooler things I saw is that—I don't want to say I invented Hamming code, but I kind of invented Hamming code without knowing Hamming code existed. Every column and every row in Task Manager has a bit indicating whether it has become dirty or not.
Then I can look, basically the same way Hamming code looks in your X and Y columns, to find out which rows have changed, and go through and find out which ones actually need to be repainted. Task Manager is super efficient, and it works in concert with the ListView control, which provides the functionality to go through and repaint as little as an individual cell that changes from frame to frame.
It could paint very fast, and it could resize very smoothly. Resizing was probably my biggest personal goal with that app. You can size it to any size and it still works. Even if you have 32 CPUs—which wasn't possible in the day—it will draw, I think, only 8 graphs and then wrap, but it still works today. I'm kind of proud of that.
It is incredible. You've gotten the chance to observe the evolution of Task Manager. In some ways, it really hasn't changed much. Maybe there are some prettier aspects to it that fit into whatever version of Windows it's in, but it's basically the same thing.
David Plummer
The functionality is very much the same. The reporting is more extensive because they've added GPU and thermals and things like that, which is really nice to have. We didn't have that ability in the day.
What can you say? Do you know whether there was any refactoring done, or is it basically the same code?
David Plummer
As far as I know, the original code is still mostly all there. There are layers of drawing code, dark mode code, and whatever else—XML schema code—that go on top of that, making it 4 MB instead of 87 KB. But that's the world we live in.
It's one of those pieces of software you create, and once it's there, it's really like the Start menu. I'm sure if you removed it, people would just lose their minds.
David Plummer
It might be locked in for a while on that one. It might be good.
I thought that would be true for Clippy, but Clippy will make it back one day.
What are some other pieces of software you created at the time that are legendary? You were part of Space Cadet Pinball, at least in porting it.
David Plummer
They came into my office and said, “Hey, what are you doing?” I told them what I was doing, and they said, “How do you want to spend your next 3 months?” I said, “I have no idea.” They said, “Do you want to port Pinball?”
I had seen Space Cadet Pinball as a standalone game for the Windows 95 platform. It had a couple of different tables, and it was a cool game, so I was kind of excited. What they wanted was some visual splash for NT to show that NT could do high-speed graphics—or at least responsive graphics—for the time.
I took a shot. Unfortunately, a lot of the code was in assembly, and I was on MIPS, so I had to rewrite the code in C so that I could then port it to all the different platforms.
At the heart of the game is a huge state machine. It's like a giant switch statement with, if I remember, about 50 entries in it. It's got an Easter egg built in. Decoding the state is like running a neural network through this thing as you hit it with different states.
I just put it aside and treated it as a black box. My code runs on top of that and does the drawing, the sound, and everything else, but the original game is still running.
Somebody recently asked me why the physics are slightly different from the Windows 95 version. It should be the same code because I was trying very hard to preserve that. What it is, though, is that I had a bug where I would draw as many frames per second as I could, which on a modern computer can be 5,000 frames per second for Pinball because it's a pretty basic game.
All the physics are interpolated 5,000 times per second instead of 30 times per second, or whatever you would have gotten on the old one. So you're getting arguably better—or at least different—physics.
Why is that game so awesome?
David Plummer
I think it's a great design. I take no credit for that. That's all totally the guys at Cinematronics. The original game is a great design. It's very similar to Black Knight 2000, which I own as an actual physical pinball machine. The layout is actually very similar. I don't know if it was inspired by it or not.
Yeah. Sometimes I think about Tetris, about certain games with pretty primitive graphics that captivate a large number of people. Maybe it's the excitement of a large number of people that contributes to the awesomeness of the game. When many people get excited and talk about it together, that sort of gets implanted into your head.
That's one of the great games. Even Solitaire and Minesweeper—there's a generation of people that have gone to war in Minesweeper.
David Plummer
Those things were included in the OS not as games, but as educational tools to get you to use a mouse.
Oh, interesting.
David Plummer
So Solitaire is there to show you how to do drag and drop.
Yeah.
David Plummer
Minesweeper's probably right-click. I think you put a flag or some item.
Yeah.
David Plummer
I'm not a Minesweeper guy, but each one of them teaches you something.
Minesweeper guy. That's funny. Yeah. Wow, I didn't know that. That's interesting, and that's true. I don't know how many hours I've spent on these games, and millions of people have spent millions of hours on these games.
David Plummer
I used to volunteer teaching computer science at my kids' school, for the third graders and stuff. So it's more like logging in than computer science. But the kids, of course, all their dads work at Microsoft, so nobody's impressed by anything you do. One of the kids found out I worked on Pinball, and then they were like, “Whoa, you worked on Pinball?” Because they all knew that in those days. Now the kids have probably aged out, so they don't know it anymore, but they did for a brief period.
You're behind Windows activation.
David Plummer
You say it like it's a bad thing.
Everything's a matter of perspective. So tell the story of that. What's Windows activation? How did you get involved?
David Plummer
They came to me late in the XP shipping process. I don't think the beta had gone out yet, but they had intended to take the Office activation code, adapt it to Windows, and add activation to Windows. Whoever was responsible for doing it had slipped it enough times that it wasn't going to happen. I had a reputation for being able to fix things quickly, so they came to me and said, “Can you get this done in time for XP?” I said, “I don't know, but I'll try.”
With the help of the guys who were doing the DRM stuff on the DRM side and the research guys doing the math for the product keys and everything else, we cranked it out in time for XP. I don't know what its actual impact was on revenue, but I imagine it was substantial when you start enforcing license keys.
I wonder what it was.
I don't know.
Because it's also annoying.
It is, especially if you have to phone-activate. That was just the case that we had to carry with us as an albatross around our neck, where you've got to pass data up to the clearinghouse, the backend systems that are going to approve your key. You've got to tell it all your hardware parameters, like how much memory and hard drive space, and the various things the product key is bound to, as well as the product key. You've got it encoded in letters and numbers that somebody's willing to read in over a phone.
If you think doing product activation is painful over the phone, could you imagine being the person who worked on the other end of that line? That's got to be a mind-numbing job, listening to product keys for 8 hours a day.
One of the challenges with Windows, and it's been a frustration point for me, but I understand from a design perspective that it's very difficult, is that so many different kinds of people use Windows. But it's been frustrating how, over time, Windows has leaned more and more in the direction of—not the power user, I should say—which is why Linux has always been really wonderful. From an activation perspective, or from any kind of configuration, it's been a source of a lot of frustration.
One of my more popular episodes of late has been why you can't move the Windows taskbar. I had no idea, but the outrage is palpable among people who just want to put it on the left or top, and you can't anymore. It's an affront to their existence, and I understand it to a certain extent.
Yeah.
Well, it's one of the main reasons I really dislike Windows. There are a lot of aspects about Windows 11 I dislike, one of which is that you can't customize things as much, like the position of the taskbar. Can we just configure stuff? There's going to be a small contingent of power users who are just going to enjoy the hell out of this operating system if you give them that option. It costs you nothing. Just give them that freedom.
Well, it does cost, right? Because the freedom to put the Start menu on the left or the top or the right really increases the complexity of the code that renders the Start menu, lays out the tabs, and does all the things. Now it's a much larger surface for bugs and a much larger piece of code to maintain, so you probably need more developers, or another developer, or some portion of a developer's time.
The question becomes: At what point is it still worth it to satisfy the niche needs of a small set of users? Those decisions weren't mine to make, but I could see it from both sides.
I think, just like the people who make movies and insert very nuanced details that only a small number of people will realize are there, that's going to really pay off. There's a kind of reputation that builds over time that has a very powerful ripple effect. I think it has so many benefits, including for hiring great software engineers.
It's like you create this aura of a place that puts love into every detail, that really takes care of the power users, that takes care of the developers. I think Microsoft has moved more and more in that direction with GitHub, acquiring GitHub, and just taking care of the developers.
But on the Windows interface side, come on, some customization. With VS Code, you can customize everything. Why can't we customize the Start menu? All right, anyway, the taskbar, and really every aspect of the Windows interface. Maybe you're right. Maybe it increases the complexity of the code. I suspect that's just not the case.
I bet it was a scheduling decision when they rewrote the Start menu. I think they rewrote it because it's different from the old taskbar. Somebody was tasked with, “You've got to deliver this set of functionality, and if I cut out putting it on the left and the top and the right, 2 rows of tabs, and all the other cool features, I can deliver it 4 months sooner.”
I'm not saying that's the right decision, but I'm guessing that might be the kind of thing that motivates it. They're on such a different release schedule now. It used to be that you wouldn't see much craftsmanship unless somebody owned a component for a long time and it settled to a point where you could work on it and polish it, right?
But if it's always churning and the UI is changing every release, it's never going to get that level of polish. I think the UI is pretty nice, but—
Yeah, it is nice, but I just don't think it's a scheduling thing. I think it's a craftsmanship thing. Just like with the Task Manager, if there's a guy or a girl in there who takes ownership of it, who has a passion for it—for them, it's a thing that they take pride in over a period of time—they can, by themselves, in a short amount of time, create something truly wonderful.
Right.
And I think if you have large software engineering teams with managers and scheduling of meetings and all this kind of stuff, then your argument applies.
They've tried that at Google, yeah.
Yeah, like, have fun with it. Do some crazy stuff, and then we'll integrate it. We'll try to integrate it into the whole ecosystem.
To me, there's such a great joy for an individual developer to create something like customization of the Start menu or the taskbar, because you know that millions of people are going to use it. Then you know that thousands, tens of thousands of developers might use it to customize even little, subtle aspects of the taskbar.
You know how much joy you give to people when they have some kind of JSON thing where they can customize something about the taskbar?
Okay, but how do you respond to the Steve Jobs aspect of this? Giving you customization implies that we couldn't figure out the right answer for you. Or maybe there is no right answer, and all 4 answers are equally right. I have no idea.
Right. I'm glad Apple exists. It's a beautiful thing, and that idea of design is wonderful, but I always thought that Windows creates the contrast. The point of Windows is to be the operating system that works on all kinds of devices and, just as much, is supposed to be much more open.
They've moved more and more in that direction with Windows Subsystem for Linux. It's this whole developer-friendly ecosystem. The interface should be in the spirit of that, I think.
Right.
But I do think that there could also be security vulnerabilities created with that. It's not just the complexity of the code, because Windows is just under attack. It's very difficult to keep it secure.
Anyway, taking that tangent, you also developed ZIP file support for Windows, creating Visual ZIP, like I mentioned—ZIP folders that eventually evolved into ZIP folders. Tell the story of that.
That was a piece of software that I wrote at home again. What happened was, I was out with my wife—I think it was a Sunday afternoon—and we're driving around. This was 1993, and we were living in our apartment and just seeing what the housing market was like.
There was a guy who had this beautiful 3-bedroom house and a Torch Red ’93 Corvette convertible parked in the driveway. The house was for sale, and it was like $300,000, I think. There was no chance I was coming up with $300,000 at that point, or even the down payment on that.
So I took the flyer, cut the picture of the house out, and taped it to my monitor. That was my incentive to write something at night, because when I came home, I was doing 2 things. First, I was expressing a creativity that I couldn't get out at work when I was just fixing bugs, and I was trying to make some extra money.
And so I wrote a Shell extension. Before I actually went to the Shell team, I started it, and that's what led to my interest in going to the Shell team, based on an MSDN sample—or MSJ at the time, an MSJ sample—that I saw on how to bring up a folder. Once I had the very basic bring-up-a-folder template, adding ZIP file support to it was just incremental all the way.
I released it as a shareware product. I think it was $19.95 or $29.95, and I sold a couple hundred or a couple thousand copies. One day, I was getting ready for work and I got a call from a lady who said, “Are you Dave Plummer?”
I said, “Yeah.”
She said, “Are you the guy who wrote Visual ZIP?”
I said, “Yeah.”
And she said, “Well, this is Betsy from Microsoft, and we'd like you to come in and talk about an acquisition of it.”
I said, “Okay, what building are you in?”
And she's like, “What do you mean?”
I said, “Well, I'll come by.”
She said, “Well, no, you've got to talk to travel and legal, and this all has to be set up.”
And I'm like, “I don't get it. We both work at the same place. Why can't I just stop by?”
I don't know if I said that literally, but it was a few minutes of back and forth where we both realized that she didn't know I worked there.
Yeah, that's funny.
They had just cold-called the author and then found out that it was me.
Yeah. That's funny.
And so they made me an offer on it. It's the kind of thing where, if I don't accept the offer, my choices are: I can keep selling my own version and quit Microsoft, or I can stop selling my own version and work for Microsoft. Neither of those is great. I'd like to keep my job, of course, but I'd also like to still have this income stream.
The other option was to accept their offer, which is what I did. So then I bought a used '93 red Corvette and—
And you got to continue building it internally?
I did. We took a lot of features out to simplify it, because it had encryption and a number of features that were common in ZIP programs of the day but probably weren't appropriate for Windows. At the time, encryption was like a munition, so you couldn't just add encryption willy-nilly to various parts of the operating system. We took out some things like that. Multi-volume support, I think, was taken out just to simplify it.
Can you speak to ZIP in general—just the history of ZIP and compression, that whole thing?
Yeah, it was really borne out of the BBS era, when people were dialing in on modems to download trialware, shareware, and other things from BBSs and compress them. Executables compressed to about half their size. Other stuff compressed much more.
A guy named Phil Katz came up with a command-line program for MS-DOS called PKZIP, which could compress programs, and he has a rather tragic arc. But it became ubiquitous in the entire PC industry, and pretty much everybody was using it. So when Windows came out, there was no way to open up a ZIP file, but everybody had been creating them for a decade. That really drove the desire to have ZIP support right in Windows.
Yeah, and that's another piece of software that's just kind of with us to this day.
Mm-hmm. It could be vastly improved, but it was written in the single-core days, so it doesn't do anything multithreaded. You've got a 96-core 7995, and it uses 1 of them to unzip your file.
What other awesome things were you a part of at Microsoft? What other pieces of software?
I worked on the initial prototypes of Windows Media Center. We did that in '96, I believe. We didn't have any sources at the time, so we had a CD of MPEG video files of Raging Rudolph and, I think, the original South Park video, the Christmas one, which is all wildly inappropriate in the workplace today.
That was all the content we had until we had them put a satellite dish on the roof—DSS, whatever the 18-inch dish is—because we couldn't get cable to the building. We built up this thing that would eventually look a lot like Media Center, and it was a distance viewing UI for Windows, so you could sit with a remote control at a desktop. The current Start menu is not great at 20 feet away.
Tell me the story of the infamous blue screen of death.
It's what happens when Windows has no other option—when the kernel gets into a state where something illegal has happened. For example, a device driver might be trying to write to a piece of memory it doesn't own or trying to free a piece of memory twice, something that just cannot happen, and the kernel has no other option.
It will shut the machine down—not to save your work, but to prevent further damage—and it puts up a blue screen and prints out the stack information, depending on your settings. Sometimes it's just a sad face in the current version of Windows.
Yeah, I wonder what the first version of Windows was when the blue screen came to be.
Windows 3 had a blue screen, but it's completely unrelated to the blue screen in Windows NT. I talked to the guy who wrote the blue screen in Windows NT. His name's Jon Viert.
I'd always heard that the reason he picked white on blue was because, in the labs, you could walk through a lab where we had 50 PCs all running under stress. “Oh, that one's got a blue screen. It's crashed.” It wasn't that simple. It was just that the MIPS firmware he was building it on was blue on white, and Visual SlickEdit, which he was using as an editor, was also the same color scheme. So you could code, boot, crash, and reboot, all in the same color scheme.
Why do you think so many problems with computers can be solved by turning them off and turning them on again?
I think there are 2 major things that happen with computers as you run them over time. One is that memory gets used and not freed, so it accumulates on the heap or in the swap file or wherever, and things get sluggish.
The other is that code gets into a state that the developers didn't anticipate or test very well. Maybe that's a rare state, but now that Notepad, Word, or Excel is in that state, your system is goofy. So if you just reboot the thing, shut it down, or restart it, you're getting a fresh state and there are no memory leaks, so it covers a lot of sins.
And the intricate ways that several pieces of software in a goofy state interact with each other create a sort of meta-goofy state. The entire system starts acting a little weird, and then somehow that fixes it.
What's some of the best and worst code you've seen during that time at Microsoft? What's some beautiful code, and what's some ugly code that pops to mind?
In terms of beautiful code, 2 things stand out for me. One is the kernel in general. When you get down into the Windows kernel, in the actual NT APIs and stuff, it's very well written, and it's written to a standard that you don't see on the user side, or at least is uncommon on the user side.
On the user side, probably the coolest code I remember seeing was written by a guy named Bob Day, who wrote a named-pipe implementation to eliminate the use of shared memory. Windows 95 had a big shared segment among all the Shell processes where it would store stuff that was common to all the Shells. We didn't want to do that. Shared memory is a bad idea on NT and at an industrial level, so he came up with a way to do it with named pipes.
I remember doing a code review on it, and it was very impressive to walk through the code. It was one of those things where it was like, “Oh, I don't think I could have done that if I was trying.”
Who's the greatest programmer you've ever encountered?
You know what? I don't think there is any one. I've met a number of great programmers, but I'll tell you one story that impressed me a lot.
When I was brand new at the company, I'd been there for about 6 weeks, and I was working on this OLE Presentation Cache that I'd mentioned earlier. I was on Windows 95, and I had Excel inserted into Word. I was in the kernel debugger, and something was going wrong in the scheduler.
I'd barely written any x86 code, and I was looking at the Windows scheduler, trying to figure out why my thing was deadlocked. Eventually, I got stuck, so I was out of my element, and I sent an email to the Windows 95 kernel team saying, “Could you send somebody by?”
About 10 minutes later, this developer strolled in holding a null-modem cable to connect my 2 machines together so they could debug one with the other in case I didn't have it. But it was already set up.
They sat down and used WinDbg, which is a horrible debugger. It's accursed. But they were very competent with it, blasting through the call stacks, checking all these objects in the kernel, and trying to find out who's waiting on what, why things were deadlocked, what things were signaled, and what wasn't.
It was this quicksilver ballet of call stacks flying by, and I'm watching this, pretty blown away, because I'm a good programmer, but this person was an amazing debugger. I'd never seen a performance like this. About 5 minutes in, I just heard, “Oh, I see.” Then they disconnected, got up, and left.
That was Laura Butler, who became a distinguished engineer at Microsoft. I think she may still be. I'm not sure if she's retired or not, but she set my template for what Microsoft developers were like when they were debugging, what kernel developers were like, and even what female developers were like, because I had such a small sample set. But it was a very high standard.
There are few things I love in life more than people who are ultra-competent at anything, really. But the lower-level, the better, in the engineering space.
They're able to, for example, run or maintain the infrastructure—the computer infrastructure. So not the individual computer, but the computers communicating together and working together. Those people are just magicians. It's so inspiring. It's like watching a great carpenter or...
I love anything done really, really well.
Yeah, it's beautiful to see. It's beautiful to see that humans are able to accomplish that. Even in the civil engineering space, when I look at bridges, it's like the number of people who had to come together to build that, and now millions of people use it every single day. With software, sometimes you don't get to see visually just the number of people impacted by a thing.
Imagine how many people are impacted by Linux and all the different open-source systems that make up Linux. It's incredible. Task Manager is an example of a piece of software. Just how many people have used that over the years, and how many times? It's crazy. It's probably—are there billions? Billions have used that.
Yeah, 2 billion a month or something.
2 billion?
Something like that. I've seen the metrics, and it's up there.
Oh, crazy to you?
It is. What I love about it, though—and I'm sure you've had this experience—is that sometimes you design a piece of software, and it's complex, and you get it working in your head. You get the plumbing working, and you know how it's going to run and flow. Then eventually you write the code, and the code does that thing that you had pictured in your head.
Now there are billions of copies of that thing I had in my head running on millions or billions of people's machines, and that in itself is really cool to me. It's not a vanity thing so much as I'm impressed by it, I guess.
How has your programming evolved over the years?
I take a lot more care with complexity these days. It used to be that you would write code and just keep writing code, and then at some point go back and clean it up. Well, I write the other way now. I try to write really clean initial skeletal code and then flesh it out, because I have been involved in too many projects of my own and of other people's making where things get so messed up that they're just not fixable. Sometimes the work you put in up front pays off.
What programming languages have you used over the years? What's been your main go-to?
For me, it's been C++ and assembly language.
And still to this day, C++ is really what you lean on?
Yeah. Right now I'm 100% Lua and Python, but that's just a side project I'm working on.
Can you speak to the Lua and Python detour that you took, and what do you love about C++?
I wanted to build an AI to play the game Tempest. That's the old Atari game, Tempest. This is a game that I actually hold the world record for.
Can you take me to this Atari game, Tempest? Okay, Atari Tempest. What kind of game is this?
It's a 3D vector game from 1980. It's a very complex game. You've got full 360 degrees of motion, you have 8 shots on the screen, and there are about 11 enemies and spikes. It's a very complex game. It's not like trying to do Pong or something.
Okay.
What I wound up doing was first taking the ROMs out of the machine and reverse engineering the code. So I got a sense of where all the code in Tempest lives and what it does, where the zero-page variables are, where things live. And, yeah, there's one.
Oh, wow. That's very geometric. Can you explain to me the gameplay?
Yeah, that's me playing the game right there.
This is literally you playing?
This is me. Dave is the high score; you'll see it in the top center there.
Can you explain to me what I'm looking at?
Well, it's a 3D geometric world. It's basically 3D Space Invaders wrapped into a shape, and the enemies descend from the center of the tube toward the outside. They all have different behaviors.
Wow.
Long story short, it's a fairly complicated game to play well. I wanted to see if I could get an AI to do it. Once I had figured out where all the interesting parts of the game lived in memory, I added them as parameters and built a Lua app to extract everything from the game's memory as it's running. It puts them together as parameters, which it sends to the Python side over a socket, and then the Python side does reinforcement learning.
I'm using a dueling Deep Q-network, and I believe it's two with two heads and tails, and they chase each other. It can play up to about level 36 now, which is way better than most humans. But that's level 96, so it's got a ways to go yet.
And you're the red thing shooting?
Yes.
You're controlling the red thing that's shooting? Okay. What are the options? You can just move clockwise or counterclockwise, and then you can shoot?
Yeah, so you have a rotating knob, which is an optical spinner, and you have a fire button and a super zapper for emergencies. But that's it: fire and rotate, basically.
All right, let's get back to your favorite, C++. What do you love about C++? Why have you stayed with it for all these years?
Because it allows me to encapsulate my favorite C code in classes.
You're really a C guy.
Yeah, I'm really a C guy. Although I write two kinds of C++. I write really modern C++ 20 using no pointers, no string, or no character strings, so it's basically as safe as Rust, as far as I'm concerned. Or I write C with classes, which is standard C, but with polymorphism and encapsulation. That's most of what my code is. I try to do both.
Let me ask you about the whole stretch of time that we kind of skipped over. You built a lot of software over the years after Microsoft, on the side while at Microsoft and afterward—a lot of successful pieces of software. One of your companies was Software Online, and it got into trouble for nagging users too much, I guess, to upgrade. That's what I saw. What was all that about, and what did you learn from that experience?
Other than family health scares, when the kids are sick, that was the scariest time of my life. The period leading up to it was one of the most invigorating and exciting, because while I was at Microsoft, I had written all these shareware utilities and was selling them on the side. I sold one to Microsoft, as we talked about, and they started to do really well.
Then I discovered banner advertising online. I signed up with my credit card for a site—I think it was called FastClick—and you could say, “I will pay this much for a banner ad impression. Here's my banner,” and it would rotate it in. I didn't set a cap on it. I came back on Monday and saw I had spent about $10,000 on banner ads. I was like, “Holy crap. How am I going to explain this to my wife? This is a bug, it's a mistake, it was my fault.”
I looked at the sales, and it had made about $38,000 worth of sales. I was like, “Holy cow. So all I have to do is scale that at some point,” and I basically did that for the next several years.
The reason we got in trouble was the AG came in, and they had 12 causes of action, and 10 of them were outrageous, which, to me as a person with autism, I couldn't get past. I know these 10 things are absolutely not true. Why are we even here talking about them? Then all they care about are the 2 things that might be true.
The 2 things that might be true were that it was a 30-day trial version, and after your 30 days were up, if you continued to run it and not buy it or uninstall it, it would remind you once a day—not every 10 minutes, but once a day—or every time you booted your computer, but mostly once a day. The AG contended that was too often; it amounted to spam. So we agreed with them to limit it to once a week, I believe. There had to be a button to uninstall it with one click, so we did those kinds of things.
The other one was that in those days, when somebody bought a piece of software—even if they bought it online and got a download—they fully expected there would be media showing up at their house. In 2001, or 2001 to 2003, which is what we're talking about, if you bought software, there was an expectation that a disc would show up.
We made that the default: to fulfill by disc. It was $3.95 or $4.95 extra, and it was very obvious, but it was a checkbox, and it was turned on to ship the disc to your house. We found that if we didn't do that, we got all these calls. People would wait, they'd order, and 2 weeks later call: “Where's my disc?” We'd look and say, “Oh, you didn't order a disc.” They'd say, “Well, cancel it all. I don't want it because I'm not waiting for it.”
So we got a lot of returns when we didn't include the disc, and we decided to include it. But that is an a priori violation of negative-option billing in Washington State, because you're giving them a default higher purchase price.
What about the software-user relationship? It's interesting how often to annoy the user with a thing. If you never mention anything, they might never discover something they actually want. But if you mention it too much, then they can get annoyed.
Yeah. What you don't want is for them to have to do it or buy it, or do something to get rid of it.
That's one of the things that bothers me with Windows. I think it still does that a little bit to this day, where it bothers me by asking me certain questions, like, “Do you want this?” For example, I really don't like to use my Microsoft account to log into Windows.
Right.
I think now it's basically required. I think there's just no way around it. But they make it so difficult not to do that. It's almost like they think they can trick me into it. It really does feel like I'm getting tricked into not doing what I want to do.
Right.
I have to think, “Okay, I need to click Skip,” and then it’ll do something like, “Are you sure?” I have to use too much of my brain to do the thing I want to do. As an interface, you know what I’m trying to do. You’re trying to trick me into not doing the thing I want to do, and what I hate about that is that it’s probably effective for converting people, but it’s really not good long-term for taking care of the interests of the user.
Yeah, the one that really throws me is “Use recommended settings.” I just did a Windows upgrade, went through the steps, and I’m going through this new dialog or wizard. “Use recommended settings” sounds like the thing you should do, but I’m pretty sure that resets you to using the Edge browser and—
Right.
—and all this other stuff. So, recommended by them, but not recommended for me. That’s the difficulty.
That’s a really good example.
What effect do you think resetting the default browser to Edge has? Do you think you’re really going to earn the loyalty of a user if you do that? Don’t you think that there are actually—what you’re going to create is some passive loyalty from some user base? On the metrics, it might actually look like you’ve increased the number of Edge users, but really, it’s the reputation hit you take over time, where it just forms this feeling that Edge is the thing that you can’t quite trust.
Right.
Unfairly, because I think Edge is a really great browser, but there’s just this unpleasant feeling. I don’t know what that is.
Well, you don’t want your operating system to be an adversary, right? Sometimes Windows can feel adversarial. It doesn’t have your best interests at heart, and that bugs me to a certain extent.
I think we just have a general distrust when somebody is super nice to you and is basically selling something. There’s a certain aura about that kind of interaction. When an operating system is interacting with you in that way, it’s like—
Yeah, I would much rather pay $199 for Windows Pro per year, or $20 a month, or whatever the fee schedule would be, and not be upsold any further and not have my data monetized and those kinds of things.
Did you learn about finding the right balance from that?
Yeah, I’m way more self-aware now. There are things I would do much differently, particularly in terms of the advertising. I always figured—there’s a guy named David Ogilvy, and he did this ad long ago for the Volkswagen Beetle. It had a picture of a Beetle, black and white, and it just said, “Lemon,” with a block of text below it. So it was clickbaity and then informational, and I always tried to follow that pattern.
But there are 3 ways to sell something, I think, and you can use sex, fear, or greed. Sex doesn’t work really well for software. Fear works well for antivirus and stuff, but not so much for optimization and making your computer faster utilities. So I always tried to cater to the greed aspect: make your computer faster, get more RAM available, whatever the value proposition is.
But I realize now that I’m looking at that with my knowledge, and as an autistic person, I now have an appreciation that other people are going to look at it with their background knowledge and may conclude something different. So I might be scaring people where I was just trying to incentivize them or get their greed instinct going. I’d be more sensitive about that kind of thing today.
Ridiculous question, but what do you think are the top 3 Windows operating systems, the different versions?
I’m a fan of Windows 2000 Server.
Wait, what? Really?
Yeah.
Okay, wait, please.
That’s what I ran my business on, and I ran my brother’s business on it. We set up multiple salons, all VPNed to one another and using SQL Server.
I don’t know if I ever got to experience Windows 2000 Server. When was XP out?
2001.
What was before XP?
2000.
2000. Was that good?
Yeah, I liked it. It doesn’t have the visual flash that came with XP, but as a system, and especially as a server operating system, it was great for the day.
But then XP was, from a completeness perspective, impact, and how long it lasted, probably the greatest Windows operating system for consumers.
I would think so. It’s certainly got the longevity. There are people who still run it. I’d still run it on stuff if you could get security updates, because it does 98% of what I need Windows to do.
Yeah, that was incredible. So Windows 95—I’ll probably put Windows XP as number 1 for me, and Windows 95 at number 2.
What’s your metric? Personal preference, industry impact, or—
Industry impact, stability, and just certain things. Like with programming, you have code smell. It’s how well all the features were orchestrated together, how there’s a design philosophy that permeated the whole thing and was consistent. Not too many features, not dumbed down too much, but not overcomplicated. How often it crashes to a blue screen. All of those things.
I don’t know if it’s a very apt description, but I think of it as crisp. There aren’t a lot of rough edges. It does what it does, does it snappily, and—
Yeah. You said you play slot machines, and given that you love hardware and software, you’re the perfect person to ask: How do slot machines work?
Well, I’m happy to ruin them for you.
Okay.
It’s ironic to me that I play slot machines, because I know it’s a losing bet overall, but there’s a whole dopamine feast there of bright lights and high-contrast colors that I enjoy. So I do play them.
What happens is, internally, there’s basically a black-box mechanism that does nothing more than generate the next random number and determine what the outcome is in terms of probability and payout. Then the game says, “I’ve got to make up a movie to go along with that.” Maybe it’s 3 bars or whatever it is, but there’s no correlation. It’s not spinning the reels, seeing where they land, and looking that up to see what you won. It’s completely the other direction. It determines whether or not you won and then makes something up to fit that scenario.
That indeed is ruining it for everyone.
A little bit.
What kind of code runs them?
I don’t really know. I tried to get down and get inside access to one, and it was very hard. They don’t want to tell you a lot about them. It’s that deep of a secret.
Yeah.
They’re all basic Windows PCs, but they’re basic Windows PCs on top of a very secure enclave of some kind that I don’t know a lot about.
Yeah, it has to be extremely secure, right?
Yeah. In the ’70s or ’80s, there was a tech in Vegas who went around burning his own ROMs for the slot machines, with a backdoor in them. When he serviced the machine, he would just put his ROM in.
Nice.
He’d come back 6 months later and—
Nice.
—invoke the backdoor.
I love humans so much. Anyway, do you have other favorite kinds of systems like that?
I like a lot of old hardware. I restore cars, so I do a lot of 1960s muscle cars, cars, and trucks. And old computers. I restore PDP-11s. It’s been my fascination and my special interest for the last 6 months or so, and I’ve built a number of those.
Yeah, I’ve seen you posting videos about it, the PDP-11/83. What’s that whole project?
Basically, I had built a number of PDP-11s, and over the years I had acquired all these parts. I decided, “Well, let me build the best PDP-11 that I can.” It was kind of a quest to, just like you try to max out a PC, max out a PDP-11. So it’s got 4 megabytes of memory, which would have been massive in the day. And yeah, that’s it there. It’s got lots of blinking lights, and I had to rewrite the BSD kernel to make the lights work.
What are we looking at here? What’s—
The very top is a PDP-11/70 control panel, which we can largely ignore. Then there are 2 chassis below that. One has—
What are the different knobs? Sorry to ask dumb questions here.
The knobs control what view you get of the LEDs. Normally, you see the data bus, and you can see the address bus. You can pause the machine, edit the address on the bus, and deposit stuff into memory with the switches.
Man, the haptics plus the LEDs—that’s what you imagine a computer to be.
Yeah.
That’s so cool. And then these are what? What are these? These are DU1, DU2?
Yeah. It’s a weird floppy drive. It’s a dual-floppy drive with 1 stepper motor, so both heads seek together like Siamese twins.
Okay. What kind of stuff are you doing with this? Are you trying to restore them?
Yeah, I restore them.
Does it actually run?
Yeah.
Oh, all the blinking lights are real?
Yeah, it’s all real.
Wow.
Then I had to rebuild the kernel and all that, so I had to learn the BSD kernel. I’m pretty familiar with it now. You can’t just add a device driver, right? You’ve got to rebuild the kernel to add support for whatever device. So you add a new disk controller, and it’s time to build the kernel. You’ve got to go find the source, find the code, and—
And you can run code on this?
Yeah.
You’ve written a couple of books on autism. Being autistic yourself, I was wondering if you could tell me about fundamental differences between the mind of a person with autism and, let’s say, a neurotypical individual.
Well, the fundamental theory of thought for autism is called monotropism. Basically, what that means is that my brain does 1 thing and does it very intensely, and then, when it’s done, I can move on and do something else. But I’m not a multitasker. I’m a serial single-tasker by any stretch.
Autism usually brings with it sensory sensitivities and repetitive behaviors—behavioral issues that compound it.
And if they rise to the level where an individual can't moderate or accommodate them in their life, it becomes a disorder. That's probably 1–2% of the population.
What's the biggest benefit of life with autism?
I can bring to bear an incredible amount of focus and dedication on a particular task. It has to be something I love, something that's rewarding, something I can make progress on, and all these things have to be true about it. It could be like a kid playing with trains. I get that same feeling.
That said, you also said that you struggle with ADHD.
Yeah, a fair bit.
So that's part of the component, maintaining the focus?
Or actually, acquiring the focus is the issue. I'm very easily distracted. I fall asleep with noise-canceling headphones, or I can't fall asleep—that kind of thing. But once I get locked in, I'm very hard to distract. So it's kind of a paradox.
Oh, that's fascinating.
It's hard to get into that state.
What's the biggest challenge of life with an autistic mind?
I don't know what anybody else is thinking. I know what I would think about this interaction if I was in your position and I was you, and that's the best I can do. But I think most neurotypical people have a sense of, "Well, Lex probably feels this way or that way because he's acting this way, and his reactions are this, and his facial expressions say this." That's all kind of lost on me. So I run a little proxy NPC game for everybody I deal with.
So I guess that makes social interaction a little bit complicated.
It can be, yeah. Telephone is especially hard because I rely on a lot of other cues. When somebody is just on the phone and I just have their voice, there's so much that's implied between people that I miss. I'm much better on FaceTime, where if somebody makes a joke, they might smile after that. On the phone, I don't know if you're being sarcastic or serious.
So that's probably gotten you into trouble over the years a bit.
Yeah. There's a certain literalism that comes with autism. We spent years where she would say something, and I'd say, "But that doesn't make sense." She'll say, "You know what I mean." I'm like, "No, I know what you said, and I'm not being just combative here. I literally only know what you said, and I don't have that."
I remember we've been in meetings with people and, if there are 3 or 4 people in the meeting and I'm the only autistic person, I'll tell that they've got this communication loop going on. I have to say, "You have to tell me what's going on, because I really don't know what's being said here."
You told me, related to this, that there was an early, somewhat awkward encounter with Bill Gates. Can you share this story of that interaction and how autism comes into play here?
My very first summer at Microsoft, when I got the internship, Bill had all the interns over. I guess it was 20 or maybe 25 of us who got hired that year, over to his house for burgers and beers and just chatting in the backyard. Of course, it was still Bill Gates, and he was a big enough deal even then that you were a little nervous.
My manager, Ben, who was sort of my mentor at the time, took me over to introduce me to Bill because he knew him. He was explaining, "This is Dave. He's our intern from Canada. In the space of 4 months, he's done this feature and COPY and SmartDrive," and he listed off all the stuff I was doing.
But I stopped because I was like, "Well, actually, it was 3 months." I had to interrupt them, and they both kind of said, "What?" They looked at each other, and I realized that was the wrong time to correct a guy.
For you, little inaccuracies?
Oh, they drive me crazy.
And then, of course, you're not aware of the impact that might have on a casual social interaction. It's not trivial for you to be aware of that.
Yeah. I'm much better than I used to be. Before, I didn't know how injecting a correction meaninglessly into a conversation could impact or make the other person feel. Now I have a better sense of it.
What advice would you have for folks who have an autistic mind on how to flourish in this world?
In terms of prosperity and finances, the biggest thing I can say is: sell what you can do, and not yourself. If you go into a job interview and try to wow them with your personality and how amazing you are, it may or may not go well. But if you go in with your portfolio of work and say, "Look, here's my GitHub history, and here are the awesome projects I contributed to. Here's the actual algorithm I wrote, and this is what I do," I think you get a lot further with that, whether you're playing the piano or writing code.
That said, so much of software engineering on large teams has a social component to it, right?
It does, and that was a liability for me.
What have you learned about how to solve that little puzzle?
I think the biggest deficit for me was when I started to manage people, because now you're concerned about their hopes, dreams, aspirations, what motivates them. They have entire lives that are kind of a mystery to me, because I assume they want to be motivated, led, encouraged, and compensated exactly as I would. That's not always the case.
Some people need a lot more affirmation. Some people just want money. Some people want to be in the important meetings and make decisions. But I was largely oblivious to that. Eventually, I had to learn that everybody you're managing has their own set of incentives and priorities, and they're completely different from what I think they probably are.
So you could, I guess, make things more explicit and communicate better. Ask them about what their interests are.
Yeah. That's something I started doing: overtly asking. It's hard for me to nudge somebody there. I'm not good with that kind of social dance.
Part of the social dance is that there's a lot of stuff that's unsaid. You can kind of figure out what's going on. You can read people. If that's difficult with autism, then you have to make things more explicit. Plus, sarcasm, satire, and humor might be difficult.
I would love to be a fly on the wall in some of your earlier interactions with Microsoft. Some of the greatest engineers have a mind like this.
Yeah, I've had laptops thrown at me and stuff, and I'm sure it was my own fault.
You write about the 10-second autism test. Could you explain how this works?
There is, of course, a high error rate with anything that has 2 answers. What's more important to society as a whole from people: cooperation or creativity? If you had to pick one, which is the most important? Most neurotypical people will generally lean toward cooperation, whereas people on the spectrum tend to lean toward creativity as individual problem-solvers.
Of course, there's some kind of error rate there.
If you want to double your precision, you can use a second test. You ask, "There's a room with 10 chairs, and 6 people come in and sit down in those chairs. How many chairs are left?" Some people are going to say 4, but I'm going to say 10, because that's how many chairs are still there. Literally true. I'm not being a dick. I'm not trying to be complicated, but that is how my mind works. When I see that question, it's like it depends on how you answer it.
So you're saying it's about how literally you take things?
Yeah, everything is very literal for me. I remember as a kid, my grandfather was building a planter holder in the kitchen for my mom. He was using these big angle brackets that I thought were a little overkill, and I said, "Do you think that'll be big enough to hold the plant?" He said, "It'll be big enough to hold a horse."
I was only 5, but I was very confused about why you would bring a horse into your kitchen, why you would put a horse up on a planter, and all of these things that didn't make any sense to me when obviously it was a figure of speech. For a lot of my life, I took figures of speech literally.
You've mentioned emotional post-processing as a strategy you use to replace social interactions, so you can sort of reverse-engineer them to help you understand the neurotypical world. I think this is going to be useful to a lot of people. What does that entail? How does that help you?
If I meet somebody, particularly somebody new, and it's my first couple of interactions with them—even meeting you today—then I will go home later and replay all of the moments where I had choices to make. Probably the most uncomfortable ones first, to find out: What did I do wrong in that moment? What did I miss? What was the other person thinking? How can I improve that kind of situation next time? Do I need to go fix it or make a phone call, that kind of thing, in an extreme case?
That's happened a couple of times in my life. I had a car restored that my dad had bought new in 1969. I still have it, so we've had it for 50 years. About 20 years ago, I had it restored, and it was a 3-year process of craftsmen working on this car for thousands of hours.
I go out to pick it up and inspect the car, and I'm very impressed with the work. I'm saying, "Oh, this is nice, and this is great," and everything else. Then I fly home, write the check, and the car gets delivered.
About 10 years later, I realized that I had a whole bunch of craftsmen who had worked on my car for 3 years, and I probably should have blown some smoke up their butts about what a great job they did. But I never did that because it's not what I wanted or needed in that moment, and I was completely oblivious to it.
So I sent an email to the manager or the owner of the place, and I said, “I don't know if you remember this, but 10 years ago, I picked up my car and I probably looked unimpressed. But I want you to know that I was very impressed with everything—the quality and everything else.” And he wrote back. He's like, “I've thought of that moment often.” So I'm like, “Now I'm glad I brought it up.”
Yeah, there are subtle things about human interaction that mean a lot to people. If you ask them straight up, they might not be able to articulate that, but it means a lot. When something is off, it bothers them.
Right.
But to reverse-engineer that, to figure that out for a person who might not sense those little subtleties of human interaction, is tough.
That's a good point to jump in there, too, on empathy, because there is some perception in the community that people with autism lack empathy, and I don't think that's the case at all. I can only speak for myself. I feel fairly empathetic, but I think the problem is a communication one, and it works in both directions. I don't know how you're feeling, so it's hard for me to be empathetic until you communicate to me what it is you're experiencing.
Once I have an understanding of what's going on in your head, I can feel incredibly sorry for you. But until then, I'm going to assume you're going to handle it just like I would in your position, in my case, with what I know now.
What advice would you give to people on the other side about how they can help you be a better friend, better partner, or better colleague? How should they communicate with you to help give more information?
Yeah, be really specific. Don't assume I'm going to pick up on clues, nuance, or subtlety. If you're trying to nudge me into a particular behavior, you're much better off saying, “Dave, this is what you need to do.”
Have I failed in any way today?
No, not yet.
All right. What score would you give me out of 1 to 10? Am I a 6? A 7? On the communication? 7.5? Floating-point. Nice.
Masking. You've got to tell me what that is. It's a significant experience for many on the spectrum. What is masking, and tell me about any of the experiences you've had with masking?
Masking is—and it's probably not the right way to describe it—the act of acting normal. How do I conduct myself in a social situation in a way that other neurotypical people are going to receive and accept the right way?
Everything you do in a social interaction, from waving my hands to making facial expressions, to tone of voice, to posture, is a huge contrivance, and it's work. It comes naturally to most people; it's just what they do, and cool people do it really well. But for somebody on the spectrum, you've got to fake it all.
Yeah, acting normal.
There's a song by Rush—you know the band?
Yes.
“Limelight.” It's written by Neil Peart. I only speculate about people who have passed on, so I've got a sense he was probably on the spectrum. But the line is something like:
“All the world's indeed a stage
And we are merely players
Performers and portrayers
Each another's audience.”
He talks at length in the song about not being able to treat strangers as friends and being able to fake an affect and all that. So it seems like he's struggling with masking a lot in the song. I have no idea, but that's what I took from it.
You described meltdowns as an overwhelming experience. Can you describe meltdowns? What typically triggers a meltdown?
Generally, it's when you're emotionally overwhelmed to the point that you can't manage your behavior anymore. You see it in the movie Rain Man when he's trying to get on the airplane, and he's kind of forced, and he starts losing it. That's a meltdown.
Probably the best portrayal I've seen in media is, what's the TV show where the doctor is autistic? There's a TV show where a doctor is autistic and he's a surgeon, and he is eventually banned from surgery because of his autism. He's always wanted to be a surgeon, and he has a complete meltdown. It's a pretty good portrayal on television.
What is actually happening? There's a threshold you cross where it's just like—
Yeah, the switch flips.
It's like a blue screen, essentially, for the brain algorithm?
Yeah, kind of. The switch flips. You go into a primitive brain. Your frontal cortex shuts down to an extent, I think, so you don't have the benefit of decision-making and filtering. You're in a very reptilian-brain state.
It's really a panic state—a panic and fight-or-flight response to not being able to tolerate the current reality. Perhaps it's been so frustrating, or you've been so randomized, or you've had a bad travel day or an argument at work or whatever. It's added up to the point that something has now triggered you, and your brain loses its ability to adequately moderate your behavior.
What about love and relationships? What are some of the challenges of that? You know, there's a show, Love on the Spectrum.
I've heard of it. I've not seen it, but I've heard of it.
Because certain aspects, like literal interpretation of things, make the complexity of romantic relationships even more explicit in that context.
I've been married 31 years and together for 37, so there's a long history there. I think our first indication that we knew we were very different was when we were sitting in the car one night out front of the house, in the dark.
Across the street, there's a nice house, and it has these big brick pillars that are linked by anchor chains, forming a fence around the yard. I'm looking at these things because they're about 2 feet square and they've got capstones, and I'm like, “I wonder if they're hollow or backfilled? Are they filled with concrete, or what?”
My now-wife looks at me and she's like, “What's wrong with you? Why do you have a place in your head that cares about that kind of thing?”
Yeah, that's great. Very specific, seemingly irrelevant details.
I was never good with people. I don't get it when people like me, I guess. My son is the same way because he doesn't fall very far from the tree, and I got him a T-shirt that says, “If you're hitting on me, please let me know and be specific because I'm clueless.”
It's very similar for me. I had to be around for a long time and grow on people because I had no game, because I had no ability to do the social dances that the whole thing requires. My only option was to be myself, and that works for some people.
Were you able to say, “I love you,” that kind of stuff?
Yeah. Her family was way more open with that kind of thing than mine was.
Yeah.
It was a growing period for me. But yeah, that's not a problem I have.
Okay. All right. But it seems unimportant. What is that actually accomplishing?
Well, now we do a lot of affirmation and checking. In the last couple of years, we've done a thing where she'll just be like, “You good?” I'm like, “Yeah.”
There are 2 steps to that. There's the “Are you good?” and then there's my response. Because if I'm like, “Yeah”... she knows something's up.
Yeah. So—
There's always this pinging back and forth because there's not the ability to read people just from looking at them to know what's going on. We have this explicit check mechanism that we developed.
So there's a vast chasm between “yeah” and “neh.” Again, that subtlety of human communication. You've written about the experience that people have of feeling “a little bit autistic.” Could you elaborate on this concept?
Yeah, I think a lot of people—maybe 10% to 20% of the population—are somewhere on the autism spectrum but aren't impacted by it enough that it rises to the level of a disorder. They still have many of the characteristics that arise from autism.
I think if they can understand, identify, and manage some of those behaviors in an optimal way, they can both leverage and take advantage of some of the skills and mediate some of the deficits and problems that come with it. I wrote it mostly for my kids because none of them, as far as I know, have ASD, but they've all got certain aspects of my behavior that are particularly related to it. So I thought I'd write a little manual for them, basically.
Why do you think so many programmers—excellent, great programmers and great engineers—are on the spectrum?
I think it's that single-minded focus and the ability to reduce a problem, and to be ultimately curious about what's inside stuff. That's been an obsession for me my whole life: what's inside. I've got to take my mom's oven apart because I've got to know how the flip clock works. I think that's a good habit to have if you're going to be a programmer.
And being willing, being excited to get into the details. What's a cool thing you hope to program or build this year? What are you working on? We've got the RL learning how to play Tempest. Where are you on that, by the way? What's the ETA on success and dominance—victory?
Well, it's very close to working. I think now it's tweaking the model size and layers and stuff like that to get it to learn past the 1 threshold. It's a couple thousand lines of Lua and a couple thousand lines of Python, and they all interact and they all work. It's like 95% of the work is done now. It's tuning hyperparameters and hoping for the best.
So it's already a success in a sense, but now you're seeing how far this can go?
Yeah, my goal was for it to be able to beat me.
That's a tough goal.
It is, but lots of games now play better than humans, but maybe not games this complex.
What other cool things are you working on? What do you hope to build this year?
The PDP-11 stuff. I'm trying to get what's called an RA82 drive. It's the big 14-inch monster that spins at 3,600 RPM and sounds like a washing machine. Then I'll find the controller card, write the code, integrate it into the driver, and try to get that all working.
What kind of code are you trying to run on it?
I'm going to have to get the driver stack to work, so I have to incorporate the driver for it into the kernel.
You built a machine recently with 1 terabyte of RAM. How did that happen, and why?
We have a project called GitHub Primes. If you just search for GitHub Primes, you'll find it.
GitHub Primes.
It's a single set of prime-number algorithms implemented in about 100 different languages. It's the exact same algorithm, and we require that you follow certain rules to make it fair. Then you express that algorithm in whatever language you choose, to the best of your ability, and we run a benchmark every night, compile the results, and find out which languages are fastest.
Is this the one? And this is what you're using this for? So this machine runs those tests? Okay, you've got to tell me about this project. This is an epic project. You're comparing the performance of the different programming languages.
All these languages get built into individual Docker containers, and then they all run.
This is an incredible project. This is really, really cool. It's really measuring the performance of the different languages. What have you learned about which languages usually win?
Zig, I think, right now.
Zig.
It varies. People will make an improvement to C++, then it'll pass for a while, and then the Zig guys will get angry and come back and make it faster.
So Zig, Rust, C++, and C? What kind of code is being run? What's the piece of code that they're trying to run to measure performance?
They're solving the primes up to 100 million as many times per second as they can in a 5-second loop.
So it's a loop, over and over and over again.
Yeah, on all cores.
Across all CPUs.
What about how the program is written? Does that vary?
No. You can do anything you want, but it has to be a prime sieve. You're allowed to use 1 bit per integer at most, so you can't use a byte, which is cheaper and easier. There are a number of rules like that. You have to allocate the memory within your timed loop.
We have a set of rules and some solutions that don't follow them, like the 6502, because you've only got 64K and you can't do a 100-million sieve. There are a lot of solutions like that that we run as exhibition projects, but among the main languages, they all follow the same rules. It should just be how the algorithm is expressed in that language.
Many of them use the same backend compiler, so it really is how you're expressing it and the limitations or benefits of that language.
Are multiple submissions allowed per language?
Yeah. If you look in the C section, there's probably 5, I think.
Some of them might use different compilers, or no?
Yeah, some are GCC, and some are Clang or LLVM.
I'm looking at a snapshot here from a couple of years ago. Zig was at the top, then Rust, then Nim, and Haskell. Oh, no, this is not ordered by slowness—or is it?
Yep. So C would be 1.5 times as long as Zig.
Wow. Okay. Fascinating. It's a super cool project.
We've got crazy languages like PowerShell. There's a version in PowerShell and stuff like that.
This is automated in terms of how the submissions are organized? There's a structure to it?
Yeah. There are 2 guys over in Europe, Rucker and Tudor, who basically own this now. I started with just 3 languages: Python, C#, and C++. I checked them in and published the episode. Then people started throwing more solutions in there, and it just got out of hand. I had to get somebody to manage it, and they've been great at doing that.
What's the happiest moment for you when you're programming and building something? What do you enjoy most?
I think the most fun for me is when I build something complex, I've thought through how it should work, and then I run it and it does work that way. That creates intense satisfaction.
Seeing the results come out the way that I planned them and having it work is really satisfying, because it rarely does the first time.
Yeah, or especially if it does work the first time.
I never trust that. I always feel like I'm missing something.
That's true. With compiled languages, like C++, it's always a good feeling. You write a bunch of code and compile it all, and it compiles without warnings or errors. It's a cool feeling.
What do you think is the future of programming? I don't know how much you've experienced the impact of LLMs with code generation. Have you used Cursor much—Cursor with VS Code and code generation?
Yeah, I've done a ton of it for the Python side, because I'm not great with Python and I'm kind of new to it. I've found it very helpful because I've learned a lot from watching the code that it generates when I don't know how to do something.
If I were to write Python from scratch, it would be about 4 times as long as what the AI can crank out, because Python can be pretty terse if you're good at it.
Oh, that's cool. So you essentially learned Python for this project?
Yeah.
This is a good case study of a great programmer in C++ quickly learning a language.
Yeah, I'm vibe coding my way through it, I guess.
Vibe coding your way through it. That's a really powerful use case: learning a language if you're already a good programmer, or learning a new way to approach a problem by having AI generate it. You probably understand the Python code it generates without actually looking up any of the syntax.
Yeah, it's all pretty self-explanatory once you see it, but creating it from whole cloth is a little different.
You still have to learn how to program in order to use it in that way.
You have to learn how to read it, know what to tell it to do next, and all that. I don't think you can vibe-code your way through it if you're just getting started and haven't coded. But if you're a good programmer, AI can make you incredibly powerful.
What do you think is the future of programming—5, 10, or 20 years from now? Vibe coding is kind of a fun meme right now, because you still have to be a programmer. The people who don't know how to program and are just vibe coding are almost entirely creating systems that aren't usable in production. It's very difficult to create a product.
The people who are already great programmers kind of vibe code in the way that you're doing it. It's basically just fancy autocomplete. They end up editing the code, or it's a way to learn a new API, a new language, a new specific use case, or maybe a different kind of GUI component.
But as AI gets smarter and smarter, we don't know where the ceiling is. That might change the nature of what it means to be a programmer. Do you think about that?
I do. I don't want to say "prompt engineer," but I think it's going to be something like that. If you're an architect building a bridge, at some point, people were down there welding beams together. Now you're dragging things around in AutoCAD and assembling them from big, preformed sections.
I assume that's what programming will be like. You won't be in there throwing individual lines of code around. You'll be moving components and interfaces, describing to the AI what those interactions should be, and letting it build the components.
But I think we're still quite a ways from it being able to generate something completely from scratch. You can't say, "Give me a Linux kernel that's compatible with Linux." One day we'll be able to, and it'll crank it out, but we're not there yet.
Does it make you sad that we're climbing the layers of abstraction so quickly? You came up working with machine code, then assembly, then C and C++. Now we're getting to a point where we're vibe coding with natural language.
Yeah, I kind of came up at a really fortunate time, I think, because I got to experience the technology develop over the course of 30 or 40 years. I understand TTL logic, I can use AI to write code, and I know all the pieces in between.
There certainly are holes in my knowledge, but I think the only way to have gotten that level of knowledge, or that completeness of the picture, is to have lived it for that long. It's going to be hard to duplicate that for people starting now.
What do you think is the meaning of this whole thing? Of existence, of life—whatever is going on here?
Making cool stuff.
Fundamentally, what I care about is being able to make complex things that are useful to other people. That leverages my abilities in a way that allows me to be creative and create things that other people can use. If I were limited to painting or sculpting or whatever in the classical arts, I would be hopeless.
For me, that's really the meaning of life. Then maybe you raise a couple of good kids to hand the baton off to.
You've created a lot of cool stuff over your life that has impacted millions, probably billions, of people. Now you're inspiring people by creating cool stuff for everyone to see on your YouTube channel.
So for everything you've done in the past and everything you're doing now, I'm a big fan. I'm really grateful for what you're doing and grateful that we got a chance to talk today. Thank you, brother.
Thank you.
Thanks for listening to this conversation with Dave Plummer. To support this podcast, please check out our sponsors in the description and now, let me leave with some words from Bjarne Stroustrup, creator of C++, and somebody who, by the way, I interviewed a long, long time ago, Episode 48 of the podcast. He said, "There are only two kinds of languages. The ones people complain about and the ones nobody uses." Thank you for listening and hope to see you next time.
Thank you.