The Next Programming Language Is English

Demetrios: [00:00:00] All right, so at the beginning of April, I went to New York for the MCP Dev Summit, and while I was there, I got the chance to record a few podcasts with attendees that were at the event. This is one of those conversations. Hope you enjoy.

Cornelia Davis: Developers in the last, up until very recently, have had to understand not the physical processor, but they had to understand the notion of a process.

Cornelia Davis: There's the correctness side of, well, when I write this line of code, it is gonna translate into the right assembly language down under the covers. I think this big transformation that we have going into the AI space where we're now programming with natural language, that's not a formal language. You get to think about the logical process.

Cornelia Davis: We will ensure that we give you durability underneath that abstraction so that as the infrastructure is doing all sorts of chaotic, weird things, we will compensate for all those weird things. You just get to think about this logical process.[00:01:00]

Demetrios: The idea of programming languages and just programming models has evolved over time. You have been deep in the weeds at studying it, being part of it, uh, helping shape it. Tell me about what you see as, like, the evolutionary through p- through line or thread that goes through it.

Cornelia Davis: So I recently did a, um, an internal developer conference for one of our, our users- Mm

Cornelia Davis: one of our customers. Um, and the very first slide that I showed them was a slide of a processor, and I ask in the room, "How many of you have programmed in assembly language?" And there were about 50 people in the room. Surprisingly, half of them raised their hands. Really? I was like, "Wow, really?" I thought I was the oldest one in the room, right?

Cornelia Davis: I did. And when I was in school, I programmed, um, assembly. And, um, and then the second question was, "How many of you [00:02:00] still program in, in assembly?" Mm. And unsurprisingly, no one raised their hands. And so nobody programs in assembly anymore because we came up with a higher level abstraction. It's-- There's still assembly language running.

Cornelia Davis: Yeah. There's still program counters and instruction registers and memory, you know, registers and all of those types of things. Those, those physical components are still there, um, but we have a different abstraction, and so that's the through line- Mm ... is that we're always moving up the level of abstraction.

Cornelia Davis: But I'll tell you honestly that, um, for the most part, uh, the last, I would say, certainly the time that I've been doing this, which is more than three decades, uh, sure, we moved from assembly language, and our languages got incrementally better and a little bit higher level in, in terms of abstraction. So C used to-- you have to-- had to do your own memory management.

Cornelia Davis: Then we had an abstraction that allowed you to not have to do your memory management, so you-- Java did, [00:03:00] did the memory management for you. Um, and then where I work now, Temporal kind of raises that abstraction as well.

Demetrios: Mm-hmm.

Cornelia Davis: Um, but in the AI space, we are radically changing the pro- programming model because now we're programming with natural language, and eventually that turns into code that eventually gets all the way down to assembly language- Mm

Cornelia Davis: and is running on a processor. Um, one of the interesting things, though, is that, um, in those tr- those other abstractions where we had a formal programming language, we had ways, and I studied programming languages in grad school for a while, and to a large extent, that's hardcore math.

Demetrios: Yeah.

Cornelia Davis: Because you're proving these programming languages and the compiler's correct and complete, so you can express everything you want to express.

Cornelia Davis: That's the completeness side, and then there's the correctness side of, well, when I write this line of code, it is gonna translate into the right assembly language down under the covers. I think this big [00:04:00] transformation that we have going into the AI space where we're now programming with natural language, that's not a formal language.

Cornelia Davis: It's not deterministic. It's not an abstraction that is deterministic down to the next level of-

Demetrios: Yeah ...

Cornelia Davis: granularity, you know, the, the next level of abstraction, and so that changes everything. So we have to figure out what the programming model is for this.

Demetrios: Well, I remember when we were first starting to do, like, text to SQL, and I had a little bit of a gripe with it because it was like, but why would you wanna do that be-- it's so fuzzy.

Demetrios: Language itself is really hard to interpret. It is. And if I want something to happen, there's so many different words that I can use to express just s- a fairly simple idea.

Cornelia Davis: Yep.

Demetrios: It feels like it's going to be easier if you just use the Bound language that we've already created. But I was proven wildly wrong.

Demetrios: Yeah. That is [00:05:00] not correct. I do not feel that same way now. Yeah. I have changed my mind completely because anybody who has vibe coded or just tried to use coding agents, they go, "Well, this is very good." Right? Yes. So it's different now. It is- We don't have that ...

