Podcast
Agile Software Engineering
Hosted by Alessandro · EN
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
12episodes
Episodes
Newest firstAll episodes
The Art of Painting Yourself into a Secure Corner
2w ago00:23:35Tap to summarizeSend us Fan MailIn this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores what happens when corporate security is added in layers without enough attention to workflow, usability, recovery, and productivity.Using the metaphor of painting yourself into a corner, the episode looks at a familiar modern workplace problem: VPNs, tunnels, multi-factor authentication, device compliance, strict password policies, authenticator apps, app PINs, short screen timeouts, and repeated confirmation prompts that may each make sense in isolation, but together can create serious friction for employees.This is not an episode against security. Quite the opposite.It is an episode about designing security properly.The discussion covers why security should be treated as an engineering system with real users, real workflows, measurable performance requirements, failure modes, and recovery paths. It also looks at common traps such as MFA recovery loops, where the system sends the confirmation code to the very phone that has just been lost.The episode argues that security teams and engineering teams should ask a simple but often forgotten question:How does the complete workflow actually work for the human being who has to use it?From use cases and workflow testing to acceptable friction, hardware support, passkeys, biometrics, and better recovery design, this episode is a reminder that good security should not only reduce risk. It should also help people work safely without constantly fighting the system.Because the most secure system in the world is not very useful if nobody can get their work done.Support the showThis 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.
Transcribe →YACC? What Is That? Why Compiler Thinking Still Matters (Compiler Theory part 2)
3w ago00:23:45Tap to summarizeSend us Fan MailIn this episode of The Agile Software Engineering Deep Dive, Alessandro Guida continues the two-part journey into compiler theory.Part 1 focused on BNF, syntax, and grammar. Part 2 moves into compiler thinking itself: LEX, YACC, compilers, interpreters, syntax trees, the Dragon Book, and the evolution from classic compiler pipelines to modern development ecosystems.For many software engineers who studied computer science in earlier decades, compiler theory was part of the foundation. It taught us how programming languages are defined, parsed, checked, transformed, optimized, and executed.Today, most developers are not writing compilers by hand. But the ideas behind compilers are still everywhere: in build systems, query engines, static analyzers, IDEs, code generators, rule engines, security scanners, infrastructure-as-code tools, and AI coding assistants.This episode explores why compiler thinking still matters when we design APIs, configuration formats, workflow definitions, domain-specific languages, rule systems, and AI-assisted development tools.It also revisits the classic distinction between compilers and interpreters, explains how modern compilers have evolved, and reflects on the connection between programming languages and AI prompts.This is not a nostalgic look back at old tools.It is a reminder that when human intent must become reliable machine action, the old lessons of compiler theory are still surprisingly modern.Support the showThis 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.
Transcribe →
Before You Add Macros, Learn BNF (Compiler Theory part 1)
4w ago00:23:19Tap to summarizeSend us Fan MailIn this episode of The Agile Software Engineering Deep Dive, Alessandro Guida begins a two-part journey into compiler theory with a look at Backus-Naur Form, or BNF.For many software engineers who studied computer science in earlier decades, BNF belonged to the world of compilers, formal languages, syntax, parsing, YACC, and the famous Dragon Book. Today, many developers may never encounter it directly.But the need for it has not disappeared.Whenever we add formulas, macros, templates, filters, workflow conditions, configuration syntax, rule engines, or domain-specific languages to an application, we are doing language design. Often informally. Often accidentally.And that is where complexity starts to grow.This episode explains why syntax is not just documentation, why a small language is still a language, and why grammar matters when applications become programmable.It is not a call for every developer to become a compiler engineer. It is a reminder that some old computer science disciplines remain deeply relevant, especially when we give users the ability to express logic inside our systems.Part 1 focuses on BNF, syntax, and grammar.Part 2 will continue with compiler thinking more broadly: lex, YACC, compilers, interpreters, the Dragon Book, and why the discipline still matters in the age of modern development tools and AI-generated code.Support the showThis 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.
Transcribe →
Lisp: The Strange Little Language That Helped Invent AI
Jun 2500:23:43Tap to summarizeSend us Fan MailIn this episode of The Agile Software Engineering Deep Dive, Alessandro Guida takes a historical and slightly playful look at Lisp - one of the strange little languages that helped shape the early world of artificial intelligence.Long before AI became associated with Python, neural networks, GPUs, and large language models, artificial intelligence was also about symbolic reasoning, rules, lists, logic, search, and knowledge representation. Lisp was built for that world. Its focus on symbolic expressions, recursion, lists, and the close relationship between code and data made it a natural fit for early AI research.This episode is not a call to abandon modern AI tools and return to 1960s programming. It is an invitation to understand where some of the deeper ideas in AI and software engineering came from - and why an old language full of parentheses can still feel strangely modern.Support the showThis 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.
Transcribe →
A Field Trip into Software Engineering Memory Lane
Jun 1800:26:58Tap to summarizeSend us Fan MailIn this episode of The Agile Software Engineering Deep Dive, we take a field trip into software engineering memory lane.Modern software teams have better tools than ever: CI/CD pipelines, cloud platforms, automated testing, observability, feature flags, and now AI assistants. But better tools do not remove the need for engineering discipline.This episode revisits a set of older or half-forgotten practices that still ask very relevant questions: Zero Bug Bounce, Zero Bug Strategy, Definition of Done, Entry and Exit Criteria, Code Freeze, Bug Triage, Root Cause and Defect Escape Analysis, Regression Test Strategy, Usability Lab Testing, and Performance Testing.The purpose is not to bring back old bureaucracy. It is to recover the practical engineering questions hidden inside these practices.Are we stabilizing? Are known defects visible? Does done really mean done? Do we understand what our bugs are teaching us? Do we know what must never break silently? Are users actually able to use the product? And do we detect performance degradation before it becomes failure?Modern tools can help us move faster and with better evidence.But they do not remove the need to ask the right engineering questions.Support the showThis 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.
Transcribe →
AI, Philosophy, and the Many Shapes of Thinking
Jun 1100:24:13Tap to summarizeSend us Fan MailIn this episode of Agile Software Engineering Deep Dive, we take a more reflective look at artificial intelligence.When we discuss AI, we often compare it to human intelligence, as if humanity were the only valid model for thinking. But is that the right comparison?This episode explores how AI brings old philosophical questions back into modern software engineering. We look at Turing’s imitation game, Searle’s Chinese Room, Descartes’ ideas about language and reason, and Plato’s distinction between knowledge and appearance.We also discuss why intelligence may not have one single architecture. Symbolic AI, neural networks, neuro-symbolic AI, embodied AI, neuromorphic computing, and biological computing all suggest that thinking may have many possible forms.The central question is not whether AI is already human. It is not.The deeper question is whether AI helps us understand that intelligence was never only one thing.Support the showThis 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.
Transcribe →
SAFe Light - Part 3: Beyond Story Points
Jun 300:23:52Tap to summarizeSend us Fan MailIn this episode of The Agile Software Engineering Deep Dive, Alessandro Guida continues the SAFe Light series with a discussion about estimation.Estimation is often treated as a promise, even though it is by definition an approximation made under uncertainty. This episode explores why false precision creates mistrust, why story points and velocity can hide uncertainty, and why better estimation starts with better understanding.The episode introduces a practical SAFe Light estimation model: no-estimate for small low-risk work, lightweight breakdown when teams need grounded understanding, WBS-based estimation when predictability matters, and exploration before estimation when the work is still too unclear.The central idea is simple: estimation should not create false confidence. It should create understanding, expose dependencies, reveal architectural risks, and support better decisions.Support the showThis 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.
Transcribe →
SAFe Light - Part 2: Evolutionary Architecture
May 2300:25:15Tap to summarizeSend us Fan MailIn this episode of The Agile Software Engineering Deep Dive, Alessandro Guida continues the discussion on SAFe Light and explores why lightweight Agile scaling needs evolutionary architecture.SAFe Light is based on preserving team autonomy while making the essential coordination points visible. But that only works if the architecture supports independent change. Without clear boundaries, explicit dependencies, contract-based integration, fitness functions, and continuous feedback, teams may appear autonomous while remaining blocked by hidden coupling and integration surprises.The episode introduces evolutionary architecture as architecture planned for change: a disciplined way to let systems evolve incrementally without losing coherence. It also explains why strong architecture can reduce the coordination burden in scaled Agile environments.The central idea is simple: when architecture is weak, process expands to compensate. When architecture is strong, process can remain lighter.Support the showThis 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.
Transcribe →
Self-Learning Machines - What Happens When AI Starts Learning from Itself?
May 1500:20:42Tap to summarizeSend us Fan MailIn this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores one of the most important questions in the next phase of artificial intelligence: what happens when AI starts learning from itself?For years, generative AI has been trained largely on human-created material from the internet. But the internet is changing. More and more text, images, code, summaries, documentation, and online content are now generated or heavily assisted by AI. That raises a difficult question: when future AI systems are trained on the output of earlier AI systems, will they become more capable, or will they slowly lose contact with the richness and diversity of human knowledge?The episode examines both sides of the self-learning machine problem. On one side, poorly controlled recursive training may lead to model collapse, narrowing, and fluent but less grounded outputs. On the other side, well-designed self-learning loops may accelerate progress in areas such as strategic games, reasoning systems, medical treatment optimization, synthetic data generation, and scientific discovery.The central distinction is simple but important: a bad loop says generate, consume, repeat; a good loop says generate, test, filter, learn, repeat. The future of AI may depend less on whether machines learn from machines, and more on whether those learning loops remain connected to reality, evidence, constraints, and human judgment.Support the showThis 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.
Transcribe →
Please, Stop Saying Generative AI Is “Just” a Statistical Machine
May 800:24:22Tap to summarizeSend us Fan MailIn this episode of The Agile Software Engineering Deep Dive, Alessandro Guida challenges one of the most common simplifications about generative AI: that it is “just a statistical machine guessing the next most likely word.”There is a small technical truth in that statement, but it misses the most important part of what happens inside a modern AI model. Before any token is generated, the input is transformed through embeddings, attention mechanisms, neural network layers, contextual representations, and inference. Probability is part of the process, but it is the final step - not the whole explanation.The episode explains, in accessible engineering language, why generative AI is not a human mind, not a truth machine, but also not a simple autocomplete toy. It explores how layered neural processing, context, intent, and representation allow these systems to produce surprisingly coherent and useful outputs - and why reducing all of that to “just guessing the next word” is not an explanation, but an oversimplification.Support the showThis 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.
Transcribe →