Barbara Liskov (Turing Award): The Story Behind The Liskov Substitution Principle

Ryan Peterman

AI-assisted summary of Barbara Liskov (Turing Award): The Story Behind The Liskov Substitution Principle — original source. Check the original for full context.

Source published: 2026-10-28

Key ideas

Barbara Liskov entered distributed computing after reading Bob Kahn's early vision of multi-node network programs, leading her to develop the Argus programming language and Viewstamped Replication. (0:00)
Viewstamped Replication and Leslie Lamport's Paxos independently derived the exact same core consensus protocol, with Viewstamped Replication tracking states via logical view numbers instead of physical wall clocks. (2:51)
The Liskov Substitution Principle emerged from Liskov's preparation for her 1986 OOPSLA keynote, where she addressed type hierarchy confusion by requiring subclasses to conform strictly to superclass observable specifications. (4:00)
Liskov only learned that her keynote insight had been christened the 'Liskov Substitution Principle' years later during the 1990s through an unexpected email inquiry. (4:00)

Detailed notes

## Background Published on YouTube by Ryan Peterman on October 28, 2026, this video features an interview clip with Turing Award winner Barbara Liskov. According to the description, the conversation explores the defining breakthroughs of her career in programming languages and distributed systems, alongside historical anecdotes from her time in computer science.

## TL;DR Liskov recounts entering distributed computing by creating Argus and developing Viewstamped Replication, a consensus protocol independently discovered alongside Leslie Lamport's Paxos that later underpinned architectures like the Google File System. She explains how the protocol leveraged view numbers instead of system clocks to maintain state across failures. The discussion then turns to the origin of the Liskov Substitution Principle, which emerged from her 1986 OOPSLA keynote where she defined type hierarchies through behavioral specification rather than code inheritance, a concept she only learned had been named after her years later via email.

## Atmosphere & style The conversation is calm, reflective, and deeply engaging, presenting foundational computer science history with remarkable modesty and matter-of-fact clarity. Liskov discusses revolutionary technical contributions without pretension, framing massive breakthroughs simply as natural, practical responses to interesting puzzles. The rapport between Peterman and Liskov feels casual yet respectful, accented by dry humor when contrasting marketing versus implementation in academic consensus protocols and recounting her surprise at finding an eponymous principle in her inbox.

## Bulletin - [00:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=0s) Barbara Liskov entered distributed computing after reading Bob Kahn's early vision of multi-node network programs, leading her to develop the Argus programming language and Viewstamped Replication. - [02:51](https://www.youtube.com/watch?v=tZe5U9heYYI&t=171s) Viewstamped Replication and Leslie Lamport's Paxos independently derived the exact same core consensus protocol, with Viewstamped Replication tracking states via logical view numbers instead of physical wall clocks. - [04:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=240s) The Liskov Substitution Principle emerged from Liskov's preparation for her 1986 OOPSLA keynote, where she addressed type hierarchy confusion by requiring subclasses to conform strictly to superclass observable specifications. - [04:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=240s) Liskov only learned that her keynote insight had been christened the 'Liskov Substitution Principle' years later during the 1990s through an unexpected email inquiry.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=0s) Barbara Liskov's foray into distributed computing was inspired by Bob Kahn's early vision of programs composed across networked machines. - [00:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=0s) Liskov created Argus, an object-oriented language utilizing local 'guardians' that communicated across networks via remote procedure calls. - [00:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=0s) Argus adapted database atomic transactions into programming semantics to maintain cross-node consistency. - [00:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=0s) Viewstamped Replication served as an early intellectual precursor to cloud storage by ensuring data accessibility across quorums. - [00:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=0s) Viewstamped Replication does not depend on synchronized physical clocks, relying instead on monotonically incremented view numbers. - [02:51](https://www.youtube.com/watch?v=tZe5U9heYYI&t=171s) Viewstamped Replication and Leslie Lamport's Paxos were developed independently and share the same underlying consensus architecture. - [02:51](https://www.youtube.com/watch?v=tZe5U9heYYI&t=171s) The Google File System was an early major real-world deployment exemplifying this consensus model. - [02:51](https://www.youtube.com/watch?v=tZe5U9heYYI&t=171s) Paxos achieved broader public recognition largely due to Lamport's extensive touring and its memorable name. - [04:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=240s) During the 1970s and 1980s, research communities around CLU, Smalltalk, and Alphard worked largely in parallel silos due to early ARPANET constraints. - [04:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=240s) The object-oriented community in the mid-1980s struggled to formalize type hierarchies and relied heavily on implementation inheritance. - [04:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=240s) Liskov's pedagogical work with John Guttag at MIT emphasized formal specification and reasoning about meaning before implementation. - [04:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=240s) The core insight of the Liskov Substitution Principle requires that a subtype must preserve the expected behavior of its supertype in all contexts. - [04:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=240s) Liskov and Jeannette Wing later formalized behavioral subtyping mathematically. - [04:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=240s) Liskov did not coin the phrase 'Liskov Substitution Principle' and discovered the naming years after her OOPSLA keynote.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=0s) Entering Distributed Computing: Argus and Viewstamped Replication

