PROLOG: THE OTHER BOOK ON MY DESK

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida revisits Prolog, the logic programming language that once stood close to the heart of symbolic artificial intelligence.

The episode starts with a personal memory from the beginning of his career, where Turbo Pascal and Turbo Prolog sat side by side on the desk, representing two very different ways of thinking about software.

Turbo Pascal was about telling the computer what to do. Prolog suggested something stranger and still fascinating: describe facts, rules, and relationships, then ask the machine what follows from them.

The episode explores Prolog’s origins, why it became popular in the age of expert systems and symbolic AI, what makes its programming model so different, and why its ideas still matter in areas such as rule engines, constraint solving, static analysis, explainable reasoning, and modern AI discussions.

It is also a critical look at Prolog’s place today, because while it may not be the natural choice for most modern software systems, it remains a powerful reminder that programming is not only about instructions.

Sometimes it is about knowledge, relationships, and the questions we ask.

Transcript

Copy Transcript Copied

SPEAKER_00 0:29

Welcome to the Agile Software Engineering Deep Dive, the podcast where we unpack the ideas shaping modern software engineering. My name is Alessandro Guda, and I've spent most of my career building and leading software engineering teams across several industries. Today, I want to go back to a language that many software engineers have heard about, some have studied, and relatively few have used seriously in professional systems. Prolog. This episode started with a question from my friend Henrik, who asked why I had written about Lisp, but not about Prolog. That question immediately brought me back to the beginning of my career where two books often sat side by side on my desk, TurboPascal and Turbo Prolog. TurboPascal was the practical companion, the tool I used for normal day-to-day work. Turbo Prolog felt different, more academic, more unusual, and in some ways much more mysterious. It represented another way of thinking about programming. Instead of telling the computer exactly what to do, step by step, Prolog invites us to describe facts, rules, and relationships, and then ask the machine what follows from them. In this episode, I look at where Prolog came from, why it became popular in the symbolic AI period, what makes it so different from mainstream programming languages, and why its ideas are still relevant today in areas such as rule engines, constraint solving, static analysis, explainable reasoning, and modern AI. I also try to be honest about its limitations, because Prolog is probably not the language most of us would choose for a modern cloud service, mobile app, or large commercial backend. But as a way of thinking, it still has something valuable to teach software engineers. With that, let's dive in.

SPEAKER_01 2:04

Welcome to today's deep dive, everyone. I am uh I'm really excited about this one. You know that feeling when you're like digging through an old box in the attic?

SPEAKER_02 2:13

Oh, yeah, totally. Dust everywhere.

SPEAKER_01 2:14

Right, dust everywhere. And you pull out this one object and suddenly it just brings back this flood of memories. But not only that, it kind of gives you an entirely new way of looking at the world.

SPEAKER_02 2:24

Like a totally different perspective, yeah.

SPEAKER_01 2:26

Exactly. Well, today we are doing exactly that, but for human thought and programming. Our mission today is to explore how programming languages don't just tell computers what to do, you know? They actually fundamentally change how we the humans think.

SPEAKER_02 2:41

Aaron Powell, which is a huge claim, I mean, when you really think about it.

SPEAKER_01 2:44

Aaron Powell It is. And we're basing this all on issue number 47 of the Agile Software Engineering newsletter. It's titled Prologue the Other Book on My Desk.

SPEAKER_02 2:53

A great read.

SPEAKER_01 2:53

It really is.

SPEAKER_02 2:54

Yeah.

SPEAKER_01 2:54

Now, quick bit of housekeeping before we jump in. This deep dive is completely free, but it is a massive help to us if you press like on this deep dive, subscribe to receive all future issues, and you know, repost or forward this deep dive and the related article to your friends and colleagues.

SPEAKER_02 3:11

Yeah, please do. It really helps.

SPEAKER_01 3:13

And one huge note on that source article the author included some genuinely brilliant visual code examples. And uh, I'll be honest, reading lines of code out loud is just terrible audio.

SPEAKER_02 3:25

That's the worst. It just sounds like alphabet soup.

SPEAKER_01 3:27

Right. So we are not going to do that to you today. We're gonna talk about the concepts, but please remember to read and subscribe to the full article so you can actually see those illustrations and get the full in-depth content. You really need to see them.

SPEAKER_02 3:40

You really do, yeah. Visualizing the logic makes all the difference.

SPEAKER_01 3:43