Cornelia Davis: it is different, but, and we also know about hallucinations, right?

Demetrios: Mm-hmm.

Cornelia Davis: So it is different. You're right, it does a pretty good job interpreting. The, the, the models have gotten really good at interpreting that, and then of course, depending on the way that you use them, you use them iteratively and you converge on something, and hopefully you're paying attention to what it's doing and that it isn't totally hallucinating something completely wacky.

Cornelia Davis: But we're seeing plenty of cases where it is. Yeah. And so that's my concern as somebody who studied formal languages. English is not a formal language, and so what are we gonna do as an industry to show that? And I think we have to find other ways of compensating for that. I don't think that we're gonna get it to the point where it is as rigorous as the math- Mm

Cornelia Davis: that we did [00:06:00] under the covers with programming languages before. But does it need to be? So now we have to-

Demetrios: I guess that's

Cornelia Davis: the big question. I, see, I don't think so.

Demetrios: Yeah.

Cornelia Davis: Um, the, the mathematician in me is like, that, the, that was the kind of initial like AI skeptic, like, oh, my gosh, like I am so used to deterministic code.

Cornelia Davis: I'm happy in that space. Mm-hmm. I'm happy with the fact that one plus one is always equal to two, you know, that type of a thing, and now it's probabilistic. One plus one might be three. And so I think what we're gonna figure out is we're gonna find, figure out different ways of compensating for it.

Demetrios: Uh-huh.

Cornelia Davis: And so we will, we have to build safety nets, so this is the way things are working. There is a certain level of nondeterminism, so how do you deal with that nondeterminism? How, how, what, what type of safety net do you have when the translation from this higher level abstraction down to the concrete thing goes haywire?

Demetrios: Yeah.

Cornelia Davis: How do you compensate for that?

Demetrios: Well, in one way you could look at the idea of durable execution as one of those safety nets, right? [00:07:00]

Cornelia Davis: Absolutely. And so it's-- And that's why so, so durable execution, as you know, durable execution is pre-gen AI craze. Mm-hmm. So the company that I work for, Temporal, um, uh, Temporal, the open source project, has been around for six and a half years or something like that, and it definitely represents this higher level ab-abstraction.

Cornelia Davis: Now, it still falls into that category. Until you start using it in the AI space, it falls in that category of it's deterministic. Mm-hmm. It is we, we know exactly how this is gonna map from the way that you write. And the programming model, so just to very quickly describe the programming model, the programming model there is that as developers for the last 30, more than 30 years, remember we talked about the physical processor before- Yeah

Cornelia Davis: right? Developers in the last, up until very recently, have had to understand not the physical processor, but they had to understand the notion of a process.

Demetrios: [00:08:00] Yeah.

Cornelia Davis: Like, my code is running in a process. As we went into the cloud, in cloud native, we had multiple processes, so we had to start figuring out how multiple processes would communicate, and what happens when the network goes down, and all of those types of things.

Cornelia Davis: But we as developers had to think about those infrastructure abstractions. I had to think about a process. I had to think about the network. And what Temporal does is it moves that level of abstraction higher, and it says, "No, you as a developer, you get to think about a process as a logical process. We'll map it down to physical processes for you."

Demetrios: Mm.

Cornelia Davis: That's what durable execution does, and so what it says is, "You get to think about the logical process. We will ensure that we give you durability underneath that abstraction so that as the infrastructure is doing all sorts of chaotic, weird things, we will compensate for all those weird things. You just get to think about this logical process."

Cornelia Davis: That's fundamentally what durable execution is. So it is that level, [00:09:00] and now we're layering AI on top of it. Mm. So it is kind of a deterministic tier that we can leverage, you're right, as kind of a safety, a part of the safety net that's gonna allow us to compensate for that.

Demetrios: I'm sure you've heard a lot of the, like, the chaos monkey or chaos engineering.

Demetrios: Oh, yeah. This, in a way, is that, but- Having folks not even worry about chaos engineering because you're gonna be doing the chaos on your side and making sure that- We compensate

Cornelia Davis: for the chaos.

Demetrios: Yeah.

Cornelia Davis: Yeah, exactly.

Demetrios: I didn't think about that before, but it makes a lot of sense.

Cornelia Davis: Yeah. It's really interesting. So I, I spent a lot of time-- I was around when we moved over into container architecture, so I worked on Cloud Foundry, and Cloud Foundry was the technology that was self-healing before Kubernetes came along.

