第 479 期·中文精讀

戴夫·普拉默:程式設計、自閉症與老微軟往事

Dave Plummer: Programming, Autism, and Old-School Microsoft Stories

前微軟工程師回憶開發工作管理員與 Windows 的年代,也談程式設計這門手藝與自閉症帶來的視角。

官方音訊00:00 / --:--
中文精讀由 AI 基於原始訪談改寫,非官方翻譯,可能存在偏差或錯誤;表述以原音訊與官方文稿為準。說明

Windows 工作管理員每個月被大約 20 億人開啟。它的第一版是 87KB。

戴夫·普拉默(Dave Plummer)寫它的時候,是在自己家裡寫的。那時候他剛進微軟不久,白天在 Shell 團隊改 bug,晚上回家開啟編輯器,從登錄檔的 HKey Performance 裡讀效能計數器,因為他沒有內部 API 的許可權,而他又不願意在家裡呼叫內部介面。

後來這個程式被收編進 Windows NT 4.0,成了幾代人的肌肉記憶:電腦卡了,Ctrl+Shift+Esc,看看誰在吃 CPU,把它殺掉。這個動作太自然了,自然到沒人會想它是誰寫的。

他想給那臺機器下英文命令

1979 年,十一歲的普拉默騎著腳踏車去當地的 RadioShack。櫃檯邊堆著一摞箱子,標籤上寫著“computer”。店員說剛進貨,還沒裝。他說那我幫你們裝。

“我完全不知道自己在幹什麼。它不比一臺組合音響複雜。問題在於 Tandy 公司用同一種五針 DIN 介面做電源、影片和磁帶機,插錯了就炸。”(戴夫·普拉默)

他照著標籤接好線,機器亮了。接下來他做了一件很有代表性的事:往 BASIC 直譯器裡敲英文句子。PRINT 2+2 能用,別的就不行了。他不理解為什麼更“正常”的英文反而不行。

那臺機器是 TRS-80 Model 1,Level 1,4K 記憶體。同一個時期,Commodore PET 2001 和 Apple II 相繼問世。普拉默今天把“史上最偉大的電腦”這一票投給 Commodore 64,理由是銷量,跟設計無關。他的判斷標準很樸素:一臺機器影響了多少人。

他用十六進位制手寫了一個 Galaga

他的第一臺 Commodore 64 是被他燒壞的,準確說是軟碟機。機器不是從大零售商買的,沒有保修,得寄回德國修。於是他只剩一臺磁帶機,和一個從磁帶載入的機器碼監視器。那個監視器帶反彙編功能,但沒有彙編器。

所以他直接在十六進位制裡敲 6502 指令碼。

他做的第一個東西是 Galaga 的克隆。敵人會隨時間推進,邏輯完整,純手工機器碼。6502 的程式碼沒法重定位,想往中間插一段,只能跳到別處執行完再跳回來,程式碼結構慘不忍睹。但它跑起來了。

然後他做備份。

他把空白盤複製到了資料盤上。幾周的工作,一張盤,一個方向搞反的操作,沒了。

“我當時有很強的負罪感。你毀掉了幾周的工作,而且你知道這是因為你著急了,或者做了個蠢決定。”(戴夫·普拉默)

這是他的第一次資料管理課。他今天還記得那種感覺,說明這堂課上得夠狠。

輟學是一個過程,由一百個小決定累積而成

他高中輟學了。他自己強調,輟學沒有“那一刻”。

“沒有哪一刻你決定輟學。你只是去得越來越少,少到有一天你意識到,現在出現會很尷尬,因為我已經很久沒去了。然後很快你就徹底不去了。”(戴夫·普拉默)

他說的這個機制值得每個人警惕。你每天做的是一個小決定:“今天不去上課。”但這個決定重複足夠多次,就變成了一個大決定,而這個大決定你從來沒在清醒的時候做過。

然後他在 7-Eleven 上夜班,也在油漆倉庫幹過。7-Eleven 的夜班要做賬、做行政,店長傾向於安排腦子夠用的人,但這個人得有個人理由必須留在 7-Eleven。他沒有高中畢業證,正好符合。

他形容那份工作裡最難受的部分是量油,被持刀搶劫反倒排不上號。

一根十五到二十英尺長的木杆,刻度是英寸和英尺,沒有電子感測器,你得把它捅進地下油罐再拔出來,看油麵停在哪個刻度。第一次他滑手了,重新抓了一把,零下四十度,一手木刺。

“我意識到我不想一輩子幹這個。然後我想到‘下次我要換個方式拿’,三秒之後我又意識到這想法多荒唐。”(戴夫·普拉默)

二十一歲,他去找本地高中的校長,問能不能回來。校長說不行,你年齡超了,也沒位置。他說,從現在到開學之間,總會有人輟學,位置就有了,那我們假設位置有了,我能回來嗎。校長讓他回來了。他補了三到四門課。

進了大學,第一學期他仍然沒當回事。幾何 90 是給沒修過十二年級幾何的人開的補修課,他以 1% 的差距被教授放行。因為補修課成績不計入成績單,他等於白撿了一個新起點。第二個學期開始,他為自己學,結果完全不同。

他翻遍註冊卡,找微軟的郵箱

大三暑假,他在電話公司做 UNet 到 TCP/IP 的遷移。聽起來宏大,實際工作是換卡,然後搞清楚為什麼客戶的 config.sys 改完之後 Lotus 跑不起來了,因為可用記憶體少了 10K。他形容那是做計算機工作最糟糕的年代。

午休時他在美食廣場讀一本講微軟怎麼誕生的書。他讀得入迷,覺得那就是他想去的地方。但他在薩斯喀徹溫省,能做什麼?

他大學是靠一款叫 HyperCache 的軟體讀完的。那是 Amiga 平臺的檔案系統快取,機器出廠不帶,他自己寫,用 C 加 68000 彙編,賣了兩千多份,單價二十到四十美元。那時候買軟體要寄回四乘六英寸的註冊卡,上面寫名字、地址、郵箱。

他把整摞註冊卡翻了一遍,找微軟字尾的郵箱地址。找到三四個,挨個冷郵件發過去。

其中一個人叫阿拉斯代爾·班克斯(Alasdair Banks),回信說有個人可以介紹給他。那個人叫本·斯利夫卡(Ben Slifka),電話面試之後,決定招他去做 MS-DOS 的暑期實習。

這套路徑今天幾乎無法複製。一個沒有文憑、在加拿大中部、靠賣 shareware 為生的年輕人,透過翻註冊卡找到了進入微軟的門。但它背後的邏輯是通用的:先做出可以展示的東西,再拿著這個東西去找人。

他眼中微軟最可怕的地方,是人

“那是我參與過的最強的一群聰明人的集合。你在普通計算機公司上班,那個真正懂行的人,他那個更聰明的朋友,多半在微軟上班。”(戴夫·普拉默)

他在訪談裡講這個感受的方式很實在。你從小地方來,是當地的大拿,覺得自己懂很多。到了那兒,第一個反應是不敢說話,怕顯得蠢。

關於比爾·蓋茨,他給的評價沒什麼神話色彩:蓋茨對“每家每戶桌上一臺電腦”這一個念頭 relentless 追逐,僱比他更聰明或至少一樣聰明的人來執行,搭出一臺幾乎停不下來的智力機器,然後去賣非常簡單的產品。

MS-DOS 按他的說法,一點都不復雜。它就是命令列啟動器:你輸入命令名,它去當前目錄和 PATH 裡找,找到就載入進記憶體執行。加一點環境變數,一點指令碼語言,能訪問硬碟和 CPU,不能多工,沒有圖形介面。90% 的 DOS 就是這回事。

但這恰好是那個市場需要的。微軟跟 IBM 談成了每臺 PC 都預裝 DOS,收費不高,卻拿到了一個用了幾十年的標準位。這裡面的運氣成分和眼光成分,普拉默都承認。

640K 是一個責任,不是一句名言

“沒人會需要超過 640K 記憶體”這句話不是蓋茨說的。普拉默直接否掉了這個流傳幾十年的梗。

但 640K 這件事本身,他講出了開發者視角的重量。x86 真實模式的記憶體上限擺在那兒,你作為作業系統開發者,用掉的每一 K,使用者就拿不到。你無謂地用掉 10K,全世界每一臺機器就少 10K。這是一種很具體的責任感,跟今天動輒幾十 G 的執行時環境不在一個尺度上。

他在實習期做的第一件正事,是給 SmartDrive(磁碟快取)加上 CD-ROM 快取。光碟剛出來,微軟 Bookshelf 是少數能跑的產品,快取做得好,速度能快幾十倍。更麻煩的活是把 SmartDrive 和後來的 DoubleSpace 壓縮引擎搬進高位記憶體。

x86 上有個 A20 地址線,控制記憶體指標在 1MB 處迴繞還是繼續往上。你可以把段暫存器和偏移組合成超過 1MB 的地址,從而多拿到 64K,把程式碼放在那裡,低端記憶體只留跳轉樁。他們靠這招給幾個產品多榨出 64K。他當時完全不懂 HIMEM 是什麼,因為他是 Amiga 程式設計師,來微軟之前沒寫過一行 x86 程式碼。

移植程式碼像闖進別人家翻抽屜

“這就像闖進別人家,翻他們所有東西,看到他們不想讓你看的抽屜裡的玩意兒。你會發現牆上的好畫,也會在床頭櫃裡發現一些讓人不適的東西。”(戴夫·普拉默)

他參與把整個 Windows 95 的使用者介面移植到 NT 上。核心工作之一是全部轉成 Unicode,每個 8 位字元變成 16 位。他形容程式碼切換完之後是一片混亂。

他看到了寬度 200 字元的行,裡面夾著髒話。這些東西后來幾年裡被清理乾淨了,但當時的程式碼水平說不上多專業。

這件事的另一面是:你寫的每一行程式碼,都有人要一行一行讀過去。包括五年後的你自己。普拉默說,這就是程式設計師的宿命,你寫的時候以為沒人會看,實際上會被非常多的人看到,而且是最挑剔的看法,因為他們正在找 bug。

NT 是另一套故事。微軟從 DEC 挖來了戴夫·卡特勒(Dave Cutler),他在那邊做過 VMS 和 RSX-11。DEC 西海岸的 Prism 和 MICA 專案被取消,整個團隊一起過來了。所以 NT 是一個全新設計,起點是 OS/2,但 OS/2 是彙編寫的,NT 要用 C 寫,具體借鑑了多少,普拉默說他也不清楚。

他給卡特勒的定位很乾脆:核心的架構師。Linux 世界裡是林納斯,Windows 世界裡是戴夫·C。

“這人聰明得可怕,但他也像個農場主。他會跟在你後面,確保活兒幹完了,而且幹對了,確保你沒往他的作業系統裡塞垃圾。他不容忍這個。”(戴夫·普拉默)

他今年八十五歲,還是微軟 Fellow,據說每天仍然寫程式碼,仍然去上班。

他輸過一場架,至今不服

移植時他們在 MIPS 機器上幹活,RISC 架構不允許非對齊地址訪問。而 Windows 的 ID 列表是把 C:\、Windows、System32 這些元件拼起來的字串表,字元數一變成奇數,後面所有資料的地址就錯位了。

從非對齊地址讀字串,要麼開異常處理器逐位元組複製,要麼付出極大代價。他在郵件列表裡主張:乾脆保證 ID 列表永遠是偶數長度,或者用個 hack 強制對齊,這樣所有引用它的程式碼就能全速跑。

爭論升級成人身攻擊級別的對吵。他輸了。

“我今天仍然知道,Windows 裡那段程式碼比它本該有的速度慢幾千倍。沒人在乎,因為已經夠快了。但它本可以快得多。”(戴夫·普拉默)

他講這件事的語氣裡沒有怨恨,更多是那種工程師特有的、對某個技術判斷長期不服氣的執拗。二十多年過去,他還記得。

這類爭論他也見得多。兩個聰明人吵到最後,技術優劣變成次要的,贏過對方變成主要目標,這時候討論就不再產出任何東西。

他們那時候除錯,全程看彙編

半天時間在除錯,而除錯的大部分時間花在純彙編的呼叫棧上。沒有原始碼級除錯,你可以在旁邊看原始碼,但螢幕上永遠是機器吐出來的彙編轉儲。

更麻煩的是同時支援四套指令集:Intel、MIPS、Alpha、PowerPC。機器在哪套平臺上崩,你面對的就是完全不同的暫存器和指令。他在 MIPS 上經驗多,所以 MIPS 的活兒會流到他這兒。

這活兒在今天是難以想象的耐力消耗。他說自己職業生涯裡 20% 在創造,80% 在除錯和修東西。他有點修理工的名聲,所以他總能接到這類活。

他講了一個和工作管理員有關的 bug。程式偶爾會顯示 CPU 總佔用超過 100%,這對一個工作管理員來說非常難堪。他加了一堆斷言,確保加起來之前每一項都不超 100,最後總和也不超 100,結果斷言一次都沒觸發,使用者那邊照樣能看到。

最後他把自己的電話號碼寫進了斷言訊息裡:如果你看到這條訊息,打 425-836 找 DavePL。

後來壓力測試的偵錯程式真的抓到了,問題出在核心的計數邏輯,不在工作管理員。核心那邊改了。電話本該刪掉,他們只是註釋掉了。

“所以它就這麼釋出了,現在網上洩露的 NT 原始碼裡到處都是。我找工作管理員程式碼的辦法,就是在谷歌搜我的電話號碼。”(戴夫·普拉默)

他對斷言有一套近乎宗教的態度:

“我不去斷言我希望不成立的事。我斷言我知道不可能成立的事。這才是斷言的本意。一旦它觸發,那就是 bug,絕不能當成一條可以忽略的提醒。”(戴夫·普拉默)

他也知道很多人不敢加斷言,怕它真的響。他的比喻是:你在路口轉彎,覺得可能有車來,但你不往左看,因為你不希望有車。不敢斷言,本質是不想知道真相。

他強調斷言要長在程式碼裡,不是事後補上去。寫到某個函式,你知道這個指標不可能為空,那就斷言它;你知道計數永遠小於兩倍位元組寬度,那就斷言它。

那個 87K 的程式,是從家裡長出來的

工作管理員的起點是他自己想要一個東西:看清哪些程式在吃資源,哪些卡死了,然後能殺掉。他在家寫了基本功能,用的登錄檔效能鍵,因為在家不能調內部 API。

收編進公司之後,他才能調 NtQuerySystemInformation 和 NtQueryProcessInformation,直接拿到真實資料,這讓程式變得極快、極靈敏。

他從來沒把功能多當目標。功能就是那一套,他想要的都有了。他要的是絕對的健壯,和絕對的小。第一版 87K。

做到這個體積的手法今天看有點硬核:完全不連結 C 執行時。他確保自己不呼叫任何執行時函式,也不連結它們,省下大約 96K,那幾乎是程式本身的大小。代價是他得手動從分派表裡呼叫所有物件建構函式,因為沒有執行時會替他做。

不卡死的關鍵是不做假設。你調 Shell 去啟動一個程式,那個路徑可能在某臺 TCP/IP 共享上,超時要等 90 秒。所以任何可能耗時的 API 呼叫,都得放到單獨的執行緒裡。程式因此變得多執行緒,複雜度上去了。

他還順手發明了一遍漢明碼。工作管理員的每一行每一列都有髒位,他透過行列兩個方向的髒位反查哪些單元格需要重繪,配合 ListView 控制元件做到只重畫變化的那一格。所以它能畫得極快,縮放極其順滑。縮放是他個人給這個程式定的最大目標:拖到任何尺寸都不崩,即使有 32 個 CPU(那個年代不可能),它會畫八張圖然後迴圈,今天還能跑。

這些程式碼今天大部分還在。上面疊了深色模式、XML 配置、GPU 和溫度監控,體積從 87K 變成四兆。

“這就是我們生活的世界。”(戴夫·普拉默)

掃雷和紙牌是滑鼠教程

這兩款內建遊戲放進作業系統,充當的是教學工具。紙牌教你拖拽,掃雷大機率是右鍵,每一個都在教你一個操作。普拉默說得很直白,這是給新使用者熟悉滑鼠用的教具。

結果一整代人在這上面耗掉了無法統計的時間。

太空軍校生彈球(Space Cadet Pinball)是他另一段經歷。有人走進他辦公室問他接下來三個月想幹什麼,他說不知道,對方問要不要移植彈球。當時 NT 需要一個視覺展示,證明它能跑高速圖形或者至少是響應靈敏的圖形。