Barbara Liskov’s transition into distributed computing was sparked by reading a paper by Bob Kahn, who, alongside Vint Cerf, is widely considered one of the founders of the internet. Kahn described a vision of distributed computing where a single program was composed of multiple pieces residing on different computers connected over a network. At the time, nobody actually knew how to write or architect such programs, which immediately caught Liskov’s attention: “And nobody knew how to build those programs. And so I just thought, great problem.” Looking for a fresh challenge, she jumped directly into the space, beginning with the creation of a programming language tailored specifically for writing distributed systems.

That language was Argus, heavily influenced by her earlier work on CLU. Argus was an object-oriented language built around a core abstraction called a “guardian”—a specialized module that resided entirely on an individual machine. Guardians communicated across the network via remote procedure calls (RPC). A major technical hurdle was ensuring that computations spanning multiple guardians across different nodes maintained consistency: in the end, an operation needed to complete in its entirety or leave no side effects whatsoever. To solve this, Liskov adapted the database concept of atomic transactions into programming language semantics, running computations as distributed atomic transactions across nodes.

```mermaid flowchart TD accTitle: Argus Distributed Architecture accDescr: Diagram showing guardian modules on separate network nodes communicating via RPC inside atomic transactions. subgraph NodeA["Network Node A"] G1["Guardian 1<br>(Local Module)"] end subgraph NodeB["Network Node B"] G2["Guardian 2<br>(Local Module)"] end subgraph NodeC["Network Node C"] G3["Guardian 3<br>(Local Module)"] end G1 <-->|"Remote Procedure Call (RPC)"| G2 G2 <-->|"Remote Procedure Call (RPC)"| G3 G1 <-->|"Atomic Transaction Scope"| G3 ```

This research led directly into her work on Viewstamped Replication, which Liskov identifies as the intellectual precursor to modern cloud storage. Although she initially conceptualized it in the framework of a distributed file system, the core goal was ensuring data distributed across multiple internet sites behaved correctly and remained accessible as long as a quorum of nodes remained online and the network functioned. When asked how Viewstamped Replication handles unsynchronized system clocks, Liskov clarifies that the mechanism does not rely on real-world time at all: “Uh it had nothing to do with clocks because it was just numbers. In other words, we were in view 25, the next view was 26.” The view numbers simply increment to identify which surviving nodes hold the most up-to-date state when others fail.