Cornelia Davis: Mm-hmm. Um, and it had containers under the covers, and so you could deploy multiple instances of an app, and if the container went away, we just brought it back.

Demetrios: Oh.

Cornelia Davis: And I worked with sometimes users and customers [00:10:00] who said, "Yeah, my developers would come in and say, 'I saw a dashboard that said the container went away.

Cornelia Davis: What are we gonna do about that?'" And the people who understood that technology were like, "Does it matter? Is your app still running?" And they're like, "Uh, yeah, I guess it is." So maybe it doesn't matter anymore that the container went away.

Demetrios: Yeah.

Cornelia Davis: It's that same concept.

Demetrios: Okay. So then going back to the original idea of, hey, durable execution is a way to make, um, almost make up for the fact that we're now communicating with our machines in natural language.

Demetrios: There feels like there's other ways that we're making up for it too. I guess one way is MCP.

Cornelia Davis: Yep.

Demetrios: And then other ways are, I, I'm sure, like if I really think about it right now, there's, there's probably plenty of ways that guardrails, putting those into place Other ones that maybe I'm-

Cornelia Davis: Yeah ...

Demetrios: not able to think about?

Cornelia Davis: Yeah, I mean, [00:11:00] I love that you bring up MCP because when we start thinking about the way that applications are being written, these AI applications, we've got the agents, right? Mm-hmm. They're running their agentic loop, and so part of the programming model there is we've got these agents running an agentic loop, and they're gonna use tools.

Cornelia Davis: Tools is one of the first class abstractions- Mm-hmm ... in the AI space, right? Even LLMs, even if you're not running an agent, an LLM has tools as an ab- abstraction. You al- you also pulled, you know, called out guardrails, those- Yeah ... types of things. Um, and so now we've got these tools. There's an abstraction, and durable execution plays across that entire gambit.

Cornelia Davis: Um, and so for example, if you have a long-running agent that might be running for five minutes or 10 minutes or five hours or five days, you want some durability around that. Remember we talked about how durable execution says, well, you could think about a logical process. So in that case, my logical process is my agent, and the fact that it's gonna run for five days, it's a logical process.

Cornelia Davis: I don't have to worry about [00:12:00] what happens with the infrastructure over those five days 'cause Temporal- Oh ... will compensate for it. Well, that same durability is valuable when you think about the tools. So are the tools gonna be long-running? And increasingly they are, because increasingly tools are themselves agents.

Cornelia Davis: Yeah. So they're gonna be long-running. So we want to apply durability in the agents. We wanna apply durability in MCP, which is why we refer to it as the concept is durable MCP.

Demetrios: Yeah, let's talk more about durable MCP, because you mentioned that it's now almost becoming first class citizen.

Cornelia Davis: It is. So prior to November, so the first kind of early versions of the MCP spec didn't say anything about durability, and in fact, they were mostly request response.

Cornelia Davis: So their whole-- And that's pretty natural. Like, I grew up in, like, the microservices era as well, and initially our microservices were all request response. And I like to say that the poster children of microservices in that era was Netflix. Mm-hmm. [00:13:00] And they built a whole bunch of services around the request response protocol.

Cornelia Davis: So they had things like retries, retry libraries. They had service discovery. They had circuit breakers to keep you from DDoSing things. So it's completely natural to start with request response because it's kind of a natural way of us programming and, like, our mental model around these things. But in November, they released, um, an something called a task Which doesn't f- um, change, it's not a new concept.

Cornelia Davis: It's still the core thing with MCP is, of course, you've got resources and prompts, but those aren't used a whole lot. It's mainly the tools, right? Mm-hmm. That's the main thing that's used out of temp- uh, I'm sorry, out of, uh, MCP. Um, tasks don't add a new type of... It doesn't add a new resource. It says a tool can be request response or it can be async.

Cornelia Davis: So it can be long-running. You fire off a tool, you make a tool [00:14:00] call, and you don't expect a response right away. Yeah. It's not request response. You just, you're waiting, and you're maybe never, maybe it's fire and forget.

Demetrios: Indefinitely. Yeah.

Cornelia Davis: And the cool thing about... So on the one hand, they could have just defined that protocol and said, instead of doing a request and getting back a result, you do a request, you get back a handle.

Cornelia Davis: Now you can interact with that handle by asking for status-

Demetrios: Mm-hmm ...