麻煩在於原版大量程式碼是彙編。他在 MIPS 機器上,只能先全部改寫成 C,才能往各平臺移。遊戲核心是一個巨大的狀態機,他記得大概是五十個分支的巨型 switch。裡面還有彩蛋。他把這塊當黑盒處理,自己的程式碼在上面做繪製和聲音。

有個細節他一直被問到:為什麼移植版的物理跟 Windows 95 原版略有不同。答案是 bug。他按每秒能畫多少幀就畫多少幀,在現代機器上彈球能跑到五千幀,於是物理被插值了五千次,而原來只有三十次。結果物理反而變“好”了,或者說至少不一樣了。後來這個問題被修掉了。

他把一棟房子的照片貼在顯示器上

1993 年,他和妻子開車在附近看房。有一棟三層臥室的房子,車道上停著一輛 93 年款紅色科爾維特敞篷,售價三十萬美元。他拿不出三十萬,連首付都拿不出。

他拿了傳單,剪下房子的照片,貼在顯示器上。

晚上回家他做兩件事:一是釋放白天修 bug 時無處安放的創造力,二是掙點外快。他照著一份 MSDN 的示例寫 Shell 擴充套件,做出一個能在資源管理器裡開啟資料夾的東西,然後往裡加 ZIP 支援。每一步都是增量。

他把它當 shareware 賣,19.95 或 29.95 美元,賣了幾百到幾千份。

某天早上他準備上班,接到一個電話。對方問,你是戴夫·普拉默嗎,你是寫 Visual ZIP 的那個人嗎。他說是。對方說,我是微軟的貝琪,我們想收購它,你能來談談嗎。

他問,你在哪棟樓。

對方愣了。他說我過來一趟就行。對方說不行,得先聯絡差旅,聯絡法務,要走流程。來回幾句之後兩個人才反應過來:貝琪不知道他就在微軟上班。他們是照著作者資訊冷電話打過來的。

他接受了報價。理由很實際:不接受的話,要麼繼續賣自己的版本然後辭職,要麼停賣然後繼續上班,兩個都不好。

然後他買了一輛二手的 93 年紅色科爾維特。

收編進 Windows 之後功能砍了不少。加密去掉了,因為那個年代加密演算法算軍需品,不能隨便往作業系統裡塞。多卷支援也去掉了,為了簡化。

ZIP 本身的來歷他也講了。BBS 時代,人們用調變解調器撥號下試用軟體,需要壓縮。可執行檔案大概能壓到一半。一個叫菲爾·卡茨(Phil Katz)的人做了 MS-DOS 上的命令列工具 PKZIP,從此在整個 PC 行業無處不在。Windows 出來的時候,市面上已經積累了十年的 ZIP 檔案,系統卻打不開,這就是內建支援的動力。

這套程式碼今天還在用。他補了一句:它是單核時代寫的,完全沒有多執行緒。你有一塊 96 核的 7995,解壓時它只用其中一個核。

啟用是他做的,他知道這東西招人煩

Windows XP 快釋出時,原本負責把 Office 的啟用機制移植到 Windows 的人一再延期,做不完了。普拉默有“能快速修好東西”的名聲,於是被找上門。

他帶著做 DRM 的團隊和做產品金鑰數學的研究人員,趕在 XP 釋出前做出來了。

他也承認這東西煩人,尤其是電話啟用。你得把硬體引數(記憶體、硬碟、繫結的各種硬體特徵)和產品金鑰一起編碼成字母數字,讓人在電話裡念出來。

“你要是覺得電話啟用很痛苦,想想在電話另一頭幹活的人是什麼感受。連著八小時聽產品金鑰,那是份能把腦子磨平的工作。”(戴夫·普拉默)

作業系統不該成為對手

話題轉到 Windows 11 的工作列。他做過一期講“為什麼工作列不能移動了”的影片,反響極大,憤怒是實打實的。

他給的解釋不站在使用者這邊,也不站在微軟這邊。可以移動意味著渲染、佈局、標籤頁排布的所有程式碼複雜度上升,bug 面變大,程式碼量變大,可能需要多一個開發者或者某個開發者的一部分時間。問題是,為了滿足一小撮使用者的小眾需求,到什麼程度還值得。

萊克斯·弗裡德曼(Lex Fridman)的反駁是:VS Code 什麼都能配,為什麼開始選單不行。這種對小眾需求的照顧會形成聲譽,會形成一種“這裡每個細節都被認真對待”的氣場,對招人也有好處。

普拉默的猜測是排期決策。重寫開始選單的時候,砍掉左右上下、雙行標籤這些特性,能提前四個月交付。他不認為這是對的決策,但很可能是真實的動因。

他提了一個更根本的問題:你希望作業系統是你的對手嗎。Windows 有時候給人的感覺就是這樣,它不站在你的利益這一邊。

萊克斯舉的例子很具體:登入時不想用微軟賬戶,系統把這個過程設計得像在騙你,你得反覆點“跳過”,還要確認“你確定嗎”,一個介面的意圖變成了讓你做不到你想做的事。

普拉默補了另一個:升級時的“使用推薦設定”。聽起來像該選的,實際上會把你重置回 Edge 和一堆別的東西。推薦是給他們推薦的,跟你沒什麼關係。

“我寧願每年付 199 美元用 Windows Pro,或者一個月 20 塊,別再往上推銷,別把我的資料變現。”(戴夫·普拉默)

老虎機的真相

他玩老虎機,明知整體是虧的,但那些強對比色和燈光對他是實打實的多巴胺盛宴。

機制他也講清楚了:機器內部有個黑盒,只幹一件事,生成下一個隨機數和對應的賠付結果。然後遊戲說,我得編一段電影來配合這個結果。三個 7 還是別的什麼,跟結果沒有因果關係。轉輪停下、看落在哪兒、再判斷你贏沒贏,這個順序是顛倒的。

至於跑什麼程式碼,他不知道。他試過接觸,很難。都是基礎 Windows PC,架在某種他不知道細節的安全飛地裡。

他還講了七十或八十年代拉斯維加斯的一個技術員,自己燒 ROM,把後門寫進去,藉著維修的機會換上自己的 ROM,半年後回來觸發。

他給一臺 PDP-11 裝了四個兆記憶體

這幾年他的特殊興趣是老硬體。他修 1960 年代的肌肉車和卡車,也修 PDP-11。

他攢了多年零件,決定裝一臺他能裝出來的最好的 PDP-11,就像給 PC 超頻那樣把一臺小型機拉滿。四個兆記憶體,那個年代是天文數字。上面是 PDP-11/70 的控制面板,下面兩個機箱,旋鈕控制 LED 顯示哪條匯流排,你可以暫停機器,用開關改地址,往記憶體裡塞資料。

燈的驅動不是現成的。他得重寫 BSD 核心才能讓燈按他想的方式閃。加一塊新磁碟控制器,就得重新編譯核心,就得去翻原始碼找裝置驅動的位置。

他現在對 BSD 核心已經相當熟了。

GitHub Primes:用一百種語言寫同一個演算法

他有個專案叫 GitHub Primes,同一個素數篩演算法,用大約一百種語言實現,規則統一,每晚跑一次基準測試,看誰快。

規則很硬:必須是素數篩,每個整數最多用一位,不能用一位元組,因為那樣更便宜也更容易。記憶體分配必須在計時迴圈內。每個實現裝進單獨的 Docker 容器跑,多核全開,五秒內儘可能多次篩到一億。

有些語言做不到,比如 6502 只有 64K,篩不了一億,那些就當表演專案跑。

他最初只寫了 Python、C#、C++ 三個,發了期影片,然後別人往裡扔實現,扔到失控,現在由歐洲的兩個人接手維護。

目前的榜首是 Zig。C++ 那邊最佳化一下能領先一陣,然後 Zig 的人不服氣,回來再改快一點。這是一場沒有終點的接力。

他用 Lua 加 Python 教 AI 打 Tempest

Tempest 是 1980 年的 3D 向量街機遊戲,360 度移動,螢幕上最多八發子彈,十一種敵人,還有尖刺。普拉默在這個遊戲上持有世界紀錄。

他先把 ROM 從機器裡取出來逆向,搞清楚程式碼在記憶體裡怎麼分佈、零頁變數在哪、哪些位置有意義。然後寫一個 Lua 程式,在遊戲執行時把這些記憶體位置讀出來當特徵,透過 socket 送給 Python 那邊,Python 做強化學習,用的是 dueling Deep-Q,兩個網路互相追逐。

現在 AI 能打到第 36 關,比大多數人強,但那遊戲一共 96 關,路還長。

他說得很實在:目標是想打贏他自己。

他的大腦一次只做一件事,但做得極深

自閉症的核心理論叫單otropism,普拉默的解釋是:他的大腦做一件事,做得非常投入,做完了再換下一件。他不是多工處理器,是徹底的序列單任務者。

好處是可以在一個任務上投入驚人的專注和堅持。前提是這件事他得喜歡,得有回報,得能看見進展。他說這感覺跟小孩玩火車是一樣的。

壞處是他同時有相當程度的 ADHD。獲取專注本身是難點,他極容易被分散,睡覺要戴降噪耳機,或者乾脆睡不著。但一旦進入狀態,很難被打斷。這兩件事同時存在,聽起來矛盾,實際上是一個門檻極高、進去之後極難出來的房間。

更大的困難是:他不知道別人在想什麼。

“我知道如果我是你,在這個位置,我會怎麼想。這是我所能做到的全部。大多數神經典型的人會有一種感覺,萊克斯大概是這麼想的或者那麼想的,因為他的舉止是這樣,反應是這樣,表情是這樣。這些對我來說全都丟失了。所以我給每個打交道的人跑一個代理 NPC 小遊戲。”(戴夫·普拉默)

電話對他格外難,因為只剩聲音。FaceTime 好得多,因為對方講完笑話可能會笑一下。在電話裡他分不清你是諷刺還是認真。

字面理解也是一部分。他小時候爺爺給媽媽在廚房做花架,用了很大的角鐵,五歲的他問這夠不夠結實能托住花盆。爺爺說,夠托住一匹馬。他當時非常困惑:為什麼要把馬弄進廚房,為什麼要把馬放在花架上。

他和妻子結婚三十一年,在一起三十七年。他們最早意識到彼此不同,是一天晚上坐在車裡,看著對面那棟房子,磚柱之間用錨鏈連成圍欄。他盯著那些兩英尺見方的柱子想,這是空心的還是回填了混凝土。妻子看著他,說,你腦子裡為什麼會有地方關心這個。

他在比爾·蓋茨面前糾正了“三個月”

第一個暑期實習,蓋茨把所有實習生請到家裡吃漢堡喝啤酒。他的導師本帶他去介紹。

本說,這是戴夫,我們從加拿大來的實習生,四個月裡他做了這些功能,還寫了 SmartDrive 的副本,然後開始列他做過的事。

他打斷了。

他說,其實是三個月。

兩個人都愣了,對視了一眼。他當場意識到,這個時機不對。

“小地方的不準確會把我逼瘋。”(戴夫·普拉默)

他現在的說法是,自己比過去好多了。以前他不知道,也不知道在對話裡毫無意義地插一句糾正會影響對方、讓對方有什麼感受。現在他有更好的判斷力了。

十秒測試,和十把椅子

他設計過一個粗糙的自測。第一個問題:對一個社會整體而言,合作和創造力哪個更重要?多數神經典型的人傾向合作,譜系上的人傾向創造力,傾向個體解決問題的價值。

想提高精度可以加第二題:一個房間裡有十把椅子,六個人進來坐下,還剩幾把椅子。

多數人會說四。他說十,因為椅子還在那兒。

“我並沒有在抬槓。我也不想把事情搞複雜。但我的腦子就是這麼運作的。”(戴夫·普拉默)

他回家後會重放每一個做選擇的瞬間

這套方法他叫情緒後處理。見完人,尤其是新認識的人,回家之後他會把當天所有需要做選擇的時刻重放一遍,先挑最不舒服的那些。剛才那一瞬我做錯了什麼,我漏掉了什麼,對方當時在想什麼,下次這種情況怎麼處理,要不要去補救一下。

他講了一個例子。他父親 1969 年買的新車,他留著,開了五十年。二十多年前他把車送去翻新,三個工匠做了三年,幾千小時。他去提車,檢查,很滿意,說這個好那個好,然後飛回家,寫支票,車送到。

十年之後他才意識到:一群工匠圍著他的車幹了三年,他當時應該說點讓他們高興的話,誇誇他們幹得多好。他沒說,因為那一刻他不需要那些話,也沒想到別人需要。

他給那家店的老闆發了封郵件:不知道你還記不記得,十年前我來提車,可能看起來並不滿意,但我想讓你知道,我對整臺車的工藝和水準非常佩服。

“他回信說,那個場面我想過很多次。”(戴夫·普拉默)

這十年的時間差,是理解自閉症的一把鑰匙。他並非不感激,只是感激的訊號在當下沒有生成,十年後才被後處理機制撈出來。

也正因為這套機制存在,他要澄清一個流傳很廣的說法。

“社群裡有一種看法,認為自閉症的人缺乏共情。我認為完全不是這樣。我只能代表我自己說,我共情能力相當強。問題出在溝通上,而且是雙向的。我不知道你此刻感覺如何,所以在你說出來之前,我很難對你共情。可一旦我知道了,一旦我理解了你腦子裡在發生什麼,我可以非常為你難過。”(戴夫·普拉默)

在沒有資訊的情況下,他的預設設定是:你會像我一樣處理這件事,用我所知道的方式。

所以他對神經典型的人的建議只有一條:說具體。別指望他能接住暗示、微妙和言外之意。如果你想把他推向某個行為,最好的說法是“戴夫,你需要做這個”。

萊克斯在訪談裡當場問:我今天有哪裡做得不對嗎?沒有。那打分呢,一到十分?7.5 分。浮點數打分,很符合這個人。

假裝正常是一份全職工作

所謂 masking,用他自己的話講,就是表演正常。

“你在社互動動裡做的每一件事,揮手、表情、語調、姿態,全都是刻意構造的,全是工作量。對多數人來說這是自然的,他們就是這麼做的,有些人還做得特別好。但對譜系上的人來說,你得把這一切都假裝出來。”(戴夫·普拉默)

他提到 Rush 樂隊那首《Limelight》,尼爾·皮爾特(Neil Peart)寫的詞,大意是世界是個舞臺,我們只是演員、表演者和描繪者,互為彼此的觀眾。歌裡反覆講無法把陌生人當朋友、必須偽造情感。普拉默只對已故的人做推測,但他覺得寫詞的人大概也在處理同樣的問題。

這首歌之所以能擊中那麼多人,可能正因為這份疲憊有普遍性,只是在他們身上被放大到了一個必須每天面對的強度。

崩潰是一個開關,不是一段情緒

他描述 meltdown 的方式很像在講一個系統故障。情緒過載到某個點,你不再能管理自己的行為。他舉《雨人》裡機場那場戲,或者某些影視劇裡那個被禁止做手術的外科醫生。

“開關一翻,你就掉進原始大腦。額葉皮層在某種程度上關閉了,你不再擁有決策和過濾的能力。那種狀態下你是一條爬行動物。這本質上是恐慌,是面對無法忍受的當下現實的戰鬥或逃跑反應。”(戴夫·普拉默)

萊克斯順口把它比作大腦的藍色畫面。普拉默說,差不多。

觸發它的一般是一連串事情的累積:糟糕的出差、工作上的爭吵、被隨機打亂的一天,堆到臨界點,任何一件小事都可能成為最後一根稻草。

“你還好嗎”需要兩個步驟

他和妻子最近幾年養成了一套明確的檢查機制。她會問,你還好嗎。他答,還好。

“這裡面有兩步。第一步是‘你還好嗎’,第二步是我的回答。因為如果我只是說‘好’,她就知道有事。”(戴夫·普拉默)

這套機制存在的原因很樸素:他沒法透過看一個人就知道對方狀態如何。所以必須顯式地互相 ping。

他對感情這件事的自我評價很低。“我從來就不擅長跟人打交道。有人喜歡我,我大概也接收不到。”他給兒子買過一件 T 恤,上面印著:如果你在追我,請明確告訴我,因為我毫無察覺。

“我得在一個人身邊待很久,慢慢長進去,因為我沒有任何技巧,那種社交舞蹈需要的能力我一點都沒有。我唯一的選擇就是做我自己,而這對某些人是行得通的。”(戴夫·普拉默)

