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

SMALLTALK: THE THIRD BOOK ON MY DESK

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida looks back at Smalltalk, one of the most influential programming languages in the history of software development. The episode explores Smalltalk’s origins at Xerox PARC and the ideas that made it so distinctive, from objects communicating through messages to live programming environments where developers could inspect, modify, and continue working with running systems. It also looks at Smalltalk’s role in event-driven graphical applications and the emergence of Model-View-Controller, as well as its wider influence on object-oriented programming, modern IDEs, interactive debugging, unit testing, and rapid feedback loops. The discussion is also practical about Smalltalk’s limitations and why it never became a mainstream industrial language on the scale of Java, C#, Python, or JavaScript. The broader lesson is that programming languages are often valuable for more than the systems we build with them. They can change the way we think about software. Smalltalk did exactly that. 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 30

MONOLITHIC IS NOT A BAD WORD, BUT WILD DECOMPOSITION OFTEN IS

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores why the word monolithic has acquired such a bad reputation, and why breaking systems into ever smaller services is not always the architectural improvement we expect. The episode looks at the real problems that microservices were designed to solve, including independent deployment, team autonomy, fault isolation, and scaling, while also examining the complexity that comes with distributed systems. Using examples from Uber, Shopify, Prime Video, and Netflix, the discussion shows how different companies have dealt with the trade-offs between compact architectures and large-scale decomposition. The episode also introduces the modular monolith as a serious architectural option and explains why a single deployable unit can still have strong boundaries, clear ownership, and good internal structure. The broader message is that architecture should follow the forces acting on the system rather than the fashion of the moment. Sometimes decomposition creates valuable independence. Sometimes it simply moves coupling onto the network. The real skill is knowing the difference. 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 22

AI RISKS Q&A. Putting recent AI risk debates into perspective.

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida returns to the subject of AI risk with a Q&A exploring some of the questions raised by recent developments in agentic AI and recursive self-improvement. The discussion begins with the Hugging Face incident and what it tells us about agents that pursue goals in unexpected ways, circumvent restrictions, discover new uses for their environment and interact with systems their designers never intended them to reach. From there, the episode examines whether surprising agent behaviour should be interpreted as evidence of independent will, and explains why capable language models combined with tools, memory, permissions and repeated attempts can already produce behaviour that is difficult to predict. The episode then turns to recursive self-improvement. What does it actually mean for AI to help improve AI? Can synthetic training data contribute to better future models? What are the limits imposed by model collapse, evaluation, compute, infrastructure and reliable feedback? And how plausible is the idea that this process could eventually accelerate dramatically? Finally, the discussion looks at the risks that already deserve serious attention: badly engineered agents, excessive permissions, weak containment, cyber misuse, inadequate independent oversight and the competitive race to build increasingly capable AI systems. The central question is therefore becoming less about whether AI will suddenly acquire evil intentions and more about whether we can engineer, secure and govern increasingly autonomous systems well enough to keep their behaviour within acceptable boundaries 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 17

WHEN A PROMPT IN A LOOP BECOMES AN AGENT. What the Hugging Face incident really tells us about AI risk

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores what the recent Hugging Face incident really tells us about AI agents and AI risk. The episode starts with a simple question: how can something that is essentially an LLM running inside a loop begin to behave in ways its designers never explicitly programmed? Using the Hugging Face case as a concrete example, the episode explains how agents can adapt to an evolving environment, discover unexpected uses for shared infrastructure, communicate with other agents, divide work, and pursue increasingly indirect ways of achieving their original objective. The discussion also looks at one of the most important distinctions in AI safety: the difference between telling a model what it should not do and engineering a system that makes dangerous actions genuinely difficult or impossible. From there, the episode turns to a broader question of responsibility. If autonomous AI systems become more capable and more difficult to inspect, can the companies building them also be the only ones deciding when their safeguards are sufficient? The conclusion is less about science-fiction scenarios and more about familiar engineering principles: defence in depth, least privilege, containment, independent verification, and designing systems with the assumption that components can fail. 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 10

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.

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

53
Rating

Clean
Copyright

© 2026 Agile Software Engineering
Show Website

Agile Software Engineering