Cornelia Davis: getting a result when the, when you get back a status that says, "Okay, you're done now. You can get back a result." That's kind of, okay, that's great, but the first line in the specification says tasks are durable Which is wicked cool because it's this recognition that tools run for a long time, and that if something goes wrong, you don't wanna have to start all over again.

Demetrios: You don't wanna send the request again.

Cornelia Davis: You don't wanna have to start- Yeah ... exactly, send the request again. Imagine that you've burned through- Start from zero, yeah ... millions or billions of [00:15:00] tokens, and then something goes wrong when you're 90% complete. Right. You don't wanna have to start that over again.

Cornelia Davis: And so the tasks, them being durable, um, the requirement is that they're durable, uh, that change-- that's the thing that changes a lot.

Demetrios: Because you can guarantee that it's going to come back.

Cornelia Davis: Yeah, exactly. Exactly. And- So by being durable, what that means is that the client- Yeah ... that just connected with the MCP server to invoke that tool, the client could go away, the network could go away, and in fact, the tool itself could go down.

Cornelia Davis: Remember we were talking about durable- Mm-hmm ... execution says think of your process as logical. It's always once you start it, it lives. Mm. It just lives. Infrastructure can come and go, all sorts of things can happen. So the MCP server itself can go down, but the specification says tasks are required to be durable, so that means that not everything is lost.

Demetrios: So you keep... You mentioned [00:16:00] before these long-running agents, and you're also talking about tasks. It feels like that is very much long-running type of- Exactly ... use case. What are the, what are being done with these long-running agents? Like, what are you seeing out there that needs such long-running agents?

Cornelia Davis: Yeah. So, um, there's quite a number of different use cases. There's some of the same batch type of use cases that we've done all along. So- Mm-hmm ... you know, tools don't have to be themselves be AI applications. Mm-hmm. It could be I'm gonna go off and do an analysis. I was in a session earlier today, um, that was given by a couple of folks in Amazon, and they were with Prime Video, and they had a just a fantastic use case that they talked about where they said, "It used to be that we did analysis on the streaming, the quality of the streaming only for the premiere events, only the, for the events where there were millions or tens of millions of [00:17:00] viewers."

Cornelia Davis: Because humans were involved in that analysis. Mm-hmm. Well, they've now created agents that can do that analysis, and so they're, they're not constrained by human, human bandwidth anymore. So they've created agents, and so now they're doing that same kind of streaming analysis on tiny little niche things.

Demetrios: All the videos.

Cornelia Davis: But that's all long-running, because what they're doing is they're crunching through a lot of data. So a lot of-- So you were asking about use cases, data analytics- Mm-hmm ... data analysis. Now, in that particular case, they are using an agent to do that, but there's a lot of use cases even that are pre-agent, um, that are just long-running.

Cornelia Davis: Another thing that makes things long-running is as soon as you have some type of human in the loop, humans are bottlenecks.

Demetrios: Mm-hmm.

Cornelia Davis: Right? So you could be part of the way through processing some tool, and now all of a sudden the tool, the MCP server, the tool says, "Oh, I need some human input." Um, [00:18:00] and now you've gotta wait for the human to come back.

Cornelia Davis: Yeah. Well, that might be days.

Demetrios: Yeah.

Cornelia Davis: And, but the process, let's say it's 50% of the way through, and now it's waiting for the human. The pro- you want that process to be durable.

Demetrios: Yep.

Cornelia Davis: Um, and so that when the human finally does-- And you don't not only want it to be durable, you want it to be efficient. You don't wanna, like, hold that in memory for five days while you're waiting for the human.

Cornelia Davis: So you wanna make sure that your infrastructure's being used efficiently as well.

Demetrios: Uh-huh.

Cornelia Davis: And that, that's not a requirement of durability, but it is a requirement of a really good durable execution platform.

Demetrios: Yeah, and just resource management.

Cornelia Davis: Exactly.

Demetrios: So-

Cornelia Davis: Exactly ...

Demetrios: can we go back to this Netflix ex- or sorry, the Amazon Prime example?

Demetrios: Yep. Amazon's not gonna be happy we're comparing. I mean, same, same. Streaming example- Streaming example, yep ... I guess we could call it. It's long-running because the whole time that they are streaming it, they're-- I assume they're constantly streaming it [00:19:00] And so they're just taking snippets of time-

Cornelia Davis: Yeah

Cornelia Davis: continuously?

Demetrios: I,