Definitely. So, okay, let's jump in. We're starting right where the author's journey began, basically at the start of their career. And it all kicked off because a friend of theirs, Henrik, asked this really simple question. Aaron Powell Yeah.

SPEAKER_02 3:55

Henrik just said, you know, why not write something about Prologue 2?

SPEAKER_01 3:58

Aaron Powell Which is such a casual question, but it sparked this vivid memory of two specific books that used to just sit on the author's desk. One was on Turbo Pascal and the other was on Turbo Prolog.

SPEAKER_02 4:10

In that contrast, I mean that is the whole story right there.

SPEAKER_01 4:12

Okay, let's unpack this. Because I like to think of Turbo Pascal as um like a trusty power drill.

SPEAKER_02 4:19

Aaron Powell A power drill, right.

SPEAKER_01 4:20

Trevor Burrus Yeah. It was the practical day-to-day tool. You pull the trigger, it spins, you use it to build things, test them, you know, debug late into the evening. But Turbo Prologue, that book was like this mysterious puzzle box.

SPEAKER_02 4:32

Aaron Powell It's a great analogy, actually.

SPEAKER_01 4:34

Thanks. So for those of us who aren't deeply entrenched in 1980s computer science, why did Prologue feel so academic? Like why was it so unusual compared to a traditional language like Pascal?

SPEAKER_02 4:45

Aaron Powell Well, the foundational difference is what they actually teach you. So Pascal taught the author how to instruct the machine, right? Step by step.

SPEAKER_01 4:52

Aaron Powell Like giving someone a recipe. First do this, then do that.

SPEAKER_02 4:56

Exactly. Initialize this variable, run this loop, stop when it hits 10. But Prologue, it proposed this radical idea. What if instead of giving steps, you just told the computer what was true?

SPEAKER_01 5:08

Aaron Ross Powell Wait, just told it what was true.

SPEAKER_02 5:10

Aaron Powell Yeah. You just give it facts. And then you simply ask it a question. It's not just a syntax change.

SPEAKER_01 5:15

Right.

SPEAKER_02 5:15

It's a complete paradigm shift. You move from execution to reasoning.

SPEAKER_01 5:18

Aaron Powell That's I mean, that's kind of mind-blowing, handing over the how and just dealing with the what.

SPEAKER_02 5:24

It really is. You're no longer micromanaging the processor.

SPEAKER_01 5:26

Aaron Powell So if Prologue is all about this, you know, this reasoning. Where did this strange philosophy even come from? Because it doesn't sound like it was made to build a banking app.

SPEAKER_02 5:36

Oh, definitely not. It was born in the early 1970s. Okay, 70s. Trevor Burrus, yeah. In Marseille, actually. Uh Elaine Kolmerauer and Philippe Roussel created it. And they had a lot of influence from a guy named Robert Kowalski on the logic side. Gotcha. And the name Prologue literally means programming in logic. Like in French, programmation en logique.

SPEAKER_01 5:55

Oh, that makes so much sense. I never actually put that together.

SPEAKER_02 5:58

Yeah. And we have to look at the era. This was the era of symbolic AI.

SPEAKER_01 6:07

Right, before neural networks took over everything.

SPEAKER_02 6:09

Exactly. Prologue wasn't built for, you know, payroll systems or GUIs. It was made for natural language processing, automated theorem-proving.

SPEAKER_01 6:17

Heavy academic stuff.

SPEAKER_02 6:18

Very heavy. Back then, researchers honestly believed human intelligence could be represented purely through symbols, like facts and rules.

SPEAKER_01 6:27

So if you could just map out enough facts, the machine would be quote unquote smart.

SPEAKER_02 6:31

That was the dream, yeah.

SPEAKER_01 6:32

Which perfectly leads into this concept in the article of building a small world. I love this part. The author demonstrates this using just everyday relationships.

SPEAKER_02 6:42

The family tree example.

SPEAKER_01 6:44

Yes. So instead of writing these crazy complex loops to find out someone's grandparents, in prologue, you just define facts. Like Alice is Bob's parent, Bob is Carol's parent.

SPEAKER_02 6:54

Right. You're literally just declaring the truth of the world.

SPEAKER_01 6:56

Exactly. And then you add a rule. A grandparent is the parent of a parent. And again, folks, remember to check out the written article to actually see this elegant code. We aren't reading it out loud, but it is so cool to see how short the code is.

SPEAKER_02 7:10

It's remarkably concise.

SPEAKER_01 7:11

