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

2d ago

THE TECHNOLOGIES YOU SHOULD START LEARNING BEFORE YOU NEED THEM

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida looks at eight technologies software engineers may want to understand before they suddenly become mainstream. The episode explores on-device AI and TinyML, quantum computing, post-quantum cryptography, heterogeneous computing with GPUs and NPUs, WebAssembly and WASI, confidential computing, eBPF, and Rust. The focus is not on predicting which technology will dominate the future, but on understanding the ideas early enough that you recognise them when they begin to matter. Along the way, the episode looks at why AI is moving onto devices, why quantum computing demands a different way of thinking about computation, how post-quantum cryptography is already changing security planning, why specialised processors are becoming more important, and how technologies such as WebAssembly, eBPF, confidential computing, and Rust are reshaping parts of modern software engineering. Each topic is also paired with a practical next step, because the best way to understand an emerging technology is usually to install something, run something, change something, and see what happens. The broader message is simple: software engineering changes continuously, and curiosity remains one of the most valuable skills we can develop. 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.
5d ago

QUANTUM COMPUTING: THE ARTICLE I HAVE BEEN AVOIDING

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida takes a software engineer’s first serious look at quantum computing. The episode starts with the basic questions: where did the idea of quantum computing come from, what is a qubit, and why does a quantum computer behave so differently from the machines we use today? From there, the discussion explores superposition, measurement, entanglement, interference, quantum gates, and quantum circuits, with a strong focus on understanding what actually happens during a quantum computation. The episode also looks at Grover’s search algorithm and Shor’s factoring algorithm, including why Shor’s work has already influenced the move toward post-quantum cryptography. There is also a look at the competing hardware technologies, the software ecosystems being built by Microsoft, Google, and IBM, and the increasingly important relationship between quantum computing and classical software systems. The broader question is whether software engineers should care about quantum computing before it becomes commercially widespread. The answer may have less to do with predicting the future and more to do with what quantum computing teaches us about computation itself. 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.
Oct 8

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.

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

55
Rating

Clean
Copyright

© 2026 Agile Software Engineering
Show Website

Agile Software Engineering