Cornelia Davis: I don't actually know the details of the implementation. I think it could be a continual process- Mm-hmm ... which I think is a super interesting use case, which, um, is just, it, the, it's like an ambient agent. Yeah. It's always watching- That's what I was thinking, yeah ... and it's always responding.

Cornelia Davis: I don't know for sure whether that's what they were referring to, or whether they were saying, "We're always collecting data for the, from the number of times that it has streamed," and then they do it in a batch situation. Uh-huh. I don't know for sure. We were asking about c- use cases for tasks. One of the interesting things about the MCP tasks is that it is largely about batch.

Cornelia Davis: Mm-hmm. So it is not-- It does support a human in the loop, but the human in the loop is triggered by the MCP tool itself. It is not one of those things where the MCP tool is doing its thing, it gives you some interim result, [00:20:00] and then the external agent is making the decision on the human in the loop and progressing it.

Cornelia Davis: It is pretty much a, "Hey, we've defined this long-running process." Again, it could be an agent, but now it's the tool that's in charge.

Demetrios: Uh-huh.

Cornelia Davis: It, the, the tool is, is the, the main player there, which surprises me because I come from a world where long-running processes can be interacted with from the outside.

Demetrios: Yeah.

Cornelia Davis: But there is no, without getting into all of the details of the protocol, the, um, the task protocol allows you to create a task, it allows you to get status on the task, it allows you to cancel the task, and it allows you to get the result. It does not allow you to essentially put into there. Like you can't from the outside say, "Hey, here's some more information."

Demetrios: Oh. The

Cornelia Davis: tool can say- I mean- ... "Hey, I need more information," and it'll come out to the client and say, "Hey, I need this more information." But the client can't offer [00:21:00] additional information. So I was actually quite surprised about that because I thought, "Oh, tasks." I thought they were gonna be like we do that in Temporal.

Cornelia Davis: Mm-hmm. But it's actually, it's a little bit more constrained. There's lots of use cases where you send it over the tool and now the tool is in control, like these batch processes that we talked about. But it's, it doesn't have a protocol. These are some of the things that I'm definitely gonna be trying to influence.

Cornelia Davis: The protocol's only experimental right now, so there's an opportunity to influence it. Oh, so you would want that ability to- I would want the ability- ... throw

Demetrios: more on its plate

Cornelia Davis: Yeah. Yeah. There are ways of doing it, but it, it's a little bit odd. You have to define other tools with the same server, and that might be a best practice.

Cornelia Davis: I haven't quite gotten that far yet. Mm. We'll see.

Demetrios: Can you break down-- I'm still trying to wrap my head around the tasks and the different use cases, so different batch processes that you've seen being done with tasks.

Cornelia Davis: Yeah. So there might be, for example, um, [00:22:00] it could be like an invoice processing example- Mm-hmm

Cornelia Davis: which is exactly what I did i- in my talk, was invoice processing. So you're gonna submit an invoice. You've got a tool that is an invoice processor. For the most part, you submit the invoice, and what does it need to do? It needs to do some validation. Then maybe it needs to ask the human for approval. You know, you've got some policy there- Mm-hmm

Cornelia Davis: that says, "Ah, anything under 500 bucks, just go ahead and process it. Anything above that," or if there's some other policy, some weirdness about the invoice, then you have to have human in the loop. The tool would be the thing that decides. That's where the policy's running. The tool can come out and say, "Hey, client, I need approval."

Cornelia Davis: And then you could be paying parts of that, and maybe the entire invoice doesn't need to be paid at once. Maybe you've got a complex invoice where you say, "Ah, I'm gonna, I'm gonna pay this in increments." So that is a long-running tool where let's say you're gonna pay it quarterly. You can model that as a [00:23:00] single tool, a single invoice that you're processing.

Cornelia Davis: You pay this quarter's, and then the thing goes to sleep, and next quarter it wakes up, and it pays the next installment.

Demetrios: Whoa.

Cornelia Davis: So that is what I mean by a long-running thing, that you can imagine an agent saying, "Hey, go ahead and process this batch of invoices for me," and that's the, the process that's going on in the background.

Demetrios: And that's where you talk about the resource management is important because you don't want it for a whole month to be there thinking about that. Yep. You want it to go to sleep.

Cornelia Davis: Exactly.

Demetrios: Huh.

Cornelia Davis: Exactly.