And there's another example in there about city to city travel routes that uses recursive rules, which is just brilliant. But why does this declarative style actually matter under the hood?

SPEAKER_02 7:23

It matters because of what Prologue is actually doing when you run it. It searches for a logical proof.

SPEAKER_01 7:29

A proof, not an outcome.

SPEAKER_02 7:30

Right. It doesn't execute a list of instructions. It tries to satisfy your query, it takes the facts, takes the rules, and essentially searches through this maze of logic to find a path that makes your question true.

SPEAKER_01 7:40

Okay, so moving from the theory to the practice then. If describing a small world is this elegant and you just ask questions and get answers, why isn't the entire modern internet running on Prolog?

SPEAKER_02 7:52

That is the big question.

SPEAKER_01 7:53

Right. Because in the 1980s, Prolog was a huge deal. It perfectly matched this massive ambition of building expert systems.

SPEAKER_02 8:00

Oh yeah. Expert systems were the hype of the decade.

SPEAKER_01 8:03

This totally seductive idea that we could just take a doctor's medical knowledge or a lawyer's legal knowledge, perfectly captured into machine rules, and boom, AI doctors.

SPEAKER_02 8:13

It sounded flawless on paper.

SPEAKER_01 8:15

But here's where it gets really interesting. Despite this amazing pedigree, the author fully admits that Prolog wouldn't be their first choice or their second or even their fifth choice for building a modern cloud platform today. So why did Prolog lose the mainstream war?

SPEAKER_02 8:30

Aaron Powell Well, the harsh reality of modern software engineering just hit it. I mean, look at mainstream languages today C, Java, Python, Rust, Go.

SPEAKER_01 8:40

They're massive.

SPEAKER_02 8:41

They have immense ecosystems. Cloud integration is seamless. You have observability tools, massive talent pools. Prolog just doesn't have that commercial infrastructure. Trevor Burrus, Jr.

SPEAKER_01 8:50

It's kind of on an island.

SPEAKER_02 8:51

It really is. But furthermore, there's what I call the mental model wall.

SPEAKER_01 8:55

The mental model wall. Tell me more about that.

SPEAKER_02 8:58

So when programmers who are trained in traditional imperative languages try to learn Prolog, they almost always try to write it like Pascal.

SPEAKER_01 9:05

Oh, I see. They try to force step-by-step logic into it.

SPEAKER_02 9:08

Aaron Powell Exactly. They use strange punctuation, they try to force sequential execution, and it just leads to disaster. Prolog uses concepts like backtracking, unification, and search.

SPEAKER_01 9:20

So they're basically fighting the language itself.

SPEAKER_02 9:22

Completely fighting it. It requires a totally different brain space. And frankly, that brain space isn't always commercially convenient when you have a tight deadline.

SPEAKER_01 9:30

You don't want to rewrite your entire way of thinking just to ship a feature by Friday.

SPEAKER_02 9:34

Exactly.

SPEAKER_01 9:35

But even though Prolog didn't achieve, you know, world domination, its ideas didn't die, did they?

SPEAKER_02 9:41

Not at all. They evolved.

SPEAKER_01 9:42

And they're suddenly becoming incredibly relevant to our modern AI boom, which I find fascinating. Where does Prolog's DNA actually live today?

SPEAKER_02 9:56

You'll find its descendants in some very powerful tools. Things like Datalog, CodeQL, and Souffle.

SPEAKER_01 10:02

Code QL? I've heard of that one. GitHub uses it, right?

SPEAKER_02 10:04

Yeah, it's heavily used for large-scale static analysis. Basically, you treat your code base like a database of facts and you query it for security vulnerabilities.

SPEAKER_01 10:14

Oh, so you're using logic rules to say, find me the security flaw instead of reading line by line.

SPEAKER_02 10:19

Exactly. It's constraint solving. Verification tools rely on this declarative logic heavily.

SPEAKER_01 10:24

Which brings us to the article's contrast between prologue and modern neural networks, like large language models. And this analogy is just perfect. The author says modern AI is like this brilliant savant.

SPEAKER_02 10:37

The savant, yeah.

SPEAKER_01 10:38

You ask a question, it gives you an amazing answer. But if you ask it, hey, how did you get that answer? It has no idea. It just predicted the next word.

SPEAKER_02 10:47

It can't explain its work.

SPEAKER_01 10:48

Right. Whereas Prolog is like a meticulous mathematician. It shows every single step of the proof. Why does that distinction actually matter in the real world?

