Agile Software Engineering

Send us Fan Mail

Could we actually build computers that use DNA molecules to perform calculations?

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores one of the most unusual and fascinating approaches to computing: using DNA and molecular interactions to process information.

The story begins in 1994, when computer scientist Leonard Adleman demonstrated that DNA could solve a mathematical problem involving possible routes through a network.

More than thirty years later, researchers have developed molecular logic gates, DNA circuits, biosensors and even programmable DNA computers capable of performing different mathematical operations.

But how does computation actually work inside a test tube, what advantages could molecular computing offer, and why are we still so far from replacing conventional processors?

The episode explores the history of DNA computing, its potential applications in biotechnology and medical diagnostics, and the latest developments in molecular computation.

And finally, we venture into more speculative territory by asking whether DNA computing and quantum computing could eventually converge, particularly as researchers begin using DNA nanotechnology to construct components for quantum devices.

An accessible exploration of a technology that challenges our traditional understanding of computers and reminds us that some of the most inspiring engineering ideas come from looking beyond the technologies we already know.

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.

Send us Fan Mail

What exactly makes us uniquely human, and could artificial intelligence eventually replicate those characteristics too?

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores one of the most intriguing arguments in the debate about AI and the future of humanity: the belief that certain human characteristics will always remain beyond the reach of machines.

But what happens when we try to define those characteristics scientifically?

The episode examines creativity, curiosity, intuition, humour, theory of mind, empathy, morality, values, intentionality, self-awareness and consciousness, exploring what each characteristic actually means, how AI already demonstrates some of the associated behaviours, and what future developments might make possible.

Could AI learn humour by observing human reactions? Could a personal AI develop something resembling genuine care by learning to support our long-term well-being? Could self-awareness emerge as an AI increasingly learns to observe its own internal processes?

And perhaps the most difficult question of all: could AI ever become conscious when we still do not fully understand consciousness ourselves?

The discussion also considers what these questions mean for the future of work and whether AI really needs to become human to perform tasks we currently consider uniquely human.

An exploration of science, technology and philosophy that challenges some familiar assumptions about artificial intelligence and what makes us human.

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.

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.

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.

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.

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.

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.

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.

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.

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.