Demetrios: And so yeah, scale to zero is important here. On these tasks you wanna- That's right ... and so-- and then you're thinking Wow, wouldn't it be great if I could add more invoices to that while it's happening instead of having to kick off a new task with new extra invoices?

Cornelia Davis: Um, so-

Demetrios: Is that kind of the idea with the-

Cornelia Davis: I, I think there's a number of different ways to do it. The [00:24:00] way that I did it very, very naively in the beginning is that each task was, each invoice was its own task. Um, you can also imagine batching those things and saying, "Actually, a batch of invoices is a task."

Cornelia Davis: And within that you can break it, break it down into, you know, subtasks or... Because each one might have its own schedule. Mm-hmm. So there might be an invoice that is paid quarterly and another one that's paid weekly- Yeah ... and those types of things. And so going back to the durability conversation that we've ha- been having all along, you're right, it needs to scale to zero.

Cornelia Davis: And remember, I said the infrastructure can go away. So where does that timer live? Yeah. The timer has to survive that, that infrastructure failure as well, and so we like to call those things durable timers. And so we have this notion of like timers need to be durable. Human in the loop needs to be durable.

Cornelia Davis: The compute needs to be durable, all of those things. So durability isn't just retries or state management, it's a [00:25:00] whole complex set of things, and that's what I mean by programming language, right? Is like here's this new abstraction of durability that you can apply across a bunch of different programming elements, and as soon as you have the notion of a durable timer, then you no longer have to program that.

Demetrios: Yeah.

Cornelia Davis: So.

Demetrios: Yeah, you, you have to keep the time though, because otherwise when is it gonna know when to wake up?

Cornelia Davis: Um, that's what it, that's what... For example, Temporal has durable timers. Yeah. And they live in the Temporal server, so it knows when to wake up. Your process can go away. Mm-hmm. That's what allows us to be efficient with that, is the processes go away, the timer fires, and now a worker process that's always checking to see is there anything new is like, "Oh, I see this timer fired.

Cornelia Davis: Oh, that timer corresponds to this thing that's asleep over here. I'll wake it up now."

Demetrios: Yeah, and so I'm starting to get a better picture, and in my head I, I'm kind of envisioning it as like different [00:26:00] things happening that are creating chain reactions, and you have to make sure that each one of those things is working.

Demetrios: Because if you have some kind of a problem, then the domino's not gonna go to the next domino. And so- Everything has to be durable.

Cornelia Davis: Yes.

Demetrios: That's, that's why I'm understanding the, the idea of, okay, durable execution doesn't mean just durable execution. It means durable timers, durable compute, all of that.

Cornelia Davis: Exactly. Exactly.

Demetrios: Huh.

Cornelia Davis: Yep.

Demetrios: Okay. So n- so that's tasks and a little bit of, like, MCP being more durable and bringing that to its own DNA in a way. Hopefully we see more of it, and so that most things are durable. Is there ever times where you wouldn't necessarily need to-- is, like, durable execution is overkill?

Cornelia Davis: Oh, definitely. Um, I think that there are some places where the cost of re- recomputing [00:27:00] something is so small that you don't necessarily need to, to take on that burden. Mm-hmm. Because what we're essentially doing is we're pushing some concerns that used to be application concerns down into the infrastructure.

Cornelia Davis: That's what we're effectively doing. Of course, that means your infrastructure is a little bit more complex. So like I said, short-running things where the, the cost to recompute that over again is, is, you know, very, very small. Other things are things like embedded systems, so if you aren't- Necessarily running a distributed system.

Cornelia Davis: Mm-hmm. So you're not deploying your application out into the cloud and have multiple instances. Embedded on like s- let's say a car, for example- Mm-hmm ... probably not needed there, in part because everything's different there. You're doing embedded systems. You're probably programming in C and C++ and those- Mm-hmm

Cornelia Davis: types of things. You're still doing your own memory management because things need to happen really quickly. You're, you're operating at a level [00:28:00] where you're still operating at that low, lower level of abstraction. So there's, there's a, a number of those things, but one of the things with durable execution is we've seen this with some of our ear- you know, the early adopters of durable execution, um, is that they come in and they adopt it for a use case, and once they understand this new programming model, all of a sudden they're like, they can't see problems- They can't

Demetrios: unsee it

Cornelia Davis: They can't unsee it.

Cornelia Davis: Mm-hmm. Now they want everything to be built that way, and we hear stories, um, one of, one of our most vocal champions is from Yum Brands, um, Matt McDole, and he tells this great story of product manager came to them. They had been talking about a feature for a while, and, um, they had estimated that it would take weeks or months to implement.