被這些問題吸引的人,大概有一兩成

他寫過一本書叫《自閉症百萬富翁的秘密》(Secrets of the Autistic Millionaire)。書裡提到一個概念:很多人會覺得自己“有一點點自閉”。

他的估計是,可能 10% 到 20% 的人處在譜系的某個位置,但影響程度沒有高到構成障礙。這些人仍然帶有許多源自自閉症的特徵。如果能識別並最佳化地管理這些行為,既可以借力,也可以緩解它帶來的缺陷。

這本書主要是寫給他孩子的。據他所知,幾個孩子都沒到 ASD 的診斷標準,但身上都有他某些跟這個相關的行為特徵。他想給他們寫一本手冊。

至於為什麼程式設計師裡這樣的人格外多,他的答案很直接:那種單向的專注,把問題不斷化簡的能力,以及對“裡面到底是什麼”的終極好奇。他一輩子都在拆東西,拆媽媽的烤箱,就為了搞明白翻頁鍾怎麼工作。他認為這是程式設計師的好習慣。

他剛好趕上了需要懂所有層的年代

關於 AI 寫程式碼,他的用法非常務實。Python 他不熟,幾乎是新學的,所以這個專案裡大量用生成式工具。他覺得很有用,因為看不懂的地方可以看它生成什麼,從中學到東西。他自己從零寫 Python,長度大概是 AI 產出的四倍,因為 Python 寫得好的話可以非常簡潔。

他承認自己是在 vibe coding 這個專案。

萊克斯追問了一個關鍵點:這必須建立在你已經會程式設計的基礎上。普拉默同意。他說你不可能在自己完全不會程式設計的情況下靠 vibe coding 做出一個東西,但如果已經是個好程式設計師,AI 能讓你變得極其強大。因為你能讀懂它生成的東西,能判斷下一步該讓它做什麼。

關於二三十年後的程式設計,他給的類比是橋樑工程。曾經有一批人在下面焊鋼樑,現在人們在 AutoCAD 裡拖拽預製件。程式設計大概也會變成那樣:你不再逐行扔程式碼,你搬動元件和介面,向 AI 描述它們之間該怎麼互動,讓它把元件造出來。但我們離“憑空生成一個相容 Linux 的核心”還差得很遠。

萊克斯問他會不會覺得遺憾,從機器碼、彙編、C、C++ 一路走到用自然語言寫程式碼,抽象層爬得這麼快。

“我出道的時機其實很幸運。技術是在三四十年裡一層層長出來的,所以我理解 TTL 邏輯,也能用 AI 寫程式碼,中間那些零件我大概都知道。我的知識當然有洞,但要把這張圖拼得這麼完整,恐怕只有親身活過那段時間才行。現在起步的人,很難複製這個。”(戴夫·普拉默)

這句話點出了一件事:他這一代人的知識結構是歷史給的禮物。硬體、編譯器、驅動、介面、網路,每一層都在他職業生涯的不同階段被推到臺前,他被迫全部學一遍。今天入行的人,一上來就站在十層抽象的頂端,底下九層是黑箱。這不是能力問題,是時代問題。

意義這件事,他答得很乾脆

萊克斯最後問的是那個大問題:這一切的意義是什麼。

“做出很酷的東西。歸根到底,我在乎的是能做出對別人有用的複雜東西,這件事能調動我的能力,讓我有創造性,讓別人用得上。如果把我限制在繪畫、雕塑那些傳統藝術裡,我毫無希望。對我來說這就是意義所在。然後再養出幾個好孩子,把接力棒交出去。”(戴夫·普拉默)

訪談的結尾,萊克斯引用了本賈尼·斯特勞斯特盧普(Bjarne Stroustrup)的一句話:世界上只有兩種語言,人們抱怨的,和沒人用的。

這句話放在普拉默身上挺合適。他寫的東西被幾十億人用過,也被人抱怨過,工作管理員被人抱怨,Windows 啟用被人抱怨,ZIP 資料夾被人抱怨。他本人對這些的態度是一致的:先把東西做出來,做小,做穩,然後接受它被使用的方式。

這期對話裡最值得帶走的,可能不是那些微軟往事。是一個人在明確知道自己大腦如何運作之後,圍繞這個事實重新設計了生活和工作的方式:用作品代替自我介紹去爭取機會,把社交規則顯式化成檢查機制,把每次失誤放回家之後重放一遍,把 640K 當成對全世界每一臺機器的責任。

還有他那句關於專注的坦白。他能對一件事投入極強的注意力和堅持,但前提是這件事他得喜歡、得有回報、得看得見進展。這三條其實也是所有人能進入心流的條件,只是大多數人可以在狀態不佳時硬撐過去,而他的大腦不提供這個選項。

最後是他自己給出的那份清單。

  • 如果你正走在“今天先不去”的路上,注意那個決定正在變大。想走非標準的路,就明確地做大決定,別讓一百個小決定替你做。
  • 找工作的時候,賣你能做的東西,不要賣你自己。GitHub 記錄、你寫過的演算法、你做出來的成品,比性格展示有效得多,尤其是在你不擅長社交表演的時候。
  • 斷言要寫在你確信不可能成立的事情上,而且要長在寫程式碼的過程裡,不要留到事後補。它響了是在幫你。
  • 寫任何要給別人用的工具,先假設所有 API 呼叫都可能卡住九十秒,把所有可能耗時的操作放到獨立執行緒。程式的可靠性和體積可以同時追求,87K 的工作管理員就是證據。
  • 不要在程式碼裡留自己的電話號碼,除非你已經準備好它會在二十年後被谷歌索引到。
  • 如果你身邊有人在譜系上,把話說具體。不要說“你覺得那樣行嗎”,直接說“你需要做這個”。不要指望對方接住暗示,那不是不願意,是收不到。
  • 如果你是那個收不到訊號的人,建立顯式的檢查機制。跟親近的人約定一個固定的問法和答法,把“讀空氣”換成“直接問”。
  • 每隔一段時間,回頭重放那些你當時沒反應過來的社交時刻。十年後才想起來誇一句工匠的手藝,也比永遠不說好。
  • 想學一門新語言,最快的路徑是帶著一個真實專案去學,讓 AI 生成,你負責讀懂和判斷下一步。前提是你已經會程式設計。
  • 如果某件事讓你痴迷到想拆開看裡面到底怎麼運作,別壓著它。這種好奇是能吃飯的本事。