SPEAKER_02 10:56

Aaron Powell What's fascinating here is the absolute critical need for explainability. Explainability? Yes. Think about safety critical systems, medicine, law, railway networks.

SPEAKER_01 11:05

Aaron Powell Oh, right. You don't want an AI just guessing if the train should switch tracks.

SPEAKER_02 11:10

Exactly. You can't just have a statistical guess from a neural network in those domains. You need to know why the answer follows. If a medical AI denies a treatment, the doctor needs to know the exact logical proof that led to that decision.

SPEAKER_01 11:24

That makes a lot of sense. You can't just say the black box said so.

SPEAKER_02 11:28

I really can't. So the old questions the prologue asked: how do we represent knowledge? How do we explain conclusions? They are more vital today than they ever were.

SPEAKER_01 11:39

Which brings us to the author's ultimate conclusion and really the heart of this whole deep dive. The real value of having that turbo prologue book on the desk wasn't about using it in production.

SPEAKER_02 11:49

No, not at all.

SPEAKER_01 11:50

It was about opening a mental door.

SPEAKER_02 11:52

I love how the author breaks down what different languages teach us as mental models.

SPEAKER_01 11:56

Yeah, let's go through that because it's so insightful. So C teaches you about memory and control. You're right down there with the hardware.

SPEAKER_02 12:03

Lisp teaches you about symbolic structures and recursion.

SPEAKER_01 12:06

Smalltalk teaches you to think in objects. Everything is an object sending a message.

SPEAKER_02 12:11

And SQL teaches you to think in sets.

SPEAKER_01 12:13

Right. And Prolog. Prologue teaches us to reason from facts and rules.

SPEAKER_02 12:17

Which is such a powerful tool for anyone listening to this.

SPEAKER_01 12:20

Even if they never write prologue.

SPEAKER_02 12:22

Even if you never write a single line of prologue in your life. Thinking like a logician helps you design domain models. It helps you untangle messy business rules and build better configuration systems.

SPEAKER_01 12:33

Because it forces you to separate things.

SPEAKER_02 12:35

Exactly. It teaches you to separate what is true about your system from what should be done by your system.

SPEAKER_01 12:41

Aaron Ross Powell That is just it's such a profound way to look at software engineering. So what does this all mean? We started with the feeling of finding a dusty book on turbo prologue in the attic. And it turned into this profound lesson on how the tools we use literally shape the way we construct logic in our own heads.

SPEAKER_02 12:59

It's a journey for sure.

SPEAKER_01 13:00

It really is. Before we wrap up, a final enthusiastic reminder for everyone listening. Please remember to read and subscribe to the full article for the in-depth content and those amazing code illustrations. Like we said, this deep dive is free, but your support is crucial.

SPEAKER_02 13:15

Please press like.

SPEAKER_01 13:16

Yes. Press like, subscribe for all future issues, and repost and forward this deep dive and the article to your friends and colleagues. We really appreciate it.

SPEAKER_02 13:25

Definitely. And you know, I want to leave you with a final thought to mull over.

SPEAKER_01 13:29

Oh, go for it.

SPEAKER_02 13:30

If every programming language teaches us a specific way to think, specific mental model.

SPEAKER_01 13:35

Yeah.

SPEAKER_02 13:36

How is our modern reliance on generating code through AI chatbots reshaping the mindset of the next generation of engineers?

SPEAKER_01 13:44

Oh, wow.

SPEAKER_02 13:45

Right. If we stop explicitly describing the truth or even writing the step-by-step instructions, and we just accept whatever the statistical model outputs, what kind of mental door is that closing for us?

SPEAKER_01 13:57

That is wow. That is a terrifying and fascinating thought to end on. If we outsource the logic, do we lose the mental model entirely?

SPEAKER_02 14:04

Something to think about.

SPEAKER_01 14:05

Definitely something to think about. Thank you all for joining us on this deep dive. See you next time.

SPEAKER_00 14:21

Thank you for listening to the Agile Engineering Deep Dive Podcast. If you found this episode valuable, feel free to share it with someone who might benefit. A colleague, your team, or your network. You can access all episodes by subscribing to the podcast and find their written counterparts in the Agile Software Engineering newsletter on LinkedIn. And if you have thoughts, ideas, or stories from your own engineering journey, I'd love to hear from you. Your input helps shape what we explore next. Thanks again for tuning in. And see you in the next episode.