Cornelia Davis: And the reason they-- it was gonna take that long was because it was this highly distributed application where, like we talked about earlier, the, the developers were gonna have to worry about all these like, okay, I've got this [00:29:00] process over here, this process over here that might go away, so I have to make sure to store some state over here, and I need a, a message bus over here.

Cornelia Davis: And it was just a complicated topology and a complicated, like, workflow that they e- needed to wire together themselves. Mm-hmm. A little bit of a Rube Goldberg machine that they had to build, and Rube Goldberg machines, metaphorically, are really hard. They're hard to operate. And when they re-thought about it in this model where they're like, "Well, if I think about it in terms of a process that doesn't go away, something else is taking care of that resilience," they were able to implement it in a couple of days.

Cornelia Davis: Like, that's the power of a different programming model.

Demetrios: Uh-huh.

Cornelia Davis: Like, we couldn't build the, we couldn't build AI systems in Assembly anymore. We just couldn't do it.

Demetrios: So this developer couldn't unsee it because there was such this, and there was such complex topology But he was able to say, "Let's imagine that these are always there, like we can take them for granted."

Demetrios: Yep. And so now if we are able [00:30:00] to take this for granted that it's going to be there, we don't have to make it as complex as we thought we did.

Cornelia Davis: Exactly.

Demetrios: But I, I guess I-- where's that parallel or where's the... I'm not drawing the conclusion of, okay, if it's always there, then it's less complexity.

Cornelia Davis: Um, because the complexity is moved down.

Cornelia Davis: The, the higher level abstraction is they get to deal with this abstraction that makes it less complex for them. And what we do in Temporal is we map it down. It's complex. The runtime- Mm-hmm ... topology is just as complex. It's that the developer doesn't have to wire all that up themselves and create all of those components themselves.

Cornelia Davis: Ah,

Demetrios: I see.

Cornelia Davis: Temporal does that. So one of the things that I like to say is that, um, event-driven systems and event-sourced systems, which is an, an added complexity on top of event-driven systems, um, they are-- it's an [00:31:00] incredibly powerful paradigm that we need for runtime resilience.

Demetrios: Mm-hmm.

Cornelia Davis: But it's so hard for humans and non-human coders to understand- Mm-hmm

Cornelia Davis: because there's so many moving parts, and it is, each one of those is a little bit different. It is truly a Rube Goldberg machine. They're all a little bit different and like you said, dominoes falling on dominoes. Yeah. Um, and so that's another one of the things. I've not done any like tests of it, um, but I am being somebody who uses coding agents.

Cornelia Davis: If you give a coding agent a simpler programming model, they're gonna do a better job writing the code in that simpler programming model as well. Yeah. So the simpler programming model up until recently was a huge benefit for our early adopters, and we have a few hundred thousand people are using Temporal.

Cornelia Davis: It's, it just-- which is still small compared to, I think it should be in everybody, every developer's toolbox, and will be in a few years. But it is [00:32:00] now, I think the even bigger thing is like Uh, coding agents wouldn't do a very good job writing, you know, some complex thing in Assembly. Mm-hmm. You give them higher level abstractions so that they, the LLMs can reason through that and- Mm.

Cornelia Davis: So that's another thing with durable execution and that change in programming model is that, that we give that programming model the understanding of that programming model to the agents, and then they can write that code better as well.

Demetrios: And how does it work if I now have all of this very complex topology and I install Temporal, I have to have Temporal map everything, and then almost give a guarantee that, all right, we're gonna secure this or we're gonna durablify this?

Cornelia Davis: Ah, so it's actually that, um, Temporal brings that complex temp- topology. Oh. So Temporal brings the messaging substrate. Temporal brings things like durable timers and stuff. So it [00:33:00] is that, um, the developer gets to write in this abstraction, and when they deploy it, when they deploy those applications, Temporal takes what looks like a single process application, 'cause it is logically a single process, and it maps it down to that complex topology.

Demetrios: Ah.

Cornelia Davis: So it's not that the developer has to think about the complex topology. Temporal basically does that for, for them.

Demetrios: So that developer that you were saying, Matt was his name?

Cornelia Davis: Matt McDole, yeah.

Demetrios: He had to worry about everything in his former life, where he's looking at it and he's trying to map out story points and saying, "This is gonna take six months."