[02:51](https://www.youtube.com/watch?v=tZe5U9heYYI&t=171s) Viewstamped Replication vs. Paxos

Ryan Peterman notes the striking resemblance between Viewstamped Replication and Leslie Lamport’s work. Liskov confirms that she and Lamport independently developed essentially the same underlying consensus mechanism; Lamport termed his system Paxos, while Liskov called hers Viewstamped Replication. While system designers can tweak minor low-level implementation details, their fundamental principles are identical. Liskov recalls that the earliest real-world adoption of this consensus paradigm occurred in the Google File System (GFS). A former student of hers, working as a consultant at Google, observed their consensus implementation and remarked, “that's Viewstamped Replication.” Even though engineers at Google attributed the approach to Paxos, both systems represent the exact same core architecture.

When asked why Paxos gained significantly more widespread recognition than Viewstamped Replication, Liskov recounts Lamport’s own candid summary: “Yeah, so what Leslie says is I went around giving all the talks and she implemented it.” Lamport traveled extensively, presenting papers and giving lectures on Paxos, which generated enormous notoriety in the community. Liskov notes that it took time before the broader community realized both protocols solved the consensus problem identically, admitting alongside Peterman that the catchy, memorable name “Paxos” likely gave it an edge in academic marketing.

- **Independent Discovery:** Viewstamped Replication (Liskov) and Paxos (Lamport) were invented concurrently without collaboration. - **Production Adoption:** Google File System (GFS) represented one of the first major industrial deployments of this consensus model. - **Clock Independence:** System state tracking is driven by monotonically increasing view numbers rather than physical wall-clock timestamps.

[04:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=240s) The Emergence of the Liskov Substitution Principle

During the period Liskov was developing CLU and abstract data types on the East Coast, Alan Kay was creating Smalltalk on the West Coast, while Bill Wulf and Mary Shaw were building Alphard at Carnegie Mellon University. Because the modern internet did not yet exist—only the early ARPANET—these research groups operated largely in parallel silos without interacting. Liskov was not tracking Smalltalk, and West Coast researchers paid little attention to formal data abstraction.

The catalyst for bridging these worlds came in roughly 1986, when Liskov was invited to deliver a keynote at the second annual OOPSLA (Object-Oriented Programming, Systems, Languages & Applications) conference. Preparing for her address, she immersed herself in papers on Smalltalk and its offshoot languages. She observed that Smalltalk relied heavily on inheritance—defining a subclass that modifies and borrows the internal implementation of a parent class—whereas CLU relied strictly on independent constructs called “clusters.” Furthermore, the object-oriented community was debating “type hierarchy,” struggling to formalize how a type implemented by a class should relate to a type implemented by a subclass.

```mermaid flowchart LR accTitle: Subtyping Perspectives Comparison accDescr: Contrasts the West Coast implementation-driven inheritance view with Liskov's specification and behavioral subtyping view. subgraph WestCoast["West Coast Approach (Smalltalk)"] direction TB W1["Superclass Implementation"] -->|"Inheritance / Code Borrowing"| W2["Subclass Implementation"] W2 -.->|"Focus on internal code deltas"| W3["Undefined Type Hierarchy"] end subgraph LiskovApproach["Liskov & Guttag Approach (MIT)"] direction TB L1["Supertype Specification & Behavior"] -->|"Behavioral Subtyping"| L2["Subtype Conformance"] L2 -.->|"Meaning and correctness first"| L3["Implementation hidden inside"] end ```

Liskov approached the problem from an entirely different perspective, shaped by a course she co-developed at MIT with John Guttag. That curriculum trained students to design through modularity and abstract data types, prioritize formal specifications, and reason rigorously about correctness: “think about the meaning of things first, and the implementation is something that's kind of hidden inside and you don't worry about it very much.” While West Coast authors described a subclass's behavior primarily by detailing how its code deviated from the superclass's code, Liskov recognized that type substitutability must be evaluated purely on externally observable behavior:

> “And this subclass better behave like the superclass if you use it in an environment where the superclass is expected.”

This insight formed the foundation of what became known as the Liskov Substitution Principle (LSP), which she and Jeannette Wing later formalized mathematically as behavioral subtyping. Liskov did not coin the moniker herself; she only learned of the term years later in the 1990s, when an unexpected email arrived in her inbox asking whether a particular code example represented a valid interpretation of the “Liskov substitution principle.” Until that moment, she had been immersed in other systems research and had not realized the immense enduring impact her keynote formulation had made across software engineering.

## Notable quotes > [04:00](https://www.youtube.com/watch?v=tZe5U9heYYI&t=240s) And this subclass better behave like the superclass if you use it in an environment where the superclass is expected. — Barbara Liskov

## Mentioned Barbara Liskov, Bob Kahn, Vint Cerf, Argus, CLU, Viewstamped Replication, Ryan Peterman, Leslie Lamport, Paxos, Google File System (GFS), Alan Kay, Smalltalk, Bill Wulf, Mary Shaw, Alphard, Carnegie Mellon University, ARPANET, OOPSLA, John Guttag, MIT, Liskov Substitution Principle, Jeannette Wing, Princeton

## Video description Barbara Liskov is a Turing Award winner known for her work in programming languages and distributed systems. We discussed the major problems she solved in her career, stories about Dijkstra, getting rejected from Princeton because she was a woman and misc topics around her work.

Watch the full conversation: https://www.youtube.com/watch?v=T9CGjbPZeaM

[Source](https://www.youtube.com/watch?v=tZe5U9heYYI)

中文简报

图灵奖得主芭芭拉·利斯科夫：里氏替换原则背后的故事 Liskov回忆了自己通过创建Argus和开发Viewstamped Replication进入分布式计算领域的历程，后者是与Leslie Lamport的Paxos各自独立发现的共识协议，后来成为Google文件系统等架构的基础。她解释了该协议如何利用视图编号而非系统时钟在故障发生时维持状态。随后，讨论转向了里氏替换原则（Liskov Substitution Principle）的起源，该原则源自她在1986年OOPSLA主题演讲中通过行为规范而非代码继承来定义类型层次结构，而直到多年后通过一封电子邮件，她才得知这一概念已以自己的名字命名。 Barbara Liskov在读到Bob Kahn关于多节点网络程序的早期构想后进入了分布式计算领域，这促使她开发了Argus编程语言和Viewstamped Replication。 (0:00) Viewstamped Replication与Leslie Lamport的Paxos独立推导出了完全相同的核心共识协议，其中Viewstamped Replication通过逻辑视图编号而非物理挂钟时间来追踪状态。 (2:51) 里氏替换原则源于Liskov为1986年OOPSLA主题演讲所做的准备，她在演讲中通过要求子类严格遵循超类的可观察规范，解决了类型层次结构的混淆问题。 (4:00) 直到20世纪90年代通过一封意外的电子邮件询问，Liskov才得知她在主题演讲中的见解已被命名为“里氏替换原则”。 (4:00)

Reading summary

Barbara Liskov's foundational contributions to computer science—ranging from distributed consensus in Viewstamped Replication to behavioral subtyping in the Liskov Substitution Principle—emerged from analyzing systems through rigorous behavioral specifications rather than internal implementation mechanics. Distributed Computing: Argus and Viewstamped Replication (0:00) Prompted by Bob Kahn’s vision of programs distributed across networked computers, Liskov entered distributed computing by designing Argus, an object-oriented language derived from her work on CLU. Argus introduced 'guardians'—machine-bound modules communicating across networks via remote procedure calls (RPC). To maintain consistency across nodes without partial failure side effects, she integrated database concepts into the language by executing computations as distributed atomic transactions. This framework led directly to Viewstamped Replication, an intellectual precursor to modern cloud storage designed to keep data accessible as long as a quorum of nodes remained online. To eliminate dependencies on unsynchronized system clocks, Viewstamped Replication relied purely on monotonically increasing view numbers to track authoritative system state during node failures. Independent Discovery: Viewstamped Replication Versus Paxos (2:51) Liskov and Leslie Lamport independently formulated the same core consensus mechanism without collaboration, branded respectively as Viewstamped Replication and Paxos. While low-level implementation details differed, their foundational architectures were equivalent. The paradigm achieved early industrial deployment in systems like the Google File System (GFS), where an engineer recognized that the underlying consensus design reflected Viewstamped Replication. Paxos ultimately garnered wider recognition within the broader computing community. Liskov notes that Lamport attributed this visibility disparity to his extensive lecture circuit while she concentrated on implementation, alongside the academic marketing advantage of Paxos’s concise, memorable name. Behavioral Subtyping and the Substitution Principle (4:00) In the mid-1980s, distributed research silos separated East Coast abstract data type research from West Coast developments like Alan Kay's Smalltalk. While preparing a 1986 OOPSLA keynote, Liskov reviewed Smalltalk and noted that the object-oriented community defined subtyping through implementation inheritance—evaluating subclasses by the internal code borrowed or modified from superclasses, without formal type hierarchies. Informed by the modularity and specification course she taught with John Guttag at MIT, Liskov argued that substitutability must be evaluated on externally observable behavior rather than internal code deltas: a subclass must conform to the superclass's behavioral expectations whenever substituted into its place. Later mathematically formalized with Jeannette Wing as behavioral subtyping, the concept was popularized externally in the 1990s as the Liskov Substitution Principle. Liskov's career demonstrated that prioritizing formal specifications and observable behavior over hidden implementation details provided the conceptual clarity needed to resolve foundational challenges in both distributed consensus and object-oriented type systems.

精炼阅读摘要

图灵奖得主 Barbara Liskov 在访谈中回顾了其在分布式计算与面向对象领域的开创性工作，阐述了从分布式语言 Argus、共识协议 Viewstamped Replication 的构建，到提出重构面向对象继承范式的“里氏替换原则”（Liskov Substitution Principle）的思考演进。 Argus与Viewstamped Replication (0:00) 受互联网先驱 Bob Kahn 关于多机协同程序设想的启发，Liskov 针对当时业界缺乏分布式系统设计范式的空白，研发了专用于分布式系统的编程语言 Argus。该语言以部署在独立单机上的模块“守护者”（guardian）为核心抽象，节点间通过远程过程调用（RPC）通信。为了保障跨节点调用的数据一致性，Liskov 将数据库领域的原子事务机制引入编程语言语义，使跨守护者的计算要么完整提交，要么不产生任何副作用。这一研究直接催生了 Viewstamped Replication（视图戳复制），被 Liskov 视为现代云存储的思想雏形。该机制旨在确保分布在互联网不同节点上的数据在多数派法定节点（quorum）存活且网络连通时保持正确与可用。与依赖物理时钟的系统不同，Viewstamped Replication 完全脱离物理时钟，仅依赖单调递增的“视图编号”（view numbers）来标识节点状态与主备更替。共识协议的独立发现与知名度差异 (2:51) Liskov 与 Leslie Lamport 在未开展合作的情况下，几乎同时独立提出了本质相同的分布式共识机制；Lamport 将其命名为 Paxos，而 Liskov 则命名为 Viewstamped Replication。Liskov 指出，除低层工程细节存在差异外，两者的核心共识架构完全一致。该范式最早的大规模工业应用之一是 Google 文件系统（GFS），当时 Google 工程师将其归功于 Paxos，而 Liskov 的学生在 Google 担任顾问时即指出其实现本质就是 Viewstamped Replication。针对 Paxos 获得更广泛学术与行业声誉的现象，Liskov 援引了 Lamport 本人的概括：“Lamport 到处演讲宣传，而她做出了实现。”Lamport 频繁的论文宣讲让 Paxos 名声大噪，加之“Paxos”这一命名更易记忆，在学术传播上占据了优势，学术界随后才逐步认识到两者解决共识问题的方式完全相同。里氏替换原则：从代码借用到行为子类型 (4:00) 20 世纪 70 至 80 年代，早期阿帕网（ARPANET）时代缺乏互联，东海岸 MIT 的 Liskov（专注于 CLU 及抽象数据类型）与西海岸 Alan Kay（专注于 Smalltalk）各自独立探索，彼此缺乏交集。1986 年，Liskov 受邀在第二届 OOPSLA 会议发表主题演讲。在研读 Smalltalk 及其衍生语言的过程中，她发现面向对象学界正困扰于类型层级的界定，且普遍将子类视为借用和修改父类内部实现代码的工具，仅通过代码差异来定义子类。基于此前在 MIT 与 John Guttag 合授课程中建立的规范思维，Liskov 提出应优先关注抽象数据类型的行为规范与正确性推理，而将内部实现隐藏。她主张，类型的可替代性必须完全取决于外部可观测的行为：子类在被期望使用父类的上下文中，其行为表现必须与父类保持一致。这一见解形成了著名的里氏替换原则（LSP），随后由她与 Jeannette Wing 形式化为“行为子类型”（behavioral subtyping）。Liskov 本人并未创造该术语，直到 20 世纪 90 年代收到一封求证代码示例的咨询邮件时，她才获知这一原则已被业界广泛冠名并应用。 Liskov 的研究表明，优先确立形式化规范与抽象模型，能够有效厘清分布式一致性与面向对象系统中的本质复杂性；该历程同时反映出早期计算机研究中因地域区隔与学术传播方式不同，对同类技术成果的历史归属与知名度所产生的影响。

Source quotes

[4:00] Barbara Liskov: And this subclass better behave like the superclass if you use it in an environment where the superclass is expected.

Original transcript

[0:00] What got you into distributed computing? [0:02] >> I read a paper by Bob Kahn, who was with [0:06] then Cerf considered to be the founders [0:08] of the internet. [0:10] And Bob talked about [0:14] his dream of distributed computing, [0:16] where you would have a program composed [0:18] of pieces on different computers [0:20] connected by a network. [0:22] And nobody knew how to build those [0:25] programs. And so I just thought, great [0:27] problem. [0:28] >> [laughter] [0:30] >> And [snorts] I was looking for a new [0:31] problem, so I jumped into distributed [0:33] computing. And the first project was [0:35] actually a programming language to write [0:37] distributed programs in. [0:40] And and then I started looking at other [0:42] problems in the distributed systems [0:44] area. [0:45] >> What was that first programming [0:47] language? [0:47] >> It was called Argus. It was It was very [0:50] strongly influenced by Clue. [0:52] It was an object-oriented language. [0:55] It had a special kind of object called a [0:57] guardian, which was a module sitting at [1:00] a single computer. [1:02] And then guardians could compute could [1:04] communicate through remote procedure [1:06] calls. [1:07] One of the things you run into in [1:08] distributed computing [1:11] is if you have a computation that starts [1:14] at one guardian and then makes use of [1:16] other guardians at other nodes in the [1:18] network, in the end, you want that [1:21] computation to either complete entirely [1:24] or have no effect at all. [1:26] And how do you do that? Well, I borrowed [1:30] the notion of transactions coming out of [1:32] the database [1:34] and that was part of how Argus worked. [1:37] It ran the computations as atomic [1:38] transactions. [1:40] >> Oh, interesting. Like distributed [1:42] transactions across those nodes. [1:45] >> And I think it led right into the work I [1:47] did on um view stamp replication, which [1:50] was um [1:51] that was the beginning of cloud storage. [1:54] I was thinking in terms of a file [1:55] system, but it doesn't really matter [1:57] what it is. You know, how do you have [1:59] data out on the internet stored at [2:02] multiple sites [2:04] with correct behavior [2:07] and always accessible as long as enough [2:11] nodes are up and running and the network [2:13] is working. [2:14] >> I see. And what is view stamp in this [2:16] context? [2:17] >> Oh, that had to do with some details of [2:19] how the system worked. And it was a way [2:22] of noticing when some nodes failed and [2:25] other nodes had to take over. You could [2:27] figure out which ones had the most [2:29] recent state in them so you could pick [2:31] up and not lose anything that had not [2:33] had that it happened in the past. [2:36] >> Uh what what if the clocks are out of [2:38] sync? Like [2:39] >> Uh it had nothing to do with clocks [2:41] because it was just numbers. [2:43] In other words, we were in view 25, the [2:45] next view was 26. So [2:47] >> Oh, okay. Just incrementing some number [2:50] that's passed around. [2:51] >> Yeah. [2:51] >> This reminds me a lot of uh Leslie [2:54] Lamport's work. [2:55] >> Actually, yes. [2:56] >> Did you ever work with him or [2:59] >> No. Leslie and I developed what is [3:02] essentially the same idea independently. [3:04] And he had the system he called Paxos, [3:07] and I had this thing called view stamp [3:09] replication. [3:11] >> Oh, interesting. And they're essentially [3:14] the same thing. [3:14] >> They are. Yeah. [3:16] >> Oh, are there pros and cons of the two [3:18] approaches? [3:19] >> Yeah, I mean, there when you do this [3:21] kind of system, there's a lots of little [3:23] details you can play around with so you [3:25] could, you know, decide to do it it gets [3:28] technical, but you know, there's tiny [3:29] differences. But no, they're basically [3:31] the same. In fact, what happened was [3:34] uh the first time that [3:37] I'm aware of that this was actually used [3:39] in a real system was when the Google [3:41] file system came along. [3:44] And [3:45] one of my former students who was I [3:48] think he was a consultant at Google [3:50] looked at what was going on in there and [3:51] he said, he says, that's few temp [3:53] replication." So, the people at Google [3:55] seem to think it was Paxos, but in fact, [3:57] they are the same system. [4:00] >> I also noticed like um [4:01] when you were uh when you came up with [4:04] abstract data types, [4:06] maybe and maybe it's just cuz there [4:08] wasn't the internet wasn't as, you know, [4:11] wasn't there, that there was also the [4:13] object-oriented stuff going on on the [4:15] West Coast. [4:16] >> Yes, Alan Kay was developing Smalltalk [4:19] at the same time that I was working on [4:21] Clu, and then at Carnegie Mellon, [4:25] Bill Wolf and Mary Shaw were working on [4:26] Alphard, which was another data [4:28] abstraction language. [4:31] And you're right, there was no there was [4:32] no internet, although there was the [4:34] ARPANET. [4:35] You know, so we did, but it was like [4:38] there were two independent streams of [4:40] research going on, and we weren't [4:41] talking to each other. [4:43] And so, I wasn't paying much attention [4:45] to Smalltalk, and [4:47] on the West Coast, I don't think they [4:49] were paying much attention to data [4:50] abstraction. [4:52] And this led to the Liskov substitution [4:55] principle, [4:57] which I mean, the story is a sort of a [4:59] cute one because [5:01] in 1986, I think it was, I was asked to [5:05] give a keynote at OOPSLA. OOPSLA is the [5:08] object-oriented programming conference, [5:11] and this was the second year it was [5:13] happening. [5:14] And so, I decided, I think I'll read all [5:17] those papers about Smalltalk, and there [5:19] were other languages being developed [5:21] that were based on Smalltalk, and see [5:22] what's going on with them. And I [5:24] discovered [5:26] um so, Smalltalk has this idea of [5:28] inheritance in it, where you can have a [5:30] class and a subclass, which borrows from [5:33] the way the class is implemented and [5:35] changes it a bit. [5:37] And Clu doesn't have that. Clu just has [5:39] what we called clusters, and they're all [5:41] independent. [5:43] So, I saw that they were talking about [5:46] this notion of classes and subclasses. [5:49] And [5:50] and then I saw that they were also [5:52] talking about something they called type [5:54] hierarchy, [5:55] where they wanted the type implemented [5:58] by a class [6:00] to be related in some way that they [6:02] didn't understand to the type that was [6:04] implemented by a subclass. [6:06] I really thought about modules in terms [6:08] of their specifications. [6:11] This partly had to do with a class I [6:13] developed at MIT [6:15] that I developed jointly with my [6:16] colleague John Guttag. And in that class [6:20] we taught the students how to do design [6:22] about modularity, data types, and so [6:24] forth, but also how to write [6:25] specifications, [6:27] how to reason about correctness, [6:29] and so it had a big focus on think about [6:33] the meaning of things first, and the [6:35] implementation is something that's kind [6:37] of hidden inside and you don't worry [6:38] about it very much. And so [6:41] that was a different way of thinking [6:43] about things than what was going on in [6:44] the [6:46] on the West Coast, where they were [6:47] really thinking in terms of [6:49] classes and subclasses, and I even saw [6:52] papers where they would describe the [6:54] behavior of a class by explaining how [6:56] its implementation was different from [6:58] the implementation of the superclass. So [7:00] they were kind of focused on [7:02] implementations in a way that we [7:03] weren't. [7:04] And so [7:07] when I read these papers about type [7:09] hierarchy and I saw they just couldn't [7:11] figure out what it was supposed to mean, [7:14] I was thinking about it from the terms [7:16] of meaning, and so I was able to say it [7:19] has to do with the behavior. [7:21] And this subclass better behave like the [7:24] superclass if you use it in an [7:26] environment where the superclass is [7:27] expected. [7:29] And that became what ended up being [7:32] called the Liskov substitution [7:33] principle. [7:35] And ultimately Jeannette Wing and I [7:36] wrote a paper on behavioral subtyping, [7:38] which is the formal definition. [7:41] >> And then how did it get that name? Cuz [7:43] you didn't go off on stage and say, "Hey [7:45] everyone, here's the Liskov [7:46] >> No, no, but no, as as as I said, one day [7:49] in the [7:50] in the '90s [clears throat] after the [7:51] internet had arrived, I got an email [7:54] saying, "Can you say if this is the [7:56] correct interpretation of the Liskov [7:58] substitution principle?" That's when I [8:00] discovered [8:01] that [8:02] there was such a name. [8:04] And and I [8:07] I don't think I had really been aware of [8:08] how important it was until that point [8:10] because I wasn't thinking about this [8:12] stuff. I was working on other stuff. [8:14] >> In the academic community, it seems very [8:17] reasonable to have multiple people have [8:20] similar ideas, but it seems like some [8:23] ideas stick [8:25] more than others. For instance, like the [8:28] the Viewstamp replication versus Paxos. [8:31] They're the same thing. I'm wondering, [8:34] like in that case for instance, why [8:36] would Paxos be more known than Viewstamp [8:39] replication? [8:40] >> Yeah, so what Leslie says is [8:43] I went around giving all the talks and [8:45] she implemented it. [8:47] >> [laughter] [8:50] >> Really? [8:52] >> Something up to that. [8:54] >> Then he [8:55] got notoriety for speaking about it. [8:58] >> Yeah, he he he did give lots of talks [9:00] about it and wrote several papers and so [9:03] forth and I didn't realize it was the [9:05] same system, but finally it became clear [9:08] that they were the same system. [9:10] >> I also wonder how much the name matters [9:13] because Paxos is kind of catchy, you [9:15] know? [9:16] >> It is a cute name. [9:16] >> It's a cute name, yeah. [9:17] >> Yeah, right. [9:18] >> So, I I could see maybe it has better [9:21] marketing around the idea, I guess.