文稿來自 Lex Fridman 官網公開發布的官方 Transcript(含說話人與時間戳)。
Lex Fridman (00:00:00): 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. He also ported the code for Space Cadet Pinball, also known as 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. Lex Fridman (00:00:44): 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. Lex Fridman (00:01:22): Tell me about your first computer. Do you remember? Dave Plummer (00:01:25): I do. 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, and I rode my bike in fifth or sixth grade, so I was about 11, to the local RadioShack. They had the standard component stereo systems, everything else RadioShack had, but they had a stack of boxes that was labeled “computer.” So I was asking the people who worked there about it, and they said they just got it and they hadn’t set it up yet. I was rather precocious and I figured, “Well, I’ll set it up for you,” and they said, “Okay. Have a shot.” Lex Fridman (00:01:53): Did you know what you were doing? Dave Plummer (00:01:54): Absolutely not. I mean, it’s no worse than a component stereo. The only thing is that Tandy, in their infinite wisdom, used the same five-pin DIN connector for power, video, and I think cassette, so they were all identical, and if you plugged them in wrong, you’d blow it up. So I read the label and got it working and wound up playing with it and not knowing anything about computers. So I’m typing English commands into it and, you know, PRINT 2+2 works perfectly, yet more simple English that you enter into a basic Level 1 interpreter is not going to get you very far. Lex Fridman (00:02:23): So you’re trying to talk to it in English? Dave Plummer (00:02:26): Didn’t know any better. And I still have an old foolscap that I wrote in sixth grade of a program that’s kind of illogically correct but has no chance of working on any interpreter that existed at the time, so it took me a while to figure out what was actually going on with them. But I rode my bike down there every Thursday and Saturday, and they were gracious to let me use the machine. Lex Fridman (00:02:45): When was this? Dave Plummer (00:02:46): ’79, ’80. Lex Fridman (00:02:47): Okay. What was the state of the art of computing back then? So what are we talking about? Dave Plummer (00:02:50): Well, the big three had come out. There was the TRS-80 Model 1, there was the PET 2001, and the Apple II came out roughly simultaneously. Lex Fridman (00:02:59): Apple II. Would you say that’s the greatest computer ever built? Dave Plummer (00:03:02): Probably in retrospect. Well, I would probably give that to the Commodore 64. Lex Fridman (00:03:06): Yeah. You and I agree on this, that that was my first computer probably many years after it was released, but yeah, Commodore 64’s incredible. But yes, Apple II had a huge impact on the history of personal computers. Dave Plummer (00:03:18): Right. It’s hard to gauge the long-term impact, but I think the 64 itself probably influenced more people, so that’s my reason for picking that one. Lex Fridman (00:03:26): You think so? Dave Plummer (00:03:26): The sales were certainly higher. Lex Fridman (00:03:28): So Commodore 64 sold a lot? Dave Plummer (00:03:30): Yeah. I mean, the numbers are hard to believe. It depends which numbers you believe, but even the medium estimates were pretty high. Lex Fridman (00:03:36): All right, cool. So you eventually graduated to the Commodore 64. Tell me about that machine. What did you do on the Commodore 64? Dave Plummer (00:03:45): Well, the first thing I did was overheat the floppy drive on it, 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, which meant when it died, it had to go back to Germany or something to be fixed. So I was left with no floppy and so I had a cassette deck, which was the best you could do at the time, and so 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 op codes in 6502 in hex, and if you were careful about planning, you’d be able to write some basic programs. Dave Plummer (00:04:17): So that’s kind of how I learned, and the first thing I ever wrote on it was a clone of Galaga. Now, it’s a bad clone of Galaga, but it has the major enemies that attack over time, and it’s all written in hand-coded machine language, and you can’t relocate 6502, so if you need to add code in the middle, you need to manually sort of jump to somewhere else, do your work, jump back to where you were. It’s just hideous spaghetti code. But it all worked eventually, and 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. So that was my first experience with data management. Lex Fridman (00:04:53): Oh, no. Dave Plummer (00:04:53): So I don’t have a copy of my first program anymore. Lex Fridman (00:04:55): What was that feeling like? Do you remember, of, of just doing something if I may say so, like stupid, you know? Which is a part of the programming experience. Dave Plummer (00:05:04): Yeah, there was a huge amount of guilt because, right, you destroyed several weeks- … of work and you know it was because you rushed- or you did something stupid or you made an unwise choice. Lex Fridman (00:05:12): What can you tell me about the programming involved in that game? Dave Plummer (00:05:15): So it’s literally machine language. Lex Fridman (00:05:17): So machine… So it’s not- Dave Plummer (00:05:19): Yeah, 65 with- Lex Fridman (00:05:19): … even assembly. Dave Plummer (00:05:19): Not assembly yet because there was no assembler built in, so I should have written an assembler as my first task, but I wasn’t that clever. Lex Fridman (00:05:26): How hard is that to do? Dave Plummer (00:05:28): Trivial, and it’s one of those things that sticks, I think. You do it so many times. You know, if I give you a C issue, there are certain syntactic issues in C that you’re never going to forget and get wrong. And it’s just one of those. Lex Fridman (00:05:40): Like, what are the limitations of programming in machine code, as a programmer? Dave Plummer (00:05:44): The biggest issue is you have to write completely sequentially because at least in that variant, 6502, you can’t add things later. You can only add things on the end. So it’s like programming a tape in a way. Lex Fridman (00:05:54): What was the most complicated thing you’ve built with machine language? Dave Plummer (00:05:57): That game would be. I mean, 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- Lex Fridman (00:06:04): You literally built a game. Dave Plummer (00:06:06): Not a great game, but it worked. Lex Fridman (00:06:07): Okay, all right, and then you erased it? Dave Plummer (00:06:10): I did. Lex Fridman (00:06:10): All right. When did you first fall in love with programming? When you figured out, like, this is a, this is something special. Dave Plummer (00:06:18): … I think there was two stages for me. I always knew immediately that I was fascinated with these machines, from the TRS-80 Model I. It’s all I wanted to do was ride my bike back there and have more time with it. And I did that, you know, to wear out my welcome as much as I could. And the other revelation came, I think about second or third 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 abso- absolutely no idea what I’m going to do post-graduation. But I love what I do.” And so, I think that was a lot of consolation. It’s like, it doesn’t really matter what I’m doing at this point, ’cause I kind of love doing it, so… Lex Fridman (00:06:54): So, you’ll figure it out. As long as you’re following this kind of feeling that’s telling you- Dave Plummer (00:06:58): I knew I was in the right area, finally. Yeah. Lex Fridman (00:06:59): Yeah. All right. You dropped out of high school. Dave Plummer (00:07:02): Yeah. Not the smartest move. Lex Fridman (00:07:03): Okay. But you ended up going back to school and being very successful at school and, just in general, successful as a programmer, as a developer, as a creator of software. How were you able to find your way? Can you tell that journey of dropping out— …and then finding your way back? Dave Plummer (00:07:21): There’s no moment when I dropped out. You just go less and less and less until you realize it’s going to be embarrassing if I show up because I haven’t been there in a long time, and then pretty soon you’re just not going, and that’s how you drop out of high school. So, if you find yourself on that path, stop doing that. But that’s precisely what I did. And so now I’m not at school and I have to get a job, so I’m working at 7-Eleven and a paint warehouse and stuff like that. And 7-Eleven is actually kind of an interesting job because it’s a job I think they keep rotating for people that are smart enough to do the night shift with all the accounting and the administration and stuff they make the night shift do, but that have reasons personally that they need to work at 7-Eleven. Dave Plummer (00:07:56): And I was one of those people because I had no high school diploma. Lex Fridman (00:08:00): What are some memorable moments from that time at 7-Eleven? Or maybe what do you appreciate about the difficulty of that job? Dave Plummer (00:08:09): Probably the worst moment for me… I mean, I got held up at knife-point and stuff, and that’s all entertaining, but the worst… …The most… The suckiest part for me was doing the gas dips. We’ve got a long… It’s a, like a 15 or 20-foot wooden stick and it’s measured in gradients of inches and feet, and you drop it into the gasoline tanks and then you bring it up and you measure where the gasoline sits because there’s no electronic sensor. So, I’m doing that, and the first time I do it, I drop the pole and I re-grab it. Well, that’s about a thousand splinters of wood into your hands, and it’s 40 below out and that really sucked. Lex Fridman (00:08:38): Oh, wow. Dave Plummer (00:08:39): And I realized, “I don’t want to do this for a whole life.” I knew that, so… Lex Fridman (00:08:44): Okay. So you stand there frozen with splinters in your hand. Dave Plummer (00:08:47): And at some point, I have a revelation about my life that next time I’m going to do it differently. And then how ludicrous that is hits me about three seconds later, right? And I think that was really the moment for me where I realized that I’ve got to do something different. And so even though I was 21, I went and I talked to the principal of my local high school and I was like, “Can you let me back in?” And he’s, “No, you’re too old and we don’t have room,” was his main reason. And I said, “Well, between now and then, somebody’s going to drop out. So, you’ll have room. So, let’s assume you have room. Can I come back?” And he was gracious and let me come back. And so I did the three or four classes that I needed. Lex Fridman (00:09:24): Yeah, just 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, like, you kind of have to be part of society to do certain things. Dave Plummer (00:09:44): Right. Lex Fridman (00:09:44): And 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. Dave Plummer (00:09:54): Well, the problem with that process is you’re making a much smaller decision. “I’m just not gonna go to class today.” And that’s all you’re deciding, but you do that enough times, you’re making a much bigger decision. And that’s the problem. Lex Fridman (00:10:04): So it’s better to make… If you want to live life in a non-standard way, it’s better to make the big decision explicitly and then you can stop going. Don’t allow yourself to make the slip-ups, though. Dave Plummer (00:10:15): It’ll be made for you eventually. Lex Fridman (00:10:17): Okay. Well, you got back, and you eventually went to college and were very successful as a student, and you weren’t that good of a student before. Dave Plummer (00:10:24): 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 like the makeup class for the Geometry 12th-grade class that I didn’t have. And that scared me because I realized by 1% or the grace of the professor that let me through, I just about ended my entire university career here. So, fortunately, those marks don’t count on your transcript because they’re remedial classes. So, I got kind of a fresh start the next semester and did it for real, and I did it for me, and that made all the difference. Lex Fridman (00:10:55): What can you speak to maybe by way of advice on how to be successful as a student? Dave Plummer (00:11:00): Well, ideally, there’s some aspect of school that you do enjoy, whether it’s art, whether it’s computer science, whether it’s shop class, whatever. So, 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, and that’s easy to say when you’re 50-something. It’s harder to say when you’re 15-something, but— … it makes a lot of sense. Lex Fridman (00:11:20): All right. What’s the story of you joining Microsoft? How did we get there from 7-Eleven to Microsoft? Dave Plummer (00:11:27): Yeah, it’s a big jump. So, I had gone back to school, and I think it was in my third year of university. I was working for the phone company for the summer as a summer job, and I’m doing conversions of their UBNet to TCP/IP and modern networking, which really amounts to swapping cards but then figuring out why their config.sys doesn’t allow Lotus to run anymore because it’s got 10K less than it used to, and it’s just a horrible time to be working in computers, but I was doing it. And at lunch, I’m sitting in the food court with the old and the bored, and I’m reading a book that I had bought called “Microsoft or Bill Gates and the Making of Microsoft Hard Drive,” I think is the title. And it’s a great book. Dave Plummer (00:12:02): It’s just sort of a matter-of-fact history of how Microsoft came to be, what it’s like, how it operates, what the people are like there. And I’m reading this book, and I become really entranced by it and fascinated because it sounds like exactly the place that I want to be, but I’m in Saskatchewan, so what am I going to do about it? And what I wound up doing was, I had put myself through school with a program called HyperCache, which is a file system cache for the Amiga because the Amiga didn’t have any out of the box, and it had done reasonably well. Dave Plummer (00:12:29): So, I went through my registration cards, because in those days you had a four-by-six card that people had to fill out with their name and their address and, if they had an email, their email, and they’d send it in, they’d get notifications of updates and so on. Well, it’s shareware. And I went through the whole stack looking for anybody with a Microsoft email address, and I found maybe three or four people, and I just cold-emailed them and said, “Hey, I’m an operating system student in Saskatchewan looking for an opportunity.” I don’t remember exactly what I said. Dave Plummer (00:12:54): But one guy, Alasdair Banks, he wrote back and he said, “I know somebody that I can put you in contact with.” And he put me in contact, I think, with a guy named Ben Slifka, who did a phone interview, who eventually wanted to hire me to work on MS-DOS for the summer. So, that’s how I got there. Lex Fridman (00:13:10): You put yourself through school by… Tell me about HyperCache. You built a piece of software- Dave Plummer (00:13:15): It’s the weight loss program for hard drives. Lex Fridman (00:13:17): That was sufficiently useful to a large number of people that would somehow give you money? Dave Plummer (00:13:24): Yeah, it made decent money. I mean, I sold a couple thousand copies. At 20 bucks a copy or 40 bucks a copy, depending on the rules. Lex Fridman (00:13:29): What program, what language was it written in? Dave Plummer (00:13:31): 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 68,000 assembly. Everything else was C. Lex Fridman (00:13:40): Okay. This is like file system I/O? Dave Plummer (00:13:43): Device block I/O. So any block that gets serviced from the drive would go through my cache first, and it was an N-way associative cache, and so it would try to match the geometry of the drive and do pre-fetch based on you’re trying to read a whole track at one time, that kind of thing. Lex Fridman (00:13:57): What was it like trying to get your software out there at that time? How were you able to find customers? Dave Plummer (00:14:05): Yeah, it’s interesting. I think I started on Usenet and some of the Amiga forums, posted, “Here’s my trial version, try it out for 30 days, see what you like.” And eventually it got picked up by a few retailers, and 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. And so this is late ’80s, and she’s got, you know, the antenna on the roof and the big box in the trunk, the whole deal. But we got a call from one of the software retailers that wanted to buy 50 copies at… 20 Bucks, which to me is a thousand bucks, which in 1989 or whatever year it is was a big deal. And so eventually a number of companies just bought inventory. Lex Fridman (00:14:41): 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 the personal computing space at that time and, and really for many, many, many years after? Dave Plummer (00:14:52): At the time, it was the single most potent assemblage of smart people that I’ve ever been a part of. And I’ve been in academia and I’ve been in industry to a certain extent, and you know, 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. So 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 just in an environment where, like, “Uh-oh, I’m just not going to speak because I don’t want to look stupid.” Lex Fridman (00:15:20): Okay. What about Bill Gates himself? What are some qualities of Bill Gates that you think contribute to the success of Microsoft? Dave Plummer (00:15:28): 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 that were as smart or smarter than him to help him execute it. And 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. Lex Fridman (00:15:56): MS-DOS changed the game. And that’s actually the team you joined, the MS-DOS team, and I think you joined before Windows 95. Was released. So tell me about the story of MS-DOS. Its success is probably pivotal to the success of Microsoft. Dave Plummer (00:16:18): 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. But their deal to have MS-DOS included with every version or every instance of the 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, and 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. Lex Fridman (00:16:51): So at that time, MS-DOS, no graphical interface. Can you just speak to what the heck MS-DOS is? Dave Plummer (00:16:57): It’s largely a command launcher. So you type in a name of a command, it looks it up to see if that’s in the current directory or on a special path of folders, and it loads it into memory and executes it if it’s there. And that’s 90% of what MS-DOS does. Now, it has environment variables and some complexity and a small scripting language built in, but it is basically just an operating system shell that allows you to use the resources of the computer, like the hard drive or the CPU, and it doesn’t allow you to multitask. There’s no graphical interface. Now, Microsoft did a- add a text-based graphical interface for things like an editor and QuickBASIC in DOS 5.0, I believe, and there was a DOS shell, which was sort of a graphical file manager in MS-DOS 4.0. Dave Plummer (00:17:38): So they experimented with it, but it’s largely a command prompt. Lex Fridman (00:17:42): 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? Dave Plummer (00:17:52): Well, it was limited by the original x86 instruction set, which limited it to 640K. And then there were various Band-Aids on top of that to do high mem and then extended memory beyond that, and a lot of hoops have to be jumped through to make anything work without consuming base RAM. Lex Fridman (00:18:10): Yeah, I mean, you programmed on MS-DOS. What’s it like? What are some interesting details there? Like you said, there’s the memory constraints of 640 kilobytes. Dave Plummer (00:18:20): Yeah, 640K is the maximum that’s ever gonna be available, so 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, you’re gonna… Every machine in the world now has 10K less, so it’s kind of a big responsibility. Lex Fridman (00:18:35): Is that a true quote from Bill Gates, where he said, Dave Plummer (00:18:38): Nobody will ever need more than 640K? Yeah, no, it’s not him. It’s been attributed to him, but not real. Lex Fridman (00:18:43): What are some interesting aspects of what you were able to do as an intern and when you joined on MS-DOS and beyond? Dave Plummer (00:18:52): One of the first things I did was to take SmartDrive, the disk cache, ’cause I had familiarity with disk caches- and to add CD-ROM caching to it, because that was new. CD-ROMs were just coming out. Microsoft Bookshelf is one of the few products you could run for it. And 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 double-space compression engine up into what’s known as high memory. Dave Plummer (00:19:19): And without rat holing on the technical aspect of it, on the x86, there’s something I believe called the A20 line. And I probably have this backwards, or I got a 50-50 shot at it, but if you’ve got the A20 line asserted, then your memory pointers wrap at the one megabyte mark. Dave Plummer (00:19:34): And if not, they don’t. So you continue going up in memory. So you can rewrite memory above by combining your segment and offset registers to a number bigger than one megabyte, and you get an extra 64K. And you put your code in there, and then you just put stubs to jump to it from low memory. And so you can get another 64K out of the machine that way, and we did that for a couple of the products. And that’s … I had no idea what HIMEM was, ’cause I was an Amiga programmer and I’d never written any x86 code before I got there, so … Lex Fridman (00:20:02): So that was, like, a cool optimization you got to be a part of. So 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? Dave Plummer (00:20:12): I actually worked on Windows 95 for about three or four months. I was on the COM/OLE team doing the presentation cache, which is when you insert a, 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. So that shipped in Windows 95, but I moved to the Shell team about six months after getting to Microsoft, and so I worked on NT from there forward. Lex Fridman (00:20:38): Okay, and what’s 95? What’s NT? Dave Plummer (00:20:40): Windows 95 is an evolution of the original 16-bit Windows 3.1, which was the very first popular version of Windows. And it adds 32-bit support, then VxD drivers and a bunch of new technology and an entirely new user interface. And it’s something that at the time was revolutionary. The people lined up at night to wait in line to buy the thing. Lex Fridman (00:21:00): Can you just take us back to that time and describe why 95 was such a big leap from 3.1? So Apple already had a graphical interface. Windows 3.1 had a graphical interface. Why was Windows 95 such a gigantic leap? Dave Plummer (00:21:17): 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, and that’s why I started writing a Shell extension, which became Zip folders at some point. But 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 the NT and what’s Windows today. Lex Fridman (00:21:39): Would you say that’s the greatest operating system ever? What’s the most impactful operating system ever? Dave Plummer (00:21:46): Windows 95 would be number two for me. I think OS/360 is going to be number one. Lex Fridman (00:21:50): Okay, interesting. Dave Plummer (00:21:51): Because you could take a machine and write a COBOL program for it in 1962, jump in your time machine, go to Poughkeepsie and boot up an IBM z17 mainframe and run it today. And they’ve been doing it for however many years that is. And 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 in the commercial side as Windows 95 was in the home side. And then probably Linux would be number three 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. Lex Fridman (00:22:29): So, yeah, Linux created… I mean, it was the embodiment of the open source spirit at its largest scale. Right? So it almost created a community and it created a spirit of programming that propagates to this day. That’s true. That’s true. Like scale matters. Dave Plummer (00:22:51): 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, so… Lex Fridman (00:22:59): Yeah, the world… I mean, this is the quiet secret of the universe, is it runs on Linux. Okay, so tell me about your work days. What were they like back then? Back in the MS-DOS and Windows 95 days? Take me through a productive day. Dave Plummer (00:23:17): Well, your day starts coming in and you’ve got to download the address book, which is… Microsoft has between 10 and 15,000 employees at this point, and we’re all on MS Mail. We’re just getting off of the PDP-11 called Miss Piggy, which ran Whizmail, and we’re running MS Mail. But MS Mail has a fixed address book that every user must download every morning, and when there are 10,000 people downloading 10,000 people, it gets pretty messy. And I think we were on 10 megabit networking at the time, so your first hour is downloading the address book, which was always frustrating. But you’d use that time to look at the crashes that would have happened overnight from a process we called Stress, which is NNT… Dave Plummer (00:23:53): All the machines that are unused run tests all night long and they try to crash themselves, and if they manage to crash themselves, it will drop into a debugger with a serial cable to another machine and you can connect to that other machine and remotely debug the crashed machine. So you come in and they will have triaged bugs, you know, there was a crash in the Start menu, so we’ll assign that to Dave, and so you come in and that’s your first thing, is to connect, because you’ve got to get that machine back to the guy that owns it and unlock the machine, so that’s your first hour of your day, is basically triage for bugs that have come up from Stress overnight and then at that point it’s probably back to coding, which unfortunately 80% of the time is fixing bugs, especially in my career it Dave Plummer (00:24:31): was porting code and fixing bugs. I wasn’t writing a lot of new code and there were exceptions. I wrote a lot of new code on the side to get it out of my system… …From a day-to-day grind of always fixing bugs in other people’s code, which is amazing learning experience. Lex Fridman (00:24:46): So you did a lot of the… At Microsoft, you did a lot of the porting of what is it, Windows 95 code to NT? Dave Plummer (00:24:53): Yeah. We took the entire Windows 95 user interface, and we ported it to NT, which meant making it Unicode, for one thing. So everything that was eight bits is now 16 bits. Lex Fridman (00:25:02): Okay. Dave Plummer (00:25:02): …pointers. It’s quite a mess when you switch the code over, as you can imagine. Lex Fridman (00:25:07): Can you give us insights into what is involved in porting? Dave Plummer (00:25:12): It’s like breaking into somebody’s house and going through all their stuff and seeing the stuff 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 like 200 characters wide with, you know, profanity and swears in it. It eventually got all cleaned up over the years by the time I left. But it was not always the most professional code in the world. Lex Fridman (00:25:37): Right, because every single piece of code you have to go through. Dave Plummer (00:25:40): Line by line, so you see it all. Lex Fridman (00:25:41): 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, …that come after you, including you five years later. You yourself looking at your own code. Okay, so tell me about Windows NT. That was a giant leap too. Dave Plummer (00:26:06): It was. It was basically a clean-sheet design. So they went and they got Dave Cutler from Digital Equipment, who had done operating systems for them, VMS and RSX-11, he had done. And so he came over after, I believe it was Prism and MICA were some projects at DEC West that got canceled. And so you had a whole team of guys where their project is canceled, and basically, they took a whole bunch of them and came to Microsoft. And I don’t know the specifics of the deal, but they all showed up. So you had Dave Cutler and Mark Lucovsky and all these really smart guys from DEC, and they did basically a clean sheet, but they also had OS/2 as a starting point. But OS/2 was, of course, written in assembly language, and NT is going to be written in C. Dave Plummer (00:26:46): So 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. Lex Fridman (00:26:53): You said that Dave Cutler’s the man, the mind behind Windows. Can you explain? Dave Plummer (00:26:59): So Dave Cutler is the architect of the kernel. So he is Linus in the Linux world. It’s Dave C. in the Windows world. Lex Fridman (00:27:06): Yeah. Dave C., okay. Dave Plummer (00:27:07): And it’s not that there weren’t other people that contributed, of course, huge pieces to it. But I think he’s the driving force behind it and always largely has been. And he’s still… I think he’s 85 now. He still codes every day. He’s a Microsoft Fellow. He, as far as I know, still goes into work, so… Lex Fridman (00:27:21): Can you speak to the genius of that guy? Like, what’s interesting about his mind, having worked with him, having interacted with Dave Cutler? Dave Plummer (00:27:30): Well, the dude’s wicked smart, but he’s also like a farmer. He’s like the guy that 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. And he won’t tolerate it. And he’s a real taskmaster in that regard, but I think it really paid off ’cause it was a very big paradigm shift for Microsoft developers to be subjected to the Dave Cutler Digital Equipment style of leadership. Lex Fridman (00:27:55): What did you learn from that about successful software teams, where there’s a large number of people collaborating? Because Microsoft had a lot of brilliant engineers back then, and like you said, Dave Cutler. They had to 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? Dave Plummer (00:28:21): Tools are everything, I think, for one. And people are everything. We’ll grant that. But the tool set is a huge factor. If we went ahead with Git, it would have been immensely easier. We were using Diff and, you know, manual Deltas. …To do this porting and stuff. So being able to fork a branch of source code would be a luxury that is new to me. At the time, it would have been really handy. Lex Fridman (00:28:44): What were some memorable conversations from that time when you walked over next door- Dave Plummer (00:28:49): Well, what… Lex Fridman (00:28:50): … and talked to some of these folks? Dave Plummer (00:28:50): …I was not present for was, somebody was 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, was going to be beautiful, and have a whole new user interface newer than Windows 95, and it never materialized. But while they were working on it, one of the guys working on Cairo was kind of flaming on the open NT dev alias, which is thousands of people, how shitty the NT boot experience was. The response that came back was an epic flame that I wish I would have saved, and I won’t name the guy who wrote it. He knows who he is, but… … 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. So it’s a very similar sentiment. Lex Fridman (00:29:32): Were there, like, kind of intellectual debates, like- Dave Plummer (00:29:35): Oh yeah. Lex Fridman (00:29:35): … there’s some, some heated stuff with the engineers? Dave Plummer (00:29:38): It was… Yeah, it got contentious. So you’ve got intellects competing, and eventually, the technical merits for some people are secondary, and it’s about besting the other person in that argument. And it’s no longer productive at that point half the time, but there was a fair bit of that. Lex Fridman (00:29:53): Yeah, I’ve seen those kind of debates in programming language design communities, like Guido van Rossum, the leaders of those communities, it can wear them down because people get… You almost forget the mission you’re on and start being very nitpicky about the details. I mean, engineering minds get together, and you just go to war over the stupidest, like, syntax subtlety. Dave Plummer (00:30:20): Right. Lex Fridman (00:30:20): Well, I shouldn’t say stupid, but it’s a small syntax subtlety for programming language. I’m sure there are internal battles about specific kernel components. Dave Plummer (00:30:32): Yeah, I mean, there’s one that I lost that still bugs me to this day, I think. Lex Fridman (00:30:35): Okay, yeah. What’s that? Dave Plummer (00:30:38): ‘Cause I still think was right. Well, when we were doing the shell, we were porting everything from ANSI to Unicode, so every character that was eight bits now becomes 16 bits. Now, the problem is I’m on a MIPS box ’cause I’m porting it to RISC…. and you can’t have unaligned addresses. But if you take two ID lists, which are basically past components, you take the one for C colon backslash, take the one for Windows, take the one for System32, and you add them together. But if you’ve got an odd number of characters, now you’re at an odd address in this thing, and it takes me an immense amount of work to turn on exception handlers, to do unaligned byte access, to pull the string out and copy it manually. Dave Plummer (00:31:11): And it’s literally like a hundred to a thousand times the amount of work to read a string out of this ID list on a MIPS machine because it’s unaligned. So I’m having the argument that even though it’s late in the Windows 95, they’ve already shipped one beta, that we should now just guarantee that ID lists are always an even number of bytes, or do some hack to just make sure this never happens so the code that references them on all this hard work can just blaze through it. And it became a shouting match and sort of a personal match and I lost that one. And I still think that, I know today, that that code running on Windows is thousands of times slower than it has to be and it- nobody cares ’cause it’s plenty fast but- …it could be a lot faster. Lex Fridman (00:31:49): Yeah. So yeah, I mean you mentioned MIPS and RISC. How deeply did you have to understand the lowest level? Sort of the lowest level of the software and even the hardware with the stuff you were building. Like what are the layers of the abstractions you had to understand to be successful with all the stuff you’re doing with NT and before that with… Dave Plummer (00:32:12): Well, 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. So it’s not like we’re in Visual Studio, and you hit a breakpoint, and it pops up, and there’s 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. Lex Fridman (00:32:29): So even if you’re programming in C, the debugging is in assembly? Dave Plummer (00:32:33): Yeah, 100%. Lex Fridman (00:32:34): Oh man. Dave Plummer (00:32:35): So it’s a little cumbersome. Lex Fridman (00:32:36): Oh. Dave Plummer (00:32:37): And better yet, we’re doing four instruction sets because we’re doing Intel MIPS, Alpha, and PowerPC. So depending on which machine it crashes on, you’ve got an entirely different instruction set… …That registers. And so you get reasonably adept at debugging all four, but I had more experience in MIPS, so MIPS stuff would come my way. Lex Fridman (00:32:54): That’s a real endurance event. I mean, can you speak to that? The torture there is debugging, especially that kind of debugging without the tooling associated with it. I mean that’s, you know, programming, kids these days, programming isn’t all about creating beautiful things, right? It’s also about fixing things. Dave Plummer (00:33:18): Yeah, I would say that 20% of my professional life has been creating and 80% has been debugging and fixing. And I mean, I got a bit of a reputation as somebody who could fix stuff, and so stuff like that would flow to me, and so I would spend more time doing that. I wasn’t renowned as a creative UI genius where I’m flowering all these new ideas. So I got to fix ugly stuff, but you get really good at that. So 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, and you know, after a day of it, it can get pretty trying. Lex Fridman (00:33:52): Yeah, debugging can be real torture. It can be really, really difficult. There’s a psychological component, I think, of perseverance. Dave Plummer (00:34:00): I think the ones that, you know, take you a day, they resolve one of two 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, and this looks pretty silly for a task manager. So I had tried to resolve it for a long time, and I’d talked to the kernel guys about my issue, and 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’s probably some issue in my code,” right? Dave Plummer (00:34:40): And they’re probably right, but it wasn’t in this case, and I was sure of it, and 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, and finally it never asserted. But occasionally we would get this bug where people would still see it, and so I finally put my phone number in the assert, and I was like, “If you see this message, call DavePL at 425-836,” my phone number. And 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. Dave Plummer (00:35:16): We were able to go through, and it was actually a kernel accounting issue, and it wasn’t a Task Manager issue, so they just fixed it in the kernel once I was able to prove that it was in fact a kernel issue. And you’d think we would then remove my phone number, but we just commented it out, so it’s shipped, and it’s in all the damn source code leaks for NT that are out there, so… Lex Fridman (00:35:32): That’s awesome. Dave Plummer (00:35:32): …that’s how I find Task Manager code. I search for my phone number on Google, and it will reverse-find… Lex Fridman (00:35:37): Oh, yeah, that’s fantastic. Dave Plummer (00:35:38): …the NT source code. Lex Fridman (00:35:39): Can you speak to the assert thing? By the way, I saw, I think you tweeted or you 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. Dave Plummer (00:35:49): A little facetious, because it’s probably not the smartest thing, but… Lex Fridman (00:35:51): No, it’s not. Dave Plummer (00:35:51): …you will find out. Lex Fridman (00:35:52): But I mean, assert by itself is already a serious thing, because it stops all execution. I mean, this is one of the reasons I really, really love asserts, because they stop everything and force you to take care of the problem. Dave Plummer (00:36:07): 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, and I think that’s really the intent of an assertion. So I’m overstating the obvious, but when it does occur, it’s a bug, plain and simple. It’s not a warning. Lex Fridman (00:36:21): It’s kind of fascinating how often it 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. Dave Plummer (00:36:34): Yeah, I tend to… it’s not something I want to suggest you go back and add later. It’s something you should do organically as you build your code. Lex Fridman (00:36:40): As you’re building. Dave Plummer (00:36:40): So for each function, if you’ve got assumptions like, “I know that this pointer is never null,” well, assert that. If you know this count is always less than twice the byte width, assert that. And don’t be afraid, because if it asserts, it’s doing you a favor. I think some people are afraid. You know, it’s like when you turn out of an intersection, and you think maybe there’s somebody coming, and you don’t look left. Or maybe I’m one to do that. But it’s like that. People don’t assert because they’re afraid they’re going to fire. Well, no, you want to know. Lex Fridman (00:37:05): 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? Dave Plummer (00:37:18): So Windows Task Manager is a way to go in and find out which apps on your system are using the computer, using the hardware, using the CPU, using the memory, and which ones might be using too much or locked up or going crazy. And it gives you the ability to terminate and kill those ones. So it’s an inspection and a fixing tool. Lex Fridman (00:37:34): Yeah, it lists all the processes. I mean, it’s a legendary piece of software. It’s crazy. You just take it for granted. It’s like the Start menu, right? It’s like genius. Dave Plummer (00:37:44): Well, 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 that I wanted for myself and eventually came in-house. So I started writing it at home and I got the basics up and running. I was using, I think it’s HKey Current Performance or HKey Performance in the registry to get the stats because I didn’t have access to the internal APIs because I was working from home and I don’t call those if I’m working from home. Dave Plummer (00:38:08): And when I brought it in-house then 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. So 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. I got everything I wanted, but I wanted it to be really robust. And small. And the original was like 87k. Lex Fridman (00:38:35): Okay, can you speak to what it takes to build a piece of software like that that doesn’t freeze? Dave Plummer (00:38:40): You don’t assume much, right? If you’re going to call the shell to run an app, well, that could be a network path that’s on a TCP/IP share that takes 90 seconds to time out. So anytime you do any kind of API call like that, that could take time, you’re going to wind up doing it on a separate thread. And so the app becomes a little more complex because everything is multithreaded. Lex Fridman (00:38:59): Okay, so what programming language were you working in? Dave Plummer (00:39:01): C++. Lex Fridman (00:39:02): So this was for Windows NT? Dave Plummer (00:39:04): Yes. Lex Fridman (00:39:05): Okay. Dave Plummer (00:39:05): So this shipped initially in NT 4.0. Lex Fridman (00:39:07): Okay, so what are some interesting details about this program? Because you have to get it as simple as possible, but also as robust as possible. What are some interesting optimizations, for example, you had to implement? Dave Plummer (00:39:20): There are a couple of things that are a little hardcore now. I’m surprised I did. Like, I didn’t want to link to the C runtimes at all. So I made sure never to call a runtime call and I didn’t link to them, and that saved me whatever the C runtime is, 96k or something. So, it almost doubled the size of the app if you just touched any C call. So I was careful not to do that, but then I was actually writing in C++, which is C with objects more than anything. But 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 runtimes to do it for you. Dave Plummer (00:39:50): So you’re working with a compiler that doesn’t have its runtime, and I don’t want to get off-topic on the technical issues, but it’s a lot of extra work to get it to work, but when you do, it’s incredibly small and tight. Lex Fridman (00:40:00): 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? Dave Plummer (00:40:10): One of the cooler things that I saw is… I don’t want to say I invented Hamming code, but I kind of invented Hamming code without knowing Hamming code existed. So every column and every row in Task Manager has a bit on whether it’s become dirty or not, and then I can look, basically the same way Hamming code looks in your X and Y columns, to find out which rows have changed, go through, and find out which ones actually need to be repainted. So Task Manager is super efficient and it works in concert with the ListView control, which provides that functionality to go through and repaint as little as an individual cell that changes from frame to frame. So it could paint very fast, it can resize very smoothly, and resizing was probably my biggest personal goal with that app. Dave Plummer (00:40:51): So you can size it to any size and it still works and even if you have 32 CPUs, which wasn’t possible in the day, it will draw, I think, only eight graphs and then it wraps but it still works today. So kind of proud of that. Lex Fridman (00:41:06): 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 really basically the same thing. Dave Plummer (00:41:23): The functionality is very same. The reporting is more because they’ve added GPU and thermals and things like that, which is really nice to have. And we didn’t have that ability in the day, so… Lex Fridman (00:41:32): I mean, what can you say? Do you know about, like, was there any refactoring done or is it basically the same code? Dave Plummer (00:41:37): As far as I know, the original code’s still mostly all there so there are layers of drawing code and dark mode code and whatever else, XML, schema code, that goes on top of that that makes it four megabytes instead of 87k but that’s the world we live in, so… Lex Fridman (00:41:51): Yeah, it’s one of those pieces of software you create and just stay once it’s there. It’s just really like the Start menu, and I’m sure if you remove it, people would just lose their mind. Dave Plummer (00:42:02): Yeah, it might be locked in for a while, on that one. It might be good. Lex Fridman (00:42:06): Yeah, I thought that would be true for Clippy, but Clippy will make it back one day. All right, what are some other pieces of software you created at the time that are legendary? So you were part of Space Cadet Pinball, at least porting. Dave Plummer (00:42:22): Yeah, so they came into my office and said, “Hey, what are you doing?” And I told them what I was doing and they said, “Well, how do you want to spend your next three months?” And I said, “I have no idea.” And they said, “Do you want to port Pinball?” And I’d seen Space Cadet Pinball as a game standalone for the Win95 platform and it had a couple 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 can do, for then, high-speed graphics or at least responsive graphics. Dave Plummer (00:42:48): And so I took a shot, and unfortunately, a lot of the code was in Assembly, and I was on a 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 engine, and it’s like a giant switch statement with, if I remember, like 50 entries in it. Dave Plummer (00:43:06): And it’s got an Easter egg built in. And decoding the state, it’s like running a neural network through this thing as you hit it with different states. And I just put it aside and treated it as a black box. So my code runs on top of that and does the drawing and the sound and everything else. But the original game is still running. And somebody recently asked me why it is slightly different; the physics are slightly different from the Windows 95 version, but it should be the same code because I’m trying very hard to preserve that. But what it is, is I had a bug where I will draw as many frames per second as I can, which on a modern computer can be 5,000 frames a second for Pinball because it’s a pretty basic game. Dave Plummer (00:43:45): And so all your physics are interpolated 5,000 times per second instead of 30 times a second, or whatever you would’ve got on the old one. So you’re getting arguably better, or at least different physics, but they fixed that since, so… Lex Fridman (00:43:57): Why is that game so awesome? Dave Plummer (00:43:59): I think it’s a great design. I mean, I take no credit for that. That’s all totally the guys at Cinematronics. But the original game is a great design. It’s very similar to Black Knight 2000, which I own as an actual physical pinball machine. And the layout is actually very similar. I don’t know if it was inspired by it or not. So it’s a good game. Lex Fridman (00:44:15): Yeah. Sometimes I think about Tetris, about certain games with pretty primitive graphics that captivate the excitement of a large number of people. And maybe it’s the excitement of a large number of people that contributes to the awesomeness of the game. So when many people together get excited and talk about it, that sort of gets implanted into your head. But that’s one of the great games. I mean, even like Solitaire and Minesweeper. I mean, there’s just a generation of people that have gone to war in Minesweeper, right? Dave Plummer (00:44:48): Well, those things were included in the OS not as games, but as educational tools to get you to use a mouse. Lex Fridman (00:44:53): Oh, interesting. Dave Plummer (00:44:54): So Solitaire is there to show you how to do drag and drop. And Minesweeper’s probably right-click. I think you put a flag or some item. I’m not a Minesweeper guy, but so each one of them teaches you something. Lex Fridman (00:45:03): Minesweeper guy? That’s funny. Yeah. Wow, I didn’t know that. That’s interesting. And that’s true. But 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. Dave Plummer (00:45:16): I used to volunteer teaching computer science at my kids’ school, you know, 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. But so 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 are probably aged out, they don’t know it anymore, but for a brief period. Lex Fridman (00:45:38): You’re behind the Windows activation. Dave Plummer (00:45:42): You say it like it’s a bad thing. Lex Fridman (00:45:44): Everything’s a matter of perspective. So tell the story of that. What’s Windows activation? How’d you get involved? Dave Plummer (00:45:53): So they came to me late in the XP ship process. I don’t know if the beta had gone out. I don’t think the beta had gone out yet, but they had intended to take the Office activation code and then adapt it to Windows and add activation to Windows. But whoever was responsible for doing it had slipped it enough times that it wasn’t going to happen. So I had kind of 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 don’t know, but I’ll try.” So with the help of the guys that 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. Dave Plummer (00:46:26): And I don’t know what its actual impact is for revenue, but I imagine it’s substantial when you start enforcing license keys. Lex Fridman (00:46:35): I wonder what it is. Dave Plummer (00:46:36): I don’t know. Lex Fridman (00:46:36): Because it’s also annoying. Dave Plummer (00:46:39): It is, especially if you have to phone activate. And 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 hardware key is bound to, as well as the product key, and you’ve got it encoded in letters and numbers that somebody’s willing to read in over a phone. And if you think doing product activation is painful over the phone, could you imagine being the person that worked on the other end of that line? I mean, that’s just got to be a mind-numbing job to listen to product keys for eight hours a day. Lex Fridman (00:47:13): Yeah, one of the challenges with Windows, and it’s been a frustration point for me, but I understand from a design perspective it’s very difficult, is so many different kinds of people use Windows. But it’s been frustrating how over time Windows has more and more leaned into the direction of not the power user, I should say, which is why Linux has always been really wonderful. But from an activation perspective or from any kind of configuration, it’s been a source of a lot of frustration. Dave Plummer (00:47:49): Yeah, one of my more popular episodes of late has been why you can’t move the Windows taskbar. And I had no idea, but the outrage is palpable amongst people that you— Lex Fridman (00:47:56): Yes. Dave Plummer (00:47:57): …just put it on the left or top and you can’t anymore, and it is an affront to their existence. And I understand it to a certain extent. Lex Fridman (00:48:02): Well, it’s one of the main reasons I really just dislike Windows. There’s a lot of aspects about Windows 11 I dislike. One of which is like you can’t customize things as much about the position of the taskbar, just basic customization. Can we just configure stuff? Because there’s going to be a small contingent of power users that are just going to enjoy the hell out of this operating system if you just give them that option. It costs you nothing. Just give them that freedom. Dave Plummer (00:48:28): 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 and lays out the tabs and does all the things, and now it’s a much larger surface for bugs and it’s 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. So 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. Lex Fridman (00:49:04): 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. That 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, and I think Microsoft has more and more moved in that direction with GitHub and acquiring GitHub and just taking care of the developers. But on the Windows interface side, come on, some customization. Lex Fridman (00:50:04): With VS Code, you can customize everything. Why can’t we customize the Start menu, all right? And the taskbar, and really every aspect of the Windows interface. I don’t know, maybe you’re right. Maybe it increases the complexity of the code. I suspect that’s just not the case. Dave Plummer (00:50:24): I bet it was. I bet it was a scheduling decision when they rewrote the Start menu. I think they rewrote it because it’s different than the old taskbar. Dave Plummer (00:50:31): And 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 and two rows of tabs and all the other cool features, I can deliver it four months sooner.” And I’m not saying that’s the right decision, but I’m guessing that might be the kind of thing that motivates it. And they’re on such a different release schedule now. It used to be… You won’t see much craftsmanship unless somebody owns a component for a long time and it settles to a point that then you can work on 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. Although I think the UI is pretty nice, but… Lex Fridman (00:51:06): Yeah, it is nice, but I think it’s a craftsmanship thing. Just like you with the Task Manager, if there’s a guy or a girl in there who takes ownership of it, who has a passionate… 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. Dave Plummer (00:51:33): Right. Lex Fridman (00:51:34): And like, I think if you have large software engineering teams with managers and scheduling of meetings and all this kind of stuff, yeah, okay. Then your argument applies. But if you allow the flourishing of individuals that create cool stuff and their own sort of side project, which Google is very good at. Dave Plummer (00:51:55): They’ve tried that, right? At Google, yeah. Lex Fridman (00:51:56): Yeah, like have fun with it. Like do some crazy stuff and then we’ll integrate it. We’ll try to integrate it into the whole ecosystem. I don’t know. I don’t know, because to me, it’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 the taskbar. And then you know that thousands, tens of thousands of developers might be using to customize even little subtle aspects of the taskbar. You know how much joy you create, you give to people to customize, to have some kind of JSON thing where you customize something about the taskbar? Dave Plummer (00:52:37): Okay, but how do you respond to the Steve Jobs aspect of giving you customization implies that we couldn’t figure out the right answer for you? Or maybe there is no right answer and all four answers are equally right. I have no idea, but… Lex Fridman (00:52:51): Right. I think I’ve always— 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, that’s supposed to be much more open. And they’ve moved towards that direction more and more with Windows Subsystem for Linux. It’s just this whole developer-friendly ecosystem. The interface should be in the spirit of that, I think. 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. Lex Fridman (00:53:30): It’s very difficult to keep it secure. Anyway, taking that tangent, you also developed ZIP file support for Windows, creating Visual ZIP, which eventually evolved into ZIP folders. Tell the story of that. Dave Plummer (00:53:44): So that was a piece of software that I wrote at home again, and what happened was, I was out with my wife, and I think it was a Sunday afternoon. We were driving around. This is 1993, and we’re living in our apartment, and we’re just seeing what the housing market is like out there. And there’s a guy, he’s got this beautiful three-bedroom house and a Corvette convertible, ’93 red, torch red, parked in the driveway, and the house is for sale, and it’s like 300K, I think. And there’s no chance I’m coming up with 300K at that point, or even the down payment on that. So I took the flyer, and I cut the picture of the house out, and I taped it to my monitor. And that was my incentive to just write something at night, because when I came home, I was doing two things. Dave Plummer (00:54:21): I was, one, 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, like, bring up a folder. Well, once I had the very basic bring up a folder template, adding ZIP file support to it was just incremental all the way. And I released it as a shareware product. Dave Plummer (00:54:50): I think it was 19.95 or 29.95, and I sold, whatever, a couple of hundreds or thousands of copies. And one day, I’m getting ready for work, and I get a call, and it’s a lady, and she says, “Are you Dave Plummer?” I said, “Yeah.” She said, “Are you the guy that wrote Visual ZIP?” I said, “Yeah.” And she said, “Well, this is Betsy from Microsoft, and we’d like you to come by and come in and talk about an acquisition of it.” And I said, “Okay, what building are you in?” And she’s like, “What do you mean?” And I said, “Well, I’ll come by.” And she said, “Well, no, you got to talk to travel, and you got to talk to 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— Dave Plummer (00:55:24): …but it was a few minutes of back and forth where we both realized that she didn’t know I worked there. Lex Fridman (00:55:28): Yeah, that’s funny. Dave Plummer (00:55:29): They had just cold-called the author and then found out that it was me. Lex Fridman (00:55:32): Yeah, that’s funny. Dave Plummer (00:55:32): And so they made me an offer on it, and it’s the kind of thing where if I don’t accept the offer, well, now 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 mean, I’d like to keep my job, of course, but I’d like to still— …have this income stream. And the other option was accept their offer, which is what I did. So then I bought a used ’93 red Corvette, and… Lex Fridman (00:55:56): And you got to continue building it internally? Dave Plummer (00:56:00): I did. So we took a lot of features out, right, to simplify, because it had encryption, and it had a number of features that were common in ZIP programs of the day, but probably weren’t appropriate for Windows. And, at the time, encryption was like a munition, so you couldn’t just add encryption willy-nilly to various parts of the operating system, so we took out some things like that. Multi-volume support, I think, was taken out just to simplify it. Lex Fridman (00:56:23): Can you speak to ZIP in general, just the history of ZIP and, you know, compression, that whole thing? Dave Plummer (00:56:29): Yeah, it was really borne out of the BBS era when people were dialing in on modems to download trialware and shareware and other things from BBSs online and to compress them. Executables compressed about half their size. Other stuff compresses much more. But a guy named Phil Katz came up with a command-line program for MS-DOS called PKZIP, which was able to do compression of 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, and so that really drove the desire to have the ZIP support right in Windows. Lex Fridman (00:57:11): Yeah, and that’s another piece of software that’s just kind of with us to this day. Dave Plummer (00:57:15): Mm-hmm. And it could be vastly improved, but, you know, it was written in the single-core days, so it doesn’t do anything multi-threaded. And you’ve got a 96-core 7995, well, it uses one of them to unzip your file. Lex Fridman (00:57:26): What other awesome things were you a part of at Microsoft? What other pieces of software? Dave Plummer (00:57:32): I worked on the initial prototypes of Windows Media Center. So we did— Lex Fridman (00:57:35): Nice. Dave Plummer (00:57:35): …that in ’96, I believe. And we didn’t have, at the time, any sources, so we had like 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, but— it’s all the content we had until we got actually… We had them put a satellite dish on the roof, a DSS, whatever the 18-inch dish is, because we couldn’t get cable to the building. And so we built up this thing that would eventually look a lot like Media Center, and it was distance viewing UI for Windows, so you could sit with a remote control on a desktop and have, you know… The current Start menu is not great at 20 feet away. Lex Fridman (00:58:13): Tell me the story of the infamous blue screen of death. Dave Plummer (00:58:17): What it is is when Windows has no other option, when the kernel gets into a state where something illegal has happened, so let’s say a device driver is trying to write to a piece of memory it doesn’t own or is 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 to save your work. And… Well, not save, but prevent further damage, and it puts up a blue screen and it prints out the stack information, depending how your settings are. Sometimes it’s just a sad face. In the current Windows. Lex Fridman (00:58:46): I wonder what the first version of Windows when the blue screen came to be. Dave Plummer (00:58:51): So, Windows 3 had a blue screen- but it’s completely unrelated to the blue screen in Windows NT. And I talked to the guy who wrote the blue screen in Windows NT. His name’s Jon Viert, and the reason he picked white on blue, I had thought, I’d always heard it was because in the labs, you could walk through a lab where we have 50 PCs all running stressed. “Oh, that one’s got a blue screen. It’s—” “crashed.” It wasn’t that simple. It was just the MIPS firmware that he was building it on was blue on white, and Visual SlickEdit that he was using as an editor was also the same color scheme. And so you could code, boot, crash, and reboot, all in the same color scheme. Lex Fridman (00:59:25): Why do you think so many problems with computers can be solved by turning it off and turning it back on again? Dave Plummer (00:59:34): I think there’s two major things that happen with computers as you run them over time. One is memory gets used and not freed. And so it accumulates on the heap or in the swap file or wherever, and things get sluggish. And the other is, code gets into a state that the developers didn’t anticipate or didn’t test very well. And maybe that’s a rare state, but now that Notepad or Word or Excel is in that state, your system is goofy. So if you just reboot the thing or 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, basically. Lex Fridman (01:00:03): And the intricate ways that several pieces of software in a goofy state interact with each other creates sort of a meta goofy state that just the entire system starts acting a little weird. And then somehow fixes it. What are some of the best and the worst code you’ve seen during that time at Microsoft? What’s some beautiful code and what’s some ugly code that pops to memory? Dave Plummer (01:00:31): In terms of beautiful code, there’s two that stand out for me. One is the kernel in general. When you get down into the Windows kernel- Dave Plummer (01:00:38): …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 a guy named Bob Day, who wrote a named pipe implementation to eliminate the use of shared memory. So Windows 95 had a big shared segment amongst 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 at an industrial level, so he came up with a way to do it with named pipes, and I remember doing a code review on it, and it was very impressive to walk through the code. Dave Plummer (01:01:15): It was one of those things where it was like, “Oh, I don’t think I could have done that if I was trying.” Lex Fridman (01:01:19): Who’s the greatest programmer you’ve ever encountered? Dave Plummer (01:01:22): 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 like six weeks, and I’m working on this OLE Presentation Cache that I’d mentioned earlier. And I’m on Windows 95, and I’ve got Excel inserted into Word, and I’m in the kernel debugger, and something’s going wrong in the scheduler. And I’ve been there, you know, I’ve barely written any x86 code, and I’m looking at the Windows scheduler, trying to figure out why my thing is deadlocked. Dave Plummer (01:01:49): And eventually, I get stuck, so I’m kind of out of my element, and I send an email to the Windows 95 kernel team and say, “Could you send somebody by?” So about 10 minutes later, this developer strolls in, and they’re just holding a null modem cable, which is to connect my two machines together so they can debug one with the other in case I didn’t have it, but it was already set up. And so they sit down, and they’re using WinDbg, which is a horrible debugger. It’s just accursed. Dave Plummer (01:02:10): But they’re very, very competent with it, and they are just blasting through the call stacks, and they’re checking all these objects in the kernel and trying to find out who’s waiting on what and why things are deadlocked, and what things are signaled and what’s not. And it’s just this quicksilver ballet of call stacks flying by, and I’m watching this, and I’m pretty blown away because I’m a good programmer, but this person is an amazing debugger, and I’ve never seen a performance like this. And about five minutes in, I just hear, “Oh, I see.” And then they disconnected and got up and left. And 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… Dave Plummer (01:02:49): So she kind of set my template for, you know, what Microsoft developers were like when they’re debugging and 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, so… Lex Fridman (01:03:02): 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 computer infrastructure. So not the individual computer, but the computers communicating and working together. Those people are just magicians. It’s so inspiring to make… It’s like watching a great carpenter or… Dave Plummer (01:03:28): I love anything done really, really well. Lex Fridman (01:03:30): Yeah, it’s beautiful to see. It’s beautiful to see that humans are able to accomplish that. Even in civil engineering, when I look at bridges, it’s like the number of people that 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. So imagine how many people are impacted by Linux and all the different open-source systems that make up Linux. It’s incredible. And 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, is it billions? Billions have used that. Dave Plummer (01:04:12): Yeah, two billion a month or something. Lex Fridman (01:04:13): Two billion? Dave Plummer (01:04:14): Something like that. I’ve seen the metrics, and it’s up there. Lex Fridman (01:04:16): Oh, crazy to think. Dave Plummer (01:04:18): It is. What I love about it, though, and I’m sure you’ve had this experience, where sometimes you design a piece of software, and it’s complex, and you get it working in your head, and you get the plumbing working, and you know how it’s going to run and flow, and then eventually you write the code, and the code does that thing that you had pictured in your head. And now there are billions of copies of that thing that I had in my head running on billions of people and 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. Lex Fridman (01:04:46): How’s your programming evolved over the years? Dave Plummer (01:04:50): I take a lot more care with complexity these days. So it used to be you would write code and just keep writing code, 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. And so sometimes the work you put in upfront pays off, you know? Lex Fridman (01:05:18): What programming languages have you used over the years? What’s been your main go-tos? Dave Plummer (01:05:22): For me, it’s been C++ and assembly language. Lex Fridman (01:05:25): And still to this day, C++ is really what you lean on? Dave Plummer (01:05:28): Yeah, right now I’m 100% Lua and Python, but that’s just a side project I’m working on. Lex Fridman (01:05:33): Can you speak to the Lua and the Python detour that you took, and what do you love about C++? Dave Plummer (01:05:40): What I’m doing is 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 on. Lex Fridman (01:05:49): Can you take me to this Atari game, Tempest? Okay, Atari Tempest. What kind of game is this? Dave Plummer (01:05:55): So it’s a 3D vector game from 1980. Lex Fridman (01:05:59): Okay. Dave Plummer (01:05:59): And it’s a very complex game. You’ve got full 360 degrees of motion, you have eight shots on the screen, there are like 11 enemies, there are spikes. So it’s a very complex game. It’s not like trying to do Pong or something. And 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. Lex Fridman (01:06:23): So, oh, wow. That’s a very geometric… Okay, what can you explain to me about the gameplay? Dave Plummer (01:06:28): Yeah, that’s me playing the game right there. Lex Fridman (01:06:30): This is literally you playing? Dave Plummer (01:06:31): This is me. Dave is the high score, you’ll see, in the top center there. Lex Fridman (01:06:34): Can you explain to me what I’m looking at? Dave Plummer (01:06:36): 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 towards the outside, and they all have different behaviors. Lex Fridman (01:06:50): Wow. Dave Plummer (01:06:51): So long story short, it’s a fairly complicated game to play well, and I wanted to see if I could get an AI to do it. So 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 and puts them together as parameters, which sends it to the Python side over a socket, and then the Python side does RL learning. I’m using a dueling Deep-Q, and I believe… Two with two head and tail, and they chase each other and 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. Lex Fridman (01:07:27): And you’re the red thing shooting? Dave Plummer (01:07:29): Yes. Lex Fridman (01:07:30): You’re controlling the red thing that’s shooting? Okay. What are the options? You can just move clockwise or counterclockwise and then you could shoot. Dave Plummer (01:07:38): 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. Lex Fridman (01:07:46): 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? Dave Plummer (01:07:51): Because it allows me to encapsulate my favorite C code in classes. I’m not a big- Lex Fridman (01:07:57): You’re really a C guy. Dave Plummer (01:07:58): Well, I actually- Lex Fridman (01:07:58): Okay, I got you. Dave Plummer (01:07:58): Yeah, I’m really a C guy. Although I write two kinds of C++. I write really modern C++ 20 using no pointers, no strings, or no character strings, so there are… you know, it’s basically as safe as Rust as far as I’m concerned. Or I write C with classes, which is standard C, but, you know, with polymorphism and encapsulation. That’s most of what my code is, but I try to do both. Lex Fridman (01:08:23): 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 afterwards, 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- Dave Plummer (01:08:44): Yep. Lex Fridman (01:08:44): … to upgrade. That’s what I saw. What was all that about and what did you learn from that experience? Dave Plummer (01:08:49): That was… Other than, like, family health scares, you know, when kids are sick, that was the scariest time of my life. And the period leading up to it was one of the most invigorating and exciting, because what had happened was while I was at Microsoft, I had written all these shareware utilities and I was selling them on the side and sold one to Microsoft, as we talked about, and they started to do really well. And then I discovered banner advertising online. So I signed up with my credit card for a site, I think it was called Fast Click, and you could say, “I will pay this much for a banner ad impression. Here’s my banner.” And it would rotate it in. And I didn’t set a cap on it. I came back on Monday and I saw I had spent like $10,000 in banner ads. Dave Plummer (01:09:26): 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.” And I looked at the sales and it had made like $38,000 worth of sales. And I was like, “Holy cow. So all I have to do is scale that at some point,” and basically did that for the next several years. And the reason we got in trouble was the AG came in and they had… well, I was blown away because they had like 12 court claims of action and 10 of them were outrageous, which to me as a person with autism, I couldn’t get past. It’s like, I know these 10 things are absolutely not true. Why are we even here talking about them? And then all they care are the two things that might be true. Dave Plummer (01:10:03): And the two things that might be true were that it was a 30-day trial version, and after your 30 days were up, it would then, if you continued to run it and not buy it or uninstall it, it would remind you once a day. Not like every 10 minutes, but once a day or every time you booted your computer, but most once a day. And the AG contended that was too often; it amounted to spam. And so we agreed with them to limit it to once a week, I believe. And, you know, there had to be a button to just uninstall with one click. So we did those kinds of things. The other one was, 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. Dave Plummer (01:10:38): So in the year 2001, which were 2001-2003 we’re talking about, if you bought software, there was an expectation that a disc would show up. And so we made that the default, was to fulfill by disc and 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. Because we found if we didn’t do that, we got all these calls, people would wait, they’d order, two weeks later call, “Where’s my disc?” And we’d look, “Oh, you didn’t order a disc.” “Well, cancel it all. Dave Plummer (01:11:04): I don’t want it because I’m not waiting for it.” And so we got a lot of returns and we didn’t include the disc, and so we decided to include the disc, but that is an a priori violation of negative affirmation billing in Washington State because you’re giving them a default higher purchase price. Lex Fridman (01:11:18): What about the software user relationship? It’s interesting, like, how often to annoy the user with a thing. Right? 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. Dave Plummer (01:11:46): Yeah. And what you don’t want is you don’t want them to have to do it or buy it or do something to get rid of it. Lex Fridman (01:11:51): That’s one of the things that bothers me with… I think Windows does that a little bit still 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. I think now it’s basically required. I think there’s just no way around it. But they make it so difficult to not do that. It’s almost like they think they can just trick me into… It really does feel like I’m getting tricked into not doing what I want to do. Lex Fridman (01:12:32): It’s… I have to, like, think, “Okay, I need to click skip,” and then it’ll do something, “Are you sure?” Like, I have to use too much of my brain to do the thing I need… 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, like… It’s probably effective, sure, for converting people, but it’s really not good long-term for taking care of the interests of the user. Dave Plummer (01:13:06): Yeah, the one that really throws me is the user recommended settings. So I just did a Windows upgrade, I went through the steps, and, you know, I’m going through this new dialog or wizard, and “use recommended settings” sounds like the thing you should do, but I’m pretty sure that resets you to using the Edge browser and… …And all this other stuff. So yeah, recommended by them, but not recommended for me. And that’s the difficulty. Lex Fridman (01:13:25): That’s a really good example. What effect do you think that does in resetting the default browser to Edge? Do you think you’re going to really earn the loyalty of a user if you do that? Don’t you think that there are actually… What you’re going to create… You’re going to create some passive loyalty from some user base, so on the metrics, it might actually look like you’ve increased the number of Edge users, but really, it’s that reputation hit you take over time where it just forms where the Edge is the thing that you can’t quite trust. Unfairly, because I think Edge is a really great browser, but just this unpleasant feeling. I don’t know what that is, and… Dave Plummer (01:14:10): Well, you don’t want your operating system to be an adversary, right? And sometimes Windows can feel adversarial. Like, it doesn’t have your best interests at heart, and that bugs me to a certain extent. Lex Fridman (01:14:20): I mean, we have this feeling, I think we just have general distrust when somebody is super nice to you and is basically selling something. There’s a certain aura about that kind of interaction. And when an operating system is interacting with you in that way, it’s like… Dave Plummer (01:14:36): Yeah, I would much rather pay $199 for Windows Pro per year, or 20 bucks 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, so… Lex Fridman (01:14:47): Did you learn about finding the right balance from that? Dave Plummer (01:14:50): Yeah, I mean, 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 where it had a picture of a Beetle, black and white, and it just said, “Lemon,” and there was a block of text below it. So it’s clickbait-y and then informational, and I always tried to follow that pattern. But there are three 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 make your computer faster utilities. Dave Plummer (01:15:24): And so I always tried to cater to the greed aspect. You know, 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 or get their greed instinct going. So I’d be more sensitive about that kind of thing today. Lex Fridman (01:15:50): Ridiculous question, but what do you think are the top three Windows operating systems? The different versions? Dave Plummer (01:15:59): I’m a fan of Windows 2000 server. That’s Lex Fridman (01:16:02): Really? Okay. … Wait, wait, pl- Dave Plummer (01:16:04): That’s what I ran my business on and I ran my brother’s business. We set up multiple salons all VPNed to one another and using the SQL Server and… Lex Fridman (01:16:11): I don’t know if I ever got to experience Windows 2000 server, so when was XP out? Dave Plummer (01:16:16): 2001. Lex Fridman (01:16:18): What was before XP? Dave Plummer (01:16:20): 2000. Lex Fridman (01:16:21): 2000. Was that good? Dave Plummer (01:16:23): Yeah, I liked it. I mean, 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. Lex Fridman (01:16:29): But then XP was, hmm, I would say probably from a completeness perspective and impact and how long it lasted, it was probably the greatest Windows for consumers, the operating system. Dave Plummer (01:16:44): I would think so. It’s certainly got the longevity for it. There are people who still run it. I mean, I’d still run it on stuff if you could get security updates ’cause it does 98% of what I need Windows to do, but… Lex Fridman (01:16:52): Yeah, that was incredible. I mean, so Windows 95, I’ll probably put Windows XP as the number one for me and then Windows 95 two. Dave Plummer (01:17:01): What’s your metric? Personal preference or industry impact or… Lex Fridman (01:17:05): Industry impact, stability, just there’s certain, like, just like with programming, you have code smell. Just, like, 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. Dave Plummer (01:17:26): Right. Lex Fridman (01:17:27): But not overcomplicated. How often it crashes to blue screen. All of those things. Dave Plummer (01:17:33): I don’t know if it’s a very apt description, but I think of it as crisp. So there’s not a lot of rough edges. It does what it does, does it snappy and… Lex Fridman (01:17:39): 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? Dave Plummer (01:17:50): Well, I’m happy to ruin them for you. Lex Fridman (01:17:52): Okay. Dave Plummer (01:17:52): So- 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. But what happens is, internally, there’s basically a black box mechanism that does nothing more than generate the next random number and what the outcome is in terms of probability and payout. And then the game says, “I’ve got to make up a movie to go along with that.” And maybe it’s three 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 or if you won and then makes something up to fit that scenario. Lex Fridman (01:18:29): That, that indeed is ruining it for everyone. Dave Plummer (01:18:31): A little bit. Lex Fridman (01:18:33): What kind of code runs them? Dave Plummer (01:18:35): 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, and I’m sure it’s not that deep of a secret, but… 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. Lex Fridman (01:18:53): Yeah, it has to be extremely secure, right? Dave Plummer (01:18:56): Yeah. Well, in the 70s or 80s, there was a tech in Vegas who went around and he was burning his own ROMs for the slot machines. With a backdoor in them, so when he serviced the machine, he would just put his ROM in. Lex Fridman (01:19:06): Nice. Dave Plummer (01:19:06): And he’d come back six months later and… Lex Fridman (01:19:07): Nice. Dave Plummer (01:19:08): Invoke the backdoor and… Lex Fridman (01:19:09): I love humans so much. Anyway, do you have other favorite kinds of systems like that? Dave Plummer (01:19:15): I like a lot of old hardware. I restore cars, so I do a lot of 1960s muscle cars, cars and trucks. Lex Fridman (01:19:20): Nice. Dave Plummer (01:19:21): And old computers, so I restore PDP-11s. It’s been my fascination and my special interest for the last six months or so, and I’ve built a number of those. Lex Fridman (01:19:30): Yeah, I’ve seen you posting videos about it, the PDP-11/83. What’s that whole project? Dave Plummer (01:19:40): So basically, what it is, is I had built a number of PDP-11s. And so over the years, I had acquired all these parts and I decided, “Well, let me build the best PDP-11 that I can.” And so it was kind of a quest to, just like you try to max out a PC, I tried to max out a PDP-11. So it’s got four megabytes of memory, which would be massive in the day. And yeah, that’s it there. And it’s got lots of blinking lights, and I had to rewrite the BSD kernel to make the lights work and… Lex Fridman (01:20:05): What are we looking at here? What’s… Dave Plummer (01:20:09): So the very top is a PDP-11/70 control panel, which we can largely ignore, and then there’s two chassis below that. One has- Lex Fridman (01:20:15): What are the different knobs? Sorry to ask dumb questions here. Dave Plummer (01:20:18): The knobs, they, uh- … control what view you get of the LEDs. Lex Fridman (01:20:22): Oh. Dave Plummer (01:20:22): So normally, you see the data bus and you can see the address bus. And you can pause the machine, you can edit the add- address on the bus, and you can deposit stuff into memory with the switches. Lex Fridman (01:20:32): Man, the haptic plus the LEDs. That’s what you imagine a computer to be. Dave Plummer (01:20:39): Yeah. Lex Fridman (01:20:39): That’s so cool. That’s so cool. And then these are what? What are these? These are DU1, DU2? Dave Plummer (01:20:45): Yeah. It’s a weird floppy drive. It’s a dual floppy drive with one stepper motor. So both heads seek together like Siamese twins. Lex Fridman (01:20:52): Okay. So what, what kind of stuff are you doing with this? What are you- … are you trying to restore them? Dave Plummer (01:20:57): Yeah. So I restore them and- Lex Fridman (01:20:58): Does it actually run? Oh, all the blinking lights are real? Dave Plummer (01:21:01): Yeah, it’s all real. Lex Fridman (01:21:03): Wow. Dave Plummer (01:21:04): 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 to get… ‘Cause 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. It’s time to build the kernel, so you gotta go find the source and find the code and… Lex Fridman (01:21:20): And you can run code on this? You’ve written a couple books on autism. Being autistic yourself, I was wondering if you could tell me about, like, fundamental differences about the mind of a person with autism versus a, let’s say, a neurotypical individual. Dave Plummer (01:21:34): Well, the fundamental theory of thought for autism is called monotropism. And basically what that means is that my brain does one 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. And that’s probably one to two percent of the population. Lex Fridman (01:22:08): What’s the biggest benefit of life with autism? Dave Plummer (01:22:11): I can bring to bear an incredible amount of focus and dedication on a particular task. It has to be something I love, it has to be something that’s rewarding, it has to be something I can make progress on, and there have to be all these things that are true about it. And it could be like a kid playing with trains. I get that same feeling. Lex Fridman (01:22:28): That said, you also said that you struggle with ADHD. Dave Plummer (01:22:33): Yeah, a fair bit. Lex Fridman (01:22:33): So that’s part of the component, like, maintaining the focus? Dave Plummer (01:22:38): Actually, acquiring the focus is the issue. So 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. Lex Fridman (01:22:52): Oh, that’s fascinating. Dave Plummer (01:22:53): It’s hard to get into that state. Lex Fridman (01:22:54): Okay. What’s the biggest challenge of life with an autistic mind? Dave Plummer (01:22:58): That I don’t know what anybody else is thinking. So 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 ’cause he’s acting this way and his reactions are this and his facial expressions say this and…” That’s all kind of lost on me. So I run a little proxy NPC game for everybody I deal with. Lex Fridman (01:23:20): So I guess that makes social interaction a little bit complicated. Dave Plummer (01:23:22): It can be, yeah. Telephone is especially hard because I rely on a lot of other cues, and 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. And so I’m much better on FaceTime, where if somebody makes a joke, they might smile after- Whereas on the phone, I don’t know if you’re being sarcastic or serious and that kind of thing, so… Lex Fridman (01:23:42): So that’s probably gotten you into trouble over the years a bit. Dave Plummer (01:23:45): Yeah. There’s lots of times with my wife, too, where… Well, there’s a certain literalism that comes with autism. And we spent years where she would say something and I’d say, “But that doesn’t make sense.” She’d 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. And I remember we’ve been in meetings with people, and you know, if there’s three or four people in the meeting and I’m the only autistic person, I’ll tell them that they’ve got this communication loop going on and I have to… You gotta tell me what’s going on because I really don’t know what’s being said here. So… Lex Fridman (01:24:19): You told me related to this that there was an early, somewhat awkward encounter with Bill Gates. Can you share the story of that interaction and how autism comes into play here? Dave Plummer (01:24:32): Yeah. 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, that got hired that year over to his house for burgers and beers and just chat in the backyard. And of course, it’s still Bill Gates, and he’s a big enough deal even then that you’re a little nervous. And so my manager, Ben, who was sort of my mentor at the time, took me over to introduce me to Bill because he knew him. And he’s explaining, “This is Dave. He’s our intern from Canada. And in the space of four months, he’s done this feature and just copy and smart drive,” and he listed off all the stuff I was doing. Dave Plummer (01:25:05): But I stopped because I’m like, “Well, actually, it was three months.” And I had to interrupt them, and they both kind of, “What?” And they looked at each other, and I realized that was the wrong time to… …Correct a guy. But… Lex Fridman (01:25:17): Yeah. So you, like, little inaccuracies? Dave Plummer (01:25:20): Oh, drive me crazy. Lex Fridman (01:25:22): And then you, of course you don’t… The impact that might have on a casual social interaction, it’s not trivial for you to be aware of that. Dave Plummer (01:25:38): Yeah. I’m much better than I used to be. Before, I didn’t know and 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, but… Lex Fridman (01:25:49): What advice would you have for folks who have an autistic mind on how to flourish in this world? Dave Plummer (01:25:56): In terms of prosperity and finances, the biggest thing I can say is sell what you can do and not yourself. Because if you go into a job interview and you 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, and here’s the actual algorithm I wrote, and this is what I do,” I think you get a lot further with that. So, whether you’re playing the piano or writing code. Lex Fridman (01:26:21): That said, so much of software engineering on large teams has a social component to it, right? Dave Plummer (01:26:29): It does, and that was a liability for me. Lex Fridman (01:26:31): How do you… I mean, what have you learned about how to solve that little puzzle? Dave Plummer (01:26:36): 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 and led and encouraged and compensated exactly as I would. And 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. And so eventually I had to learn that everybody that you’re managing has their own set of incentives and priorities, and they’re completely different from what I think they probably are. Lex Fridman (01:27:11): So you could, I guess, make things more explicit and just communicate better about, like, ask them about what their interests are. Dave Plummer (01:27:19): Yeah. And that’s something I started doing, is overtly asking. Because it’s hard for me to nudge somebody there. I’m not good with that kind of social dance, so… Lex Fridman (01:27:27): Yeah, part of the social dance is there’s a lot of stuff that’s unsaid. You can kind of figure out… You can read people. But if that’s… With autism, it might be a little bit difficult to do that, and so you have to make things more explicit. Plus, like, sarcasm and satire and humor might be difficult. I would love to be a fly on the wall in some of your earlier interactions with Microsoft. I mean, some of the greatest engineers have a mind like this, so… Dave Plummer (01:27:58): Yeah, I’ve had laptops thrown at me and stuff, and I’m sure it was my own fault, so… Lex Fridman (01:28:01): You write about the 10-second autism test. Could you explain how this works? Dave Plummer (01:28:05): Yeah. Now, there is, of course… Anything that has two answers has a high error rate, but… So what’s more important to society as a whole from the people, is it cooperation or creativity? And if you had to pick one, which is the most important? And most neurotypical people will generally lean towards cooperation, whereas people on the spectrum tend to lean towards creativity as individual problem-solvers. Lex Fridman (01:28:26): Of course, there’s some kind of error rate there. Dave Plummer (01:28:28): So if you want to double your precision, you can use a second test, which is you ask, “There’s a room with 10 chairs, and six people come in and sit down in those chairs. How many chairs are left?” Now, some people are going to say four, but I’m going to say 10, because that’s how many chairs are still there. Literally true. And I’m not being a dick. Lex Fridman (01:28:46): Yeah, okay. Dave Plummer (01:28:46): I’m not trying to be complicated, but that is how my mind works. And so when I see that question, it’s like it depends how you answer it. Lex Fridman (01:28:53): So you’re how literally you take things? Dave Plummer (01:28:57): 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. And 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?” And he says, “It’ll be big enough to hold a horse.” And I was only five, but I was very confused about, A, 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. But for a lot of my life, I took figures of speech as literal, so… Lex Fridman (01:29:26): You’ve mentioned emotional post-processing as a strategy you use to replace social interactions so you can sort of reverse engineer 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? Dave Plummer (01:29:43): So if I meet somebody, particularly somebody new, and it’s my first couple interactions with them, so even meeting you today, then I will go home later and replay all of the moments where I had choices to make. And 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, and do I need to go fix it or make a phone call, that kind of thing in a bad… you know, in an extreme case. But… And that’s happened a couple times in my life. Like, I had a car restored that my dad had bought new in ’69. I still have it, so we’ve had it 50 years. Dave Plummer (01:30:18): About 20 years ago, I had it restored, and it was a three-year process of craftsmen working on this car for thousands of hours. I go out to pick it up and I’m inspecting the car and I’m very impressed with the work, and I’m saying, “Oh, this is nice and this is great,” and everything else. Then I fly home and write the check and the car gets delivered. And then I realized probably 10 years later that I had a whole bunch of craftsmen that had worked on my car for three 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 that. Dave Plummer (01:30:51): So I sent an email to the manager, or to 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 and the quality and everything else.” And he wrote back. He’s like, “I’ve thought of that moment often.” (laughs) So I’m like, “Now I’m glad I brought it up.” Lex Fridman (01:31:08): Yeah, there’s subtle things about human interaction that mean a lot to people, and if you ask them straight up, they might not be able to articulate that, but it means a lot. And when it’s off, when something is off, it bothers them. Dave Plummer (01:31:22): Right. Lex Fridman (01:31:22): But to reverse engineer that, to figure that out for a person who might not sense those little subtleties of human interaction is tough. Dave Plummer (01:31:32): 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, whereas I don’t know how you’re feeling, so it’s hard for me to be empathetic with it until you communicate to me what it is you’re experiencing. And then once I know, 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. Lex Fridman (01:32:06): What advice would you give to people on the other side? How can they help you be a better friend or partner or colleague? How should they communicate with you to help, like, give more information? Dave Plummer (01:32:18): Yeah. Be really specific. And don’t assume I’m going to pick up on clues and nuance and subtlety. So 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.” Lex Fridman (01:32:31): Have I failed in any way today? Dave Plummer (01:32:32): No, not yet. Lex Fridman (01:32:33): All right. What score would you give me out of one to ten? Am I a six? A seven? Dave Plummer (01:32:43): 7.5. Lex Fridman (01:32:43): Communication? 7.5? (laughs) Floating point. Nice. Masking. You 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. Dave Plummer (01:33:00): So masking is, and it’s probably not the right way to describe it, but it’s the act of acting normal. And that is, how do I conduct myself in a social situation in a way that other neurotypical people are going to receive and accept it the right way? And everything you do in a social interaction, from waving my hands to making facial expressions to tone of voice to posture, it’s a huge contrivance and it’s work. So it comes natural 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. Lex Fridman (01:33:41): Yeah. Acting normal. Dave Plummer (01:33:44): There’s a song by Rush, you know the band? Limelight. And 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.” And 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 was what I took from it. Lex Fridman (01:34:13): You described meltdowns as an overwhelming experience. Can you describe meltdowns? What typically triggers a meltdown? Dave Plummer (01:34:22): Generally, it is… it’s when you’re emotionally overwhelmed to the point that you can’t manage your behavior anymore. So 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. Or I’ve seen it on… They did kind of a… Well, actually, probably the best portrayal I’ve seen in media is… What’s the TV show where the doctor is autistic? He’s… Anyway, there’s a TV show where a doctor’s autistic and he’s a surgeon and he is eventually banned from surgery because of his autism, and he’s always wanted to be a surgeon and he has a complete meltdown, and it’s a pretty good portrayal on television. Lex Fridman (01:34:56): What is actually happening? Like, there’s a threshold you cross that it’s just like… Dave Plummer (01:35:00): Yeah. The switch flips. Lex Fridman (01:35:01): It’s like a blue screen essentially- Dave Plummer (01:35:05): Yeah. Kind of. Lex Fridman (01:35:05): … for the brain algorithm? Dave Plummer (01:35:07): So the switch flips. You go to 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 a very reptilian brain in that state. And it’s really a panic state. And so it’s a panic and a fight or flight response to not being able to tolerate the current reality. And perhaps it’s been so frustrating or you’ve been so randomized or you 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. Lex Fridman (01:35:41): What about love and relationships? What are some of the challenges of that and… You know, there’s a show, Love on the Spectrum. Dave Plummer (01:35:47): I’ve heard of it. I’ve not seen it, but I’ve heard of it. Lex Fridman (01:35:49): Because certain aspects, like literal interpretation of things, it just makes the complexity of romantic relationships even more explicit in that context. Dave Plummer (01:36:01): You know, I’ve been married 31 years and together for 37, so a long history there, and I think our first indication that we knew we were very different was we were sitting in the car one night out front of the house at dark and across the street there’s kind of a nice house, and it has these big brick pillars that are linked by, like, anchor chains and it forms a fence around the yard. And I’m looking at these things ’cause they’re about two feet square and they got capstone and I’m like, “You know, I wonder if they’re hollow or are they backfilled?” Are they filled with concrete or what?” And 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?” Lex Fridman (01:36:36): Yeah. That’s great. Dave Plummer (01:36:37): And we just knew in the moment that I was passionately involved and caring, and she was passionately involved, and why would you even worry about that kind of thing? We knew we were very different. Lex Fridman (01:36:47): Yeah. Very specific, seemingly irrelevant details. Dave Plummer (01:36:51): But- …I was never good with people. I don’t get it when people like me, I guess. And so my son is the same way, because they don’t fall very far from the tree. I got them a T-shirt that says, “If you’re hitting on me, please let me know and be specific, because I’m clueless.” And it’s very similar for me. I mean, I had to be around a long time and kind of grow on people because I had no game, I had no ability to do the social dances that that whole thing requires. So my only option is to just be myself, and that works for some people. Lex Fridman (01:37:21): Were you able to say, like, “I love you,” that kind of stuff? Dave Plummer (01:37:26): Yeah. I mean, her family was way more open with that kind of thing than mine was. So it was a growing period for me. But, yeah, that’s not a problem I have. Lex Fridman (01:37:33): Okay. All right. But it seems unimportant. Like, what is that actually accomplishing? Dave Plummer (01:37:41): Well, now we do a lot of affirmation and checking. In the last couple of years, we do a thing where she’ll just be like, “You good?” I’m like, “Yeah.” And there’s two 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. Lex Fridman (01:37:55): Yeah. So, Dave Plummer (01:37:55): And 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, so we have this explicit check mechanism, I think, where we develop that. Lex Fridman (01:38:05): 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, quote, “a little bit autistic.” Could you elaborate on this concept? Dave Plummer (01:38:25): Yeah, I think a lot of people, maybe 10 to 20% of the population, is somewhere on the autism spectrum, but isn’t impacted by it enough that it rises to the level of a disorder. But they still have many of the characteristics that arise from autism. And I think if they can understand and identify and manage some of those behaviors in an optimal way, they can both leverage them and take advantage of some of the skills and mediate some of the deficits and problems that come with it. And 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. Lex Fridman (01:39:02): Hmm. Why do you think so many programmers, like excellent, great programmers and great engineers, are on the spectrum? Dave Plummer (01:39:08): 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 gotta take my mom’s oven apart because I gotta know how the flip clock works. And I think that’s a good habit to have if you’re gonna be a programmer. Lex Fridman (01:39:26): And being willing, being excited to get into the details. Yeah. What’s a cool thing you hope to program to build this year? What are you working on? So we got the RL learning how to play Tempest. Where are you on that, by the way? Like, what’s the ETA on success and dominance? Like victory? Dave Plummer (01:39:47): 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 one threshold. But, you know, it’s a couple thousand lines of Lua and it’s a couple thousand lines of Python, and they all interact and they all work, so it’s like 95% of the work is done now. It’s tuning hyperparameters and hoping for the best. Lex Fridman (01:40:04): So it’s already a success in a sense, but now you’re seeing how far can this go? Dave Plummer (01:40:08): Yeah, my goal was to be able to beat me. Lex Fridman (01:40:11): That’s tough for. Dave Plummer (01:40:13): It is, but lots of games now are, you know, they play them better than humans, but maybe not games this complex. Lex Fridman (01:40:19): What other cool things are you working on? What do you hope to build this year? Dave Plummer (01:40:22): 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 3600 rpm and sounds like a washing machine. And then I’ll find the controller card and write the code and integrate it into the driver and try to get that all working. Lex Fridman (01:40:35): What kind of code are you trying to run on it? Dave Plummer (01:40:38): I’m going to have to get the driver stack to work, so I have to incorporate the driver for it into the kernel. Lex Fridman (01:40:43): You built a machine recently with one terabyte of RAM. How did that happen and why? Dave Plummer (01:40:52): We have a project called GitHub Primes. If you just search for GitHub Primes, you’ll find it, and it is… Lex Fridman (01:40:57): GitHub Primes. Dave Plummer (01:40:57): …a single set of prime number algorithms implemented in about 100 different languages. So 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, and we compile the results and find out which languages are fastest. Lex Fridman (01:41:16): Is this the one? Oh, so this is it. You’re using this for? Oh, so- Dave Plummer (01:41:25): So- Lex Fridman (01:41:25): This machine runs those tests? Okay, you’ve got to tell me about this project. This is an epic project. So you’re comparing the performance of the different programming languages. Dave Plummer (01:41:34): Of all these languages. So they all get built into an individual Docker container, and then they all run. And so- Lex Fridman (01:41:38): This is an incredible project. This is really, really cool. It’s really measuring the performance of the different languages. So what have you learned about which languages? Which language usually wins? Dave Plummer (01:41:51): Zig, I think right now. Lex Fridman (01:41:52): Zig. Dave Plummer (01:41:52): It does, it varies. People will make an improvement to the C++ then it’ll pass for a while, and then the Zig guys will get angry and come back and make it faster. Lex Fridman (01:41:59): So Zig, Rust, C++, C? And what kind of code is being run? What’s the piece of code that they’re trying to run to measure the performance? Dave Plummer (01:42:10): So what they’re doing is they’re solving the primes up to 100 million as many times per second as they can in a five-second loop. Lex Fridman (01:42:17): And so it’s a loop, got it. Over and over and over and over and over again. Dave Plummer (01:42:19): Yeah, on all cores. Lex Fridman (01:42:21): So what- Dave Plummer (01:42:21): Across all CPUs. Lex Fridman (01:42:22): What about, like, how the program is written? Does that vary? Dave Plummer (01:42:25): No. So you can do anything you want, but it has to be a prime sieve. You’re allowed to use one 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 that you have to allocate the memory within your timed loop. And so we have a set of rules and we have some solutions that don’t follow the rules like the 6502 because you’ve only got 64K, you can’t do 100 million sieve. So there’s a lot of solutions like that that we run as exhibition projects, but among the main languages, they all follow the same rules, and so it really should just be the how the algorithm is expressed in that language. And many of them use the same backend compiler, so it really is how you’re expressing it and the limitations or the benefits of that language. Lex Fridman (01:43:04): They’re allowed to be multiple submissions per language? Dave Plummer (01:43:07): Yeah, yeah. So if you look in the C, there’s like five, I think. Lex Fridman (01:43:10): Okay. And then they, some of them might use different compilers, or no? Dave Plummer (01:43:14): Yeah, some are GCC, some are Clang, LLVM. Lex Fridman (01:43:17): I’m looking at a snapshot here from a couple years ago, Zig was at the top, then Rust, then Nim, Haskell. Oh, no, this is not, this is not ordered by slowness, or is it? It is. Dave Plummer (01:43:28): So C would be 1.5 times as long as Zig. Lex Fridman (01:43:31): Wow. Okay. Fascinating. Well, it’s a super cool project. Dave Plummer (01:43:36): And we’ve got in crazy languages like PowerShell. There’s a version in PowerShell, and stuff like that. Lex Fridman (01:43:41): So this is automated, like in terms of organization of like how the submissions are done, there’s a structure to it? That’s cool. Dave Plummer (01:43:47): Yeah, there’s two guys over in Europe Rucker and Tudor basically own this now. I started as just three languages, I did Python, C#, and C++. And I checked them in and I published the episode, and then people started throwing more solutions in there and it just got out of hand, so I had to get somebody to manage that one and they’ve been great doing that for me. Lex Fridman (01:44:05): What’s the happiest moment for you when you’re programming and building a thing? Like, what do you enjoy most? Dave Plummer (01:44:11): I think the most fun for me is when I build something complex, and I’ve thought through how it should work, and then I run it and it does work that way. That creates intense satisfaction. So seeing the results come out the way that I planned them and have it work, because it rarely does the first time, but… Lex Fridman (01:44:28): Yeah. Or especially if it does work the first time. Dave Plummer (01:44:31): I never trust that. I always feel like I’m missing something. Lex Fridman (01:44:33): That’s true. But, you know, with compiled languages like C++, that’s always a good feeling. You write a bunch of code, and you compile it all, it compiles without warnings, without errors. It’s a cool feeling. What do you think is the future of programming? So now, I don’t know how much you’ve got to really experience the impact of LLMs with code generation. Have you used Cursor much, Cursor VSCode with code generation? Dave Plummer (01:45:05): 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. So I found it very helpful because I’ve learned a lot from watching the code that it generates if I don’t know how to do something. Because if I were to write Python from scratch, it’s going to be about four times as long as what the AI can crank out because Python can be pretty terse if you’re good at it. Lex Fridman (01:45:23): Oh, that’s cool. So you essentially learned Python for this project? Dave Plummer (01:45:27): Yeah. Lex Fridman (01:45:29): So this is a good case study of a great programmer in C++ quickly learning a language. Dave Plummer (01:45:36): Yeah, I’m vibe coding my way through it, I guess. Lex Fridman (01:45:38): Vibe coding your way through it. I mean, that is a really powerful use case to learn a language for. If you’re already a good programmer, to learn either a new language or a new way to approach a problem by having it generate it because you already you probably understand the Python code it generates. Dave Plummer (01:45:55): Yeah. Lex Fridman (01:45:56): Like without actually looking up any of the syntax. Dave Plummer (01:45:58): Yeah, it’s all pretty self-explanatory once you see it but, you know, creating it from whole cloth is a little different, so. Lex Fridman (01:46:03): Yeah, but you still have to learn how to program in order to use it in that way. Dave Plummer (01:46:08): Oh, and to read it and to know what to tell it to do next and all that, yeah. I don’t think you can vibe code yourself if you’re just new and haven’t coded but if you’re a good programmer, AI can make you incredibly powerful. Lex Fridman (01:46:19): What do you think is the future of programming, like 5, 10, 20 years from now, this whole process? Now, vibe coding is kind of a fun meme thing because you still have to be… The people that don’t know how to program and are just vibe coding are almost entirely creating systems that are not usable in production. They’re not… It’s very difficult- Lex Fridman (01:46:38): It’s very difficult to create a product. And the people who are already great programmers kind of vibe code just for… in the way that you’re doing it. They’re basically… it’s just a fancy autocomplete, and they end up editing it, or it’s a way to learn a new API, or new language, or a new whatever, a new specific use case, or maybe a different kind of gooey component or something like that. But as they get smarter and smarter, we don’t know where the ceiling is. That might change the nature of what it means to be a programmer. So do you think about that? Dave Plummer (01:47:12): I do. I don’t want to say prompt engineer, but I think it’s going to be something like that in the sense that if you’re an architect building a bridge, at some point, guys were down there welding beams together, but now you’re dragging things around in AutoCAD and assembling from big pre-formed sections. And 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 and 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 whole cloth generate… 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. Lex Fridman (01:47:51): Does it make you sad that we’re climbing the layers of abstraction so quickly so you, somebody that used to do machine code and then assembly, then C and C++, that we’re getting to a point where we’re vibe coding with natural language? Dave Plummer (01:48:07): Yeah, I kind of came up at a really fortunate time, I think, because I had to come up with the technology over the course of 30 or 40 years, so I understand TTL logic, and I can use AI to write code, and I kind of know all the pieces in between. There certainly are holes in my knowledge, but I think the only way to have got that level of knowledge or the completeness of that picture is to have lived it for that long. And it’s going to be hard to duplicate that for people starting now. Lex Fridman (01:48:32): What do you think is the meaning of this whole thing? Of existence of life, whatever is going on here? Dave Plummer (01:48:44): Making cool stuff. I guess, fundamentally, what I care about is being able to make complex things that are useful to other people, which leverages my abilities in a way that allows me to be creative and to create things that other people can use in a way that if I was limited to painting or sculpting or whatever in the classic arts, I would be hopeless. And so for me, that’s really the meaning of life, and then maybe you raise a couple of good kids to hand the baton off to. Lex Fridman (01:49:14): Yeah, and you’ve created a lot of cool stuff over your life that impacted millions, probably billions of people, and now you’re inspiring… You’re creating cool stuff for everyone to see on your YouTube, and you’re inspiring people in that way. 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- Dave Plummer (01:49:40): Great. Lex Fridman (01:49:40): … you’re doing and grateful that we got a chance to talk today. Thank you, brother. Dave Plummer (01:49:44): Thank you. Lex Fridman (01:49:46): 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.

本集資源與出處