Demetrios: And then he says, "Oh, no. Well, maybe we'll just hit Temporal instead." And then you are in the background bringing the, all of that that he thought he was having to wire up.

Cornelia Davis: Exactly.

Demetrios: And so in a way, you're sitting [00:34:00] in between His system and that complexity in the system, and he's just interfacing with you. Uh, and now everything's making sense.

Demetrios: It took me a minute. Yep. Yep. But yeah, I'm, I'm getting it while you're like, "Yeah, that's a higher level abstraction. That's where we're, we're... It's what we've been talking about."

Cornelia Davis: Yeah. And, and, and Demetrius, that is- ... that aha moment, um, uh, brilliant that you had it. It takes a while- Yeah ... because we have spent, like I said, decades thinking about building systems with these lower level abstractions.

Cornelia Davis: Even as our programming languages gave us higher level abstractions- Mm ... we still fundamentally still had to understand the architecture of the computer and the architecture- Mm-hmm ... of the network and things like that. What I'm saying is you don't have to anymore.

Demetrios: Yeah.

Cornelia Davis: Yeah.

Demetrios: Just like you don't have to learn TypeScript or Python anymore.

Cornelia Davis: Yep. Yep.

Demetrios: Absolutely. It's good if you know it and you can debug through it. Yeah. But it's als- you can also create a lot of stuff without knowing it.

Cornelia Davis: [00:35:00] Yep, that's

Demetrios: right. So, yeah. All right. Well-

Cornelia Davis: Yeah ...

Demetrios: that kind of drives it home and brings me full circle to, okay, we started this conversation with the evolution and the thread that has been going on these abstractions and programming models, and recognizing how we're just continuously moving up and up and up.

Demetrios: Yep. And how durable execution is bringing a new level of abstraction to this, just like We have natural language bringing a new level of abstraction to the way that we're interacting with-

Cornelia Davis: Yep, exactly. And I think that the, probably the way of layering it is that we've had these traditional programming languages, Temporal layers an abstraction on top of that, which is durable execution.

Cornelia Davis: That's what allows Temporal to, like, figure out the, uh, abstract away the, the physical processes and the, you know, network connections and all of that stuff. We handle that for you. And then AI, the, the natural language programming sits over the top of that.

Demetrios: [00:36:00] Mm-hmm.

Cornelia Davis: So-

Demetrios: Because Temporal isn't a language per se, it's more of just like a helper.

Cornelia Davis: It's a... Yeah, it's a... I- I refer to it as a programming model.

Demetrios: Mm-hmm.

Cornelia Davis: Um, it's... We- we- our SDKs are in a bunch of different languages. We're not giving you new programming language, but what we are doing is we're giving you a new set of abstractions, so a new programming model, where instead of you deciding, oh, here's a process boundary, you basically break up your code into the t- the things that where things could go wrong.

Cornelia Davis: Like, I'm gonna make a network call here, or I'm gonna go down to a database, or maybe it's a long-running thing where you, you don't wanna have to re- recompute it if, um, something goes wrong. You put those things into activities, that's one of our primary abstractions, and then you wire the activities together in what we call workflows.

Cornelia Davis: Mm. And so that's the new programming model, and it takes a while d- to, like, it's so fundamentally different that it takes a while to kind of do that [00:37:00] minds- mindset shift. Yeah. So I had something similar where I- I did my undergraduate in the greater LA area, state school, learned all sorts of programming languages.

Cornelia Davis: They were really focused on getting you ready for industry, so it was learned half a dozen different programming languages. And then I worked for a few years, and then I decided to go back to grad school, and I went to Indiana University, which is a research university in southern Indiana. Programming languages is their thing- Mm

Cornelia Davis: so that's really where I got hardcore into programming models. Well, because they're more research-oriented, the first language that they teach their students as undergraduates is Scheme. And you could always tell the students who came in as freshmen who had already programmed in iterative programming languages like Pascal and Fortran and C and those types of things, because they had a hard time shifting their mindset- Mm

Cornelia Davis: over to a functional model. Very similar with Temporal, is that but once you make that shift, then you're like, "Oh, that's a different programming model. I can do totally [00:38:00] different things with that now."

Demetrios: Uh-huh. It enables you. So...

Cornelia Davis: Yeah.

Demetrios: Yeah. Yeah. Well, that's a perfect place to finish it. Yeah. Thank you for doing this with me.

Cornelia Davis: Thank you. It's been so fun.