Agile Software Engineering

Alessandro

0.0 (0)
Technology

This podcast explores how craftsmanship, architecture, engineering rigor, and organizational practices come together in modern R&D environments. Each edition refines and deepens my earlier reflections, building a coherent and evolving body of knowledge around Agile Software Engineering

3d ago

THE POWER OF RECURSION

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida revisits recursion, one of the classic ideas in Computer Science and still one of the most useful ways to think about problem solving. The episode starts with a personal memory from Computer Science studies, where recursion stood out as something surprisingly elegant: a way to solve a complex problem by reducing it to a smaller version of the same problem. Using the Tower of Hanoi puzzle as a concrete example, the episode explains what recursion is, why a recursive function needs a base case, how recursive calls interact with the call stack, and why execution continues from the right place when each call returns. It also connects recursion to mathematical induction, decomposition, correctness, and clean design, showing why recursion is more than a programming technique. It is a disciplined way of thinking about structure. The episode is both a refresher and a practical reminder that some old Computer Science ideas still matter deeply in modern software engineering. Sometimes the best way to solve a big problem is to understand the smaller one hiding inside it. Support the show This Podcast is an audio version of the written Agile Software Engineering newsletter. If you want to go deeper, don't forget to subscribe the newsletter too.
Sep 2

PROLOG: THE OTHER BOOK ON MY DESK

Send us Fan Mail 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. Support the show This Podcast is an audio version of the written Agile Software Engineering newsletter. If you want to go deeper, don't forget to subscribe the newsletter too.
Aug 26

THINKING SLOW, THINKING FAST AND INTUITION IN SOFTWARE ENGINEERING

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores intuition in software engineering through Daniel Kahneman’s ideas about fast and slow thinking. The episode looks at how years of experience can turn deliberate reasoning into fast pattern recognition, why this matters in debugging, code review and architecture, and where intuition can become dangerous when confidence grows faster than evidence. It also explores the relationship between intuition and first-principles thinking, and asks what these human capabilities may mean in a world where AI can generate increasingly convincing software at remarkable speed. And, of course, it answers one important question: why does John earn so much? Support the show This Podcast is an audio version of the written Agile Software Engineering newsletter. If you want to go deeper, don't forget to subscribe the newsletter too.
Aug 19

First Principles in Software Engineering

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores what first-principles thinking means and how it can be applied to software engineering. The episode moves from the philosophical roots of first principles into practical engineering questions about architecture, Agile, microservices, technical debt, software quality, and AI-assisted development. The core idea is simple: before choosing methods, tools, frameworks, or fashionable solutions, we should understand what is fundamentally true about the problem, the system, and the engineering responsibility behind it. Support the show This Podcast is an audio version of the written Agile Software Engineering newsletter. If you want to go deeper, don't forget to subscribe the newsletter too.
Aug 13

WHO WROTE THIS? Can AI Detectors Really Distinguish Human Writing from AI-Assisted and AI-Generated Text?

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores whether AI detectors can really distinguish human-written, AI-assisted, and AI-generated text. Using one original science-fiction passage in three different versions, he compares the results from five popular detection services and finds striking differences between them. The episode also looks at how these detectors work, what their scores really mean, and why the distinction between AI-assisted and AI-generated content is becoming increasingly important. Support the show This Podcast is an audio version of the written Agile Software Engineering newsletter. If you want to go deeper, don't forget to subscribe the newsletter too.
Aug 7

Is There Any Science in Science Fiction? And What Can we use It For?

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores the science behind some of his favourite science-fiction stories, including 2001: A Space Odyssey, Rendezvous with Rama, Project Hail Mary, Interstellar and Arrival. The episode looks at what these stories got scientifically right, where imagination took over, and how science fiction can inspire real innovation. Alessandro also shares the personal story of how American Graffiti inspired him to help build one of Italy’s earliest private radio stations. Support the show This Podcast is an audio version of the written Agile Software Engineering newsletter. If you want to go deeper, don't forget to subscribe the newsletter too.
Jul 31

How to hit the target every time. Iterative vs. Agile development.

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores a simple but powerful idea: the shortest path to building the right software is to keep understanding and implementation in sync. Using a clear visual model, the episode examines why both Waterfall and “just start coding” lead to rework, how Agile attempts to balance the two through iteration, and where it often drifts in practice. It also introduces a more intentional iterative approach that focuses on aligning knowledge and execution throughout the development process. Support the show This Podcast is an audio version of the written Agile Software Engineering newsletter. If you want to go deeper, don't forget to subscribe the newsletter too.
Jul 23

It’s Not What You Learn, But How You Learn - Even If You Are An AI

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores the difference between generating code and learning software engineering. Modern coding AI has been trained on enormous quantities of publicly available software. Some of that code is excellent, but much of it is also outdated, inefficient, insecure, poorly tested, difficult to maintain, or disconnected from the realities of commercial software development. The episode examines several recurring concerns in AI-generated software: black-box code that developers may accept without fully understanding, inefficient implementations, error handling that does not integrate with the surrounding product, inconsistent security, and user interfaces created without user research, workflow analysis, prototyping, or human feedback. It also considers a more systemic risk: what happens when AI-generated code increasingly becomes part of the training material for future AI models? Weak patterns may be copied, normalised, and amplified until commonly generated code is mistaken for well-engineered code. More agents do not automatically mean better software. Ten coding agents today and fifty tomorrow may simply produce more code, more complexity, and more work that still requires human review. AI can be an extraordinarily valuable engineering tool, but it does not assume responsibility for the result. The engineer remains accountable for understanding, testing, securing, maintaining, and operating whatever ultimately enters the product. The episode concludes with The Old Grumpy Engineer’s Trust Test, a humorous examination of whether engineering trust should ever be granted automatically-and a brief, nostalgic appearance from Clippy. Support the show This Podcast is an audio version of the written Agile Software Engineering newsletter. If you want to go deeper, don't forget to subscribe the newsletter too.

This podcast explores how craftsmanship, architecture, engineering rigor, and organizational practices come together in modern R&D environments. Each edition refines and deepens my earlier reflections, building a coherent and evolving body of knowledge around Agile Software Engineering

Creator

Alessandro
Years Active

2025 - 2026
Episodes

49
Rating

Explicit
Copyright

© 2026 Agile Software Engineering
Show Website

Agile Software Engineering