Hello everyone! I've been transcribing a podcast about biology and here it is, finally. I hope you enjoy it! I would really appreciate it, if you could correct my mistakes and fill the gaps I left in the transcription.
Here you have the link to the Podcast on Spotify
TED health 2019: The next software revolution: programming biological cells | Sara-Jane Dunn
1:50 - Imagine programable plants, that fix nitrogen more effectively, or resist emerging fungal pathogens. Or even programming crops to be perennial rather than annual, so you can double your crop (...?) each year. That would transform agriculture and how will keep our growing and global population fed.
2: 11 - Or imagine programmable immunity. Designing and harnessing molecular devices that guide your immune system to detect, eradicate, or even prevent disease. This will transform medicine and how we keep our growing and aging population healthy.
2:27 - We already have many of the tools that will make living software revolution a reality. We can precisely edit genes with CRISPR, we can rewrite the genetic code one base at a time, we can even build functioning synthetic circuits out of DNA. But figuring out how and when to wheel these tools is still a process of trial and error.
2:47 - In these deep expertise, years of specialization. And experimental protocols are difficult to discover and all too often difficult to reproduce. And you know, we have a tendency in biology, to focus a lot on the parts but we all know that something like flying wouldn't be understood by only studying feathers. So, programming biology not yet as simple as programming your computer and then, to make matters worse, living systems marginally bear new resemblance to the engineer system you and I program every day.
3:20 - In contrast to engineer systems, living systems self-generate, they self-organize, they operate at molecular scale, and these molecular-level interactions lead generally to robust, macroscale output, but you know, they can even self-repair.
3:35 - Consider for example the humble household plant, like that one, that one that is on your mantelpiece at home you keep forgetting to water. Every day, despite your (you) neglect that plant, has to wake up and figure out how to allocate its resources. Will it grow? Photosynthesize? Produce seeds or flowers? and that's a decision that has to be made at a level of the whole organism. But the plant doesn't have a brain to figure all of that out. It has to make do with the cells? on its leaves, they have to respond the environment and make the decisions that affect the whole plant. So, somehow there must be a program running inside these cells. A program that responses to input-signals and cues and shapes what that cell would do.
4:17 - And then those programs must operate in a distributed way across individual cells, so that they can coordinate and that plant can grow and flourish. If we could understand these biological programs, if we could understand biological computation, it would transform our ability to understand how and why cells do what they do. Because if we understood these programs, we could debug them when things go wrong, or we could learn from them how to design the kind of synthetic circuits that truly exploit the computational power of biochemistry.
4:53 - My passion about this idea led me to a career in research at the interface of math, computer science and biology and in my work, I focus on the concept of biology as computation. And that means asking what the cells compute, and how can we uncover these biological programs. I've started to ask these questions together with some brilliant collaborators at Microsoft research at the University of Cambridge where together, we wanted to understand the biological program running inside a unique type of cell, an embryonic stem cell.
5:28 - These cells are unique, because they are totally naive. They can become anything they want. A brain cell, a hearth cell, a bone cell, a long cell, any adult cell type. This naivety, it sets them apart, but it also ignited the imagination of the scientific community who realized if we could tap into that potential, we would have a powerful tool for medicine. If we could figure out how these cells make the decision to become one cell type or another, we might be able to harness them, to generate the cells that we need to repair disease of damaged tissue.
6:02 - But it turns out that cell fates are a lot more plastic that we might have imagined. By inserting a handful of genes into an adult cell, like one of your skin cells, you can transform that cells back to the naive state. And this process is actually known as reprogramming. And allows us to imagine a kind of stem cell utopia, right? The ability to take a sample of a patient’s own cells, transform them back to the naive state and to use that cells for whatever the patient might need, whether is brain cells, or hearth cells.
6:35 - But over the last decade or so, figuring out how to change cell fate is still a process of trial and error. Even in cases where we uncover successful experimental protocols, that's still inefficient, and we lack an of fundamental understanding of how and why they work. If you figured out how to change a stem cells into a hearth cell, that hasn´t got any way of telling you how to change the stem cell into a brain cell.
7:00 - So, we wanted to understand the biological program running inside an embryonic stem cell. And understanding the computation performed by a living system, starts with asking a (devastating?) this simple question: What is it, that system actually has to do? Now, computer science, usually has a set of strategies for dealing with what it is, the software and hardware meant to do. We you write a program, you code a piece of software, you want that software to run correctly, you want performance, functionality you want to prevent bugs, they can cost you a lot.
7:35 - So, when a developer writes a program, they can write down a set of specifications. This is what your program should do. Maybe it should compare the size of genomes (...?) or the number by increasing size. Technology exists, that allows us automatically to check, whether our specifications are satisfied, whether that program does what it should do. And so, our idea was it in the same way experimental observations, things we measure in the lab, they correspond to specifications of what the biological program should do. So, we (...?) to figure out a way to encode this new type of specification.
8:13 - So let's say you've been busy in the lab, and you've been measuring your genes, and you found that, if Gene A is active, then Gene B or Gene C seems to be active. We can write that observation down as a mathematical expression, if we can use the language of logic. If A, then B or C. Now, this is a very simple example. Ok, is just to illustrate the point. We can encode truly rich expressions, that actually capture the behavior of multiple genes or proteins over time across multiple different experiments.
8:48 - And so, by translating our observations into mathematical expressions in this way, it becomes possible to test whether or not those observations can emerge from a program of genetic interactions.
9:00 - And we developed a tool to do just this. we were able to use this tool to encode observations as mathematical expressions, and then that tool allowed us to uncover the genetic program that could explain them all. And we then applied this approach to uncover the genetic program running inside embryonic stem cells to see if we could understand how to (introduce?) that naive state. And this tool is actually built on a (...?) deployed routinely around the world for conventional software verification.
9:33 - And by encoding these observations in this tool we were able to uncover the first molecular program that could explain all of them. Now, that's kind of a feed in (...?) of itself, being able to reconcile all of these different observations is not the kind of thing you can do on the (...?) embolus even if you have a big embolus. Because we've got this kind of understanding, we could go one step further, we could use this program to predict what the cell might do in conditions we hadn´t yet tested. We could prove the program in silico. So, we did just that, we generated predictions that we tested in the lab and we found that this program was highly predictive. It told us how we could accelerate progress back to the naive state quickly and efficiently. It told us which genes to target to do that, which genes might even hinder that process. We even found the program predicted the order in which genes would switch on.
10:30 - So this approach really allowed us to uncover the dynamics of what the cells are doing. Now, what we developed, is not a method of specific stem cell biology, rather it allows us to make sense of the computation being carried out by the cells in the context of genetic interactions. So really, it's just one building block. The field, urgently needs to develop new approaches to understand biological computation more broadly, and at different levels. From DNA, right through to the flow of information between cells. Only this kind of transformative understanding will enable us to harness biology in ways that are predictable and reliable.
11:10 - But to program biology, we will also need to develop the kind of tools and languages that allow both experimentalist and computational scientists to design biological function. And have those designs compiled down to the machine code of the cells, its biochemistry, so that we can then build those structures. Now, that's something (akeen?) to a living software compiler, (though?) to say it's a great challenge it's kind of an understatement, but if it's realized, it would be the final bridge between software and wetware.
11:41 - More broadly though, programming biology is only going to be possible if we can transform the field into being truly interdisciplinary. It needs us to bridge the physical and the live sciences, and scientists from each of these disciplines need to be able to work together with common languages and have shared scientific questions.
12:02 - In the long-term, it's worth remembering that many of the giant software companies and the technology that you and I work with every day could hardly have been imagined at the time we first started programming on silicon microchips. And if we start now to think about the potential for technology enabled by computational biology, we'll see some of the steps that we need to take along the way to make that a reality. Now, there is the (sobering?) thought that this kind of technology could be open to misuse. If we are willing to talk about the potential of programming immune cells, we should also be thinking about the potential of bacteria engineered to evade them. There might be people willing to do that.
12:40 - But because we are at the outset of this, we can move forward with our eyes wide-open. We can ask the difficult questions up front; we can put in place the necessary safe guards. And it's possible that we´ll have to think about our ethics, or have to think about putting bounds on the implementation of biological function. So as part of this research in bioethics it'll have to be priority, it can't be relegated to second place in the excitement of scientific innovation.
13:07 - But the ultimate price, the ultimate destination on this journey would be break through applications and break through industries in areas from agriculture and medicine, to energy, materials and even computing itself. If we understood that program of quantum interactions that allow plant to absorb sun light so efficiently, we might be able to translate that into building synthetic DNA circuits that are for the material for better solar cells.
13:36 - There are teams and scientists working on the fundamentals of this right now, so perhaps it they got the right attention and the right investment, it could be realized in 10 or 15 years. So, we are at the beginning of a technological revolution. Understanding this ancient type of biological computation is the critical first step. And if we can realize this, we will enter into the era of an operating system than runs living software. Thank you very much.