So, people argue vigorously about the definition of life. They ask if it should have reproduction in it, or metabolism, or evolution. And I don't know the answer to that, so I'm not going to tell you. I will say that life involves computation. So this is a computer program. Booted up in a cell, the program would execute, and it could result in this person; or with a small change, it could result in this person; or another small change, this person; or with a larger change, this dog, or this tree, or this whale.
Mensen discussiëren heftig over de definitie van het leven. Ze vragen zich af of het gaat om reproductie, stofwisseling of evolutie. Ik ken het antwoord niet, dus ga ik het jullie ook niet vertellen. Ik ga zeggen dat het bij het leven om rekenen gaat. Dit is een computerprogramma. Als het opstart in een cel en wordt uitgevoerd, zou deze persoon daar het resultaat van kunnen zijn of met een kleine aanpassing deze persoon, of met nog een kleine aanpassing deze persoon, of met een grotere aanpassing een hond, een boom of een walvis.
So now, if you take this metaphor [of] genome as program seriously, you have to consider that Chris Anderson is a computer-fabricated artifact, as is Jim Watson, Craig Venter, as are all of us. And in convincing yourself that this metaphor is true, there are lots of similarities between genetic programs and computer programs that could help to convince you. But one, to me, that's most compelling is the peculiar sensitivity to small changes that can make large changes in biological development -- the output. A small mutation can take a two-wing fly and make it a four-wing fly. Or it could take a fly and put legs where its antennae should be. Or if you're familiar with "The Princess Bride," it could create a six-fingered man.
Als je deze metafoor van het genoom als programma serieus neemt, dan moet je bedenken dat Chris Anderson een computergefabriceerd ding is, net als Jim Watson of Craig Venter, net als iedereen van ons. Om jezelf ervan te overtuigen dat deze metafoor klopt, zijn er heel veel overeenkomsten tussen genetische programma's en computerprogramma's die daarbij kunnen helpen. Maar wat ik het meest interessant vind, is de opvallende gevoeligheid voor kleine veranderingen die grote veranderingen kunnen teweegbrengen in de biologische ontwikkeling - de output zeg maar. Een kleine mutatie kan van een tweevleugelige vlieg een viervleugelige vlieg maken. Of een vlieg poten geven waar antennes zouden moeten zitten. Of als je bekend bent met "The Princess Bride" dan kan het een zesvingerige man maken.
Now, a hallmark of computer programs is just this kind of sensitivity to small changes. If your bank account's one dollar, and you flip a single bit, you could end up with a thousand dollars. So these small changes are things that I think that -- they indicate to us that a complicated computation in development is underlying these amplified, large changes.
Nu is een kenmerk van een computerprogramma juist deze gevoeligheid voor kleine veranderingen. Als je bankrekening één dollar bedraagt en je verplaatst een cijfertje, dan kan dat resulteren in duizend dollar. Deze kleine wijzigingen wijzen ons erop dat een gecompliceerde berekening in de ontwikkeling aan de basis ligt van deze versterkte, grote wijzigingen.
So now, all of this indicates that there are molecular programs underlying biology, and it shows the power of molecular programs -- biology does. And what I want to do is write molecular programs, potentially to build technology. And there are a lot of people doing this, a lot of synthetic biologists doing this, like Craig Venter. And they concentrate on using cells. They're cell-oriented. So my friends, molecular programmers, and I have a sort of biomolecule-centric approach. We're interested in using DNA, RNA and protein, and building new languages for building things from the bottom up, using biomolecules, potentially having nothing to do with biology. So, these are all the machines in a cell. There's a camera. There's the solar panels of the cell, some switches that turn your genes on and off, the girders of the cell, motors that move your muscles. My little group of molecular programmers are trying to refashion all of these parts from DNA. We're not DNA zealots, but DNA is the cheapest, easiest to understand and easy to program material to do this. And as other things become easier to use -- maybe protein -- we'll work with those.
Alles wijst erop dat moleculaire programma’s de biologie sturen en het toont ons de kracht van deze moleculaire programma's. Dat is wat biologie doet. Ik wil moleculaire programma's schrijven om er een technologie op te bouwen. Veel mensen zijn daarmee bezig, veel synthetische biologen zoals Craig Venter. Zij concentreren zich op het gebruik van cellen. Ze zijn ‘celgeoriënteerd’. Mijn vrienden de moleculaire programmeurs en ik, leggen ons meer toe op biomoleculen. Wij zijn geïnteresseerd in het gebruik van DNA, RNA en eiwitten. We schrijven nieuwe talen om deze dingen vanaf de grond op te bouwen door het gebruik van biomoleculen, die mogelijkerwijs niets met biologie te maken hebben. Dit is de hele machinerie van een cel. Daar een camera. Daar zijn de zonnepanelen van de cel, een paar schakelaars om genen aan en uit zetten, de steunbalken van de cel, motoren die je spieren bewegen. Mijn kleine groep van moleculaire programmeurs probeert al deze onderdelen aan te passen via DNA. Niet dat we DNA-zeloten zijn, maar DNA is het goedkoopst, makkelijkst te begrijpen en te programmeren materiaal om dit te doen. Als andere dingen gemakkelijker te gebruiken worden - misschien wel eiwitten - gaan we daar ook mee werken.
If we succeed, what will molecular programming look like? You're going to sit in front of your computer. You're going to design something like a cell phone, and in a high-level language, you'll describe that cell phone. Then you're going to have a compiler that's going to take that description and it's going to turn it into actual molecules that can be sent to a synthesizer and that synthesizer will pack those molecules into a seed. And what happens if you water and feed that seed appropriately, is it will do a developmental computation, a molecular computation, and it'll build an electronic computer. And if I haven't revealed my prejudices already, I think that life has been about molecular computers building electrochemical computers, building electronic computers, which together with electrochemical computers will build new molecular computers, which will build new electronic computers, and so forth.
Als we slagen, hoe zal dan moleculair programmeren eruit zien? Je gaat achter je computer zitten. Je gaat iets ontwerpen zoals een mobiele telefoon. Die ga je beschrijven middels een taal van een hoger niveau. Dan neem je een compiler die deze beschrijving in echte moleculen omzet. Dat kan dan naar een synthesizer gestuurd worden en deze synthesizer stopt deze moleculen in een zaadje. Als je het zaadje genoeg water en eten geeft, dan gaat het de ontwikkelingsberekening uitvoeren, een moleculaire berekening en bouwt zo een elektronische computer. Als je begrijpt waar ik naartoe wil: ik denk dat leven gaat over moleculaire computers die elektrochemische computers bouwen die weer elektronische computers bouwen die samen met elektrochemische computers weer nieuwe moleculaire computers bouwen die ook weer nieuwe elektronische computers bouwen, enzovoorts.
And if you buy all of this, and you think life is about computation, as I do, then you look at big questions through the eyes of a computer scientist. So one big question is, how does a baby know when to stop growing? And for molecular programming, the question is how does your cell phone know when to stop growing? (Laughter) Or how does a computer program know when to stop running? Or more to the point, how do you know if a program will ever stop? There are other questions like this, too. One of them is Craig Venter's question. Turns out I think he's actually a computer scientist. He asked, how big is the minimal genome that will give me a functioning microorganism? How few genes can I use? This is exactly analogous to the question, what's the smallest program I can write that will act exactly like Microsoft Word? (Laughter) And just as he's writing, you know, bacteria that will be smaller, he's writing genomes that will work, we could write smaller programs that would do what Microsoft Word does.
Als je dit allemaal gelooft en je gelooft, net als ik, dat leven over berekeningen gaat, dan kijk je naar de grote vragen door de ogen van een computerwetenschapper. Dan is een hamvraag: hoe weet een baby wanneer hij moet stoppen met groeien? Voor een moleculair programmeur wordt dat dan de vraag hoe je mobiele telefoon weet wanneer te stoppen met groeien. (Gelach) Of hoe weet een computerprogramma wanneer het moeten stoppen met draaien? Of meer direct, hoe weet je of je computerprogramma ooit stopt? Er zijn nog meer van dit soort vragen. Een ervan is de vraag van Craig Venter. Ik denk dat hij eigenlijk een computerwetenschapper is. Hij vraagt hoe groot een genoom minimaal moet zijn om een functionerend micro-organisme op te leveren? Met hoe weinig genen kom ik toe? Dit is exact analoog aan de vraag wat het kleinste programma is dat ik kan schrijven dat hetzelfde doet als MS Word. (Gelach) Terwijl hij werkende genomen schrijft voor bacteriën, zouden wij kleinere programma’s kunnen schrijven die hetzelfde doen als wat MS Word doet.
But for molecular programming, our question is, how many molecules do we need to put in that seed to get a cell phone? What's the smallest number we can get away with? Now, these are big questions in computer science. These are all complexity questions, and computer science tells us that these are very hard questions. Almost -- many of them are impossible. But for some tasks, we can start to answer them. So, I'm going to start asking those questions for the DNA structures I'm going to talk about next. So, this is normal DNA, what you think of as normal DNA. It's double-stranded, it's a double helix, has the As, Ts, Cs and Gs that pair to hold the strands together. And I'm going to draw it like this sometimes, just so I don't scare you. We want to look at individual strands and not think about the double helix. When we synthesize it, it comes single-stranded, so we can take the blue strand in one tube and make an orange strand in the other tube, and they're floppy when they're single-stranded. You mix them together and they make a rigid double helix. Now for the last 25 years, Ned Seeman and a bunch of his descendants have worked very hard and made beautiful three-dimensional structures using this kind of reaction of DNA strands coming together. But a lot of their approaches, though elegant, take a long time. They can take a couple of years, or it can be difficult to design.
Maar bij moleculair programmeren is onze vraag: hoeveel moleculen moeten we in dat zaadje stoppen om een mobiele telefoon te krijgen? Wat is het kleinste aantal waar we mee weg kunnen komen? Dat zijn nou grote vragen in de computerwetenschappen. Allemaal complexiteitsvraagstukken en de computerwetenschap vertelt ons dat dit hele moeilijke vragen zijn. Bijna - veel ervan zijn onmogelijk. Maar voor sommige taken kunnen we ze beginnen te beantwoorden. Dus ga ik beginnen die vragen te stellen voor de DNA-structuren waarover ik hierna ga praten. Dit is normaal DNA, wat jullie zien als normaal DNA. Het is dubbelstrengig, het is een dubbele helix. De A's en de T's, de C's en de G's koppelen om de strengen bij elkaar te houden. Ik zal het als volgt tekenen om jullie niet bang te maken. Het gaat over de enkele strengen en niet over de dubbele helix. Wanneer we het DNA synthetiseren gaan we uit van enkele strengen. We doen de blauwe streng in de ene buis en de oranje streng in de andere buis. Ze kronkelen wanneer ze enkelstrengig zijn. Voeg ze samen en ze vormen een rigide dubbele helix. De afgelopen 25 jaar hebben Ned Seeman en een aantal van zijn medewerkers heel hard gewerkt en deze prachtige driedimensionale structuren gemaakt middels de reactie van DNA-strengen om samen te komen. Maar hun methode, hoe elegant ook, heeft veel tijd nodig. Het kan een paar jaar duren of ze zijn moeilijk te ontwerpen.
So I came up with a new method a couple of years ago I call DNA origami that's so easy you could do it at home in your kitchen and design the stuff on a laptop. But to do it, you need a long, single strand of DNA, which is technically very difficult to get. So, you can go to a natural source. You can look in this computer-fabricated artifact, and he's got a double-stranded genome -- that's no good. You look in his intestines. There are billions of bacteria. They're no good either. Double strand again, but inside them, they're infected with a virus that has a nice, long, single-stranded genome that we can fold like a piece of paper. And here's how we do it.
Ik kwam een paar jaar geleden met een nieuwe methode. Ik noem het DNA-origami. Zo makkelijk dat je het thuis in je eigen keuken kunt doen en het spul ontwerpen op een laptop Maar om het uit te voeren heb je een lange, enkele streng DNA nodig wat technisch heel moeilijk voor elkaar te krijgen is. Je kan echter uitgaan van een natuurlijke bron. Bijvoorbeeld van dit computergefabriceerde artefact. Hij heeft een dubbelstrengig genoom, daar hebben we niks aan. Of in zijn darmen. Daar zitten miljoenen bacteriën. Ook niet goed. Dubbelstrengig alweer, maar daarbinnen zijn ze geïnfecteerd met een virus met een fijn, lang, enkelstrengig genoom dat we kunnen vouwen als een vel papier. Zo doen we dat.
This is part of that genome. We add a bunch of short, synthetic DNAs that I call staples. Each one has a left half that binds the long strand in one place, and a right half that binds it in a different place, and brings the long strand together like this. The net action of many of these on that long strand is to fold it into something like a rectangle.
Dit is een deel van het genoom. We voegen een paar korte stukken synthetisch DNA toe - ik noem ze nietjes. Allemaal hebben ze een linkerhelft die op één plaats aan de lange streng bindt en een rechterhelft die op een andere plaats bindt. Dat brengt de lange streng als volgt samen. Het resultaat hiervan is dat de lange streng tot iets als een rechthoek wordt gevouwen.
Now, we can't actually take a movie of this process, but Shawn Douglas at Harvard has made a nice visualization for us that begins with a long strand and has some short strands in it. And what happens is that we mix these strands together. We heat them up, we add a little bit of salt, we heat them up to almost boiling and cool them down, and as we cool them down, the short strands bind the long strands and start to form structure. And you can see a little bit of double helix forming there. When you look at DNA origami, you can see that what it really is, even though you think it's complicated, is a bunch of double helices that are parallel to each other, and they're held together by places where short strands go along one helix and then jump to another one. So there's a strand that goes like this, goes along one helix and binds -- it jumps to another helix and comes back. That holds the long strand like this.
We kunnen daar geen filmpje van maken maar Shawn Douglas van Harvard heeft voor ons een mooie visualisatie gemaakt. Het begint met een lange streng en wat korte strengen erbij. We voegen deze strengen samen, verwarmen ze, voegen een beetje zout toe. Dan verhitten we tot bijna koken en koelen dan af. Tijdens het afkoelen, binden de korte strengen aan de lange strengen en begint er zich een structuur te vormen. Je kan daar een beetje dubbele helix zien ontstaan. Als je naar DNA-origami kijkt, dan kun je zien wat het echt is. Ook al denk je dat het heel complex is, is het een hoop parallelle, dubbele helixen bijeengehouden op plaatsen waar korte strengen zich aan een helix hechten en dan naar een andere overspringen. Er is dus een streng die zo gaat, langs een streng gaat en bindt - hij springt naar een andere helix en komt terug. Dat houdt de lange streng als volgt vast.
Now, to show that we could make any shape or pattern that we wanted, I tried to make this shape. I wanted to fold DNA into something that goes up over the eye, down the nose, up the nose, around the forehead, back down and end in a little loop like this. And so, I thought, if this could work, anything could work. So I had the computer program design the short staples to do this. I ordered them; they came by FedEx. I mixed them up, heated them, cooled them down, and I got 50 billion little smiley faces floating around in a single drop of water. And each one of these is just one-thousandth the width of a human hair, OK?
Om aan te tonen dat we iedere gewenste vorm of patroon kunnen maken, heb ik geprobeerd deze vorm te maken. Ik wilde DNA vouwen in iets dat over het oog heen gaat, langs de neus naar beneden, om het voorhoofd, terug naar beneden en eindigend in een kleine lus. Ik dacht: als dit kan, dan kan vrijwel alles werken. Ik liet het computerprogramma de nietjes ervoor ontwerpen. Ik bestelde ze en ze kwamen per FedEx binnen. Ik mengde, verwarmde en koelde af en ik kreeg 50 miljard kleine smilies. Ze drijven rond in één enkele druppel water en elk ervan is één duizendste van de breedte van een menselijke haar.
So, they're all floating around in solution, and to look at them, you have to get them on a surface where they stick. So, you pour them out onto a surface and they start to stick to that surface, and we take a picture using an atomic-force microscope. It's got a needle, like a record needle, that goes back and forth over the surface, bumps up and down, and feels the height of the first surface. It feels the DNA origami. There's the atomic-force microscope working and you can see that the landing's a little rough. When you zoom in, they've got, you know, weak jaws that flip over their heads and some of their noses get punched out, but it's pretty good. You can zoom in and even see the extra little loop, this little nano-goatee.
Dus drijven ze allemaal in deze oplossing en om ze te zien te krijgen, moet je ze op een oppervlak plakken. Je giet ze uit over een oppervlak en ze hechten zich eraan. We maken een foto met een atoomkrachtmicroscoop. Die heeft een naald als een platenspeler die heen en weer over het oppervlak gaat. Ze gaat op en neer en voelt de hoogte van het oorspronkelijke oppervlak Ze voelt de DNA-origami. Hier is de atoomkrachtmicroscoop aan het werk. Je kunt zien dat de landing een beetje ruig is Wanneer je inzoomt hebben ze zwakke kaken die over hun hoofd heen flappen en sommige neuzen zijn eruit gestoten, maar het is redelijk goed. Je kunt inzoomen en dan zie je ook de kleine extra lus een kleine nano-geitesik.
Now, what's great about this is anybody can do this. And so, I got this in the mail about a year after I did this, unsolicited. Anyone know what this is? What is it? It's China, right? So, what happened is, a graduate student in China, Lulu Qian, did a great job. She wrote all her own software to design and built this DNA origami, a beautiful rendition of China, which even has Taiwan, and you can see it's sort of on the world's shortest leash, right? (Laughter) So, this works really well and you can make patterns as well as shapes, OK? And you can make a map of the Americas and spell DNA with DNA.
Het leuke is dat iedereen dit kan en dus kreeg ik dit ongevraagd, ongeveer een jaar later met de post. Weet iemand wat dit is? Het is China, ja? Een studente in China, Lulu Qian heeft iets moois gedaan. Ze schreef haar eigen software om dit te ontwerpen en te bouwen met DNA-origami een mooie weergave van China, waar zelfs Taiwan in zit en je kunt zien dat dit zo'n beetje 's werelds kortste leiband is, toch? (Gelach) Dit werkt best goed. Je kunt patronen en figuren maken. Je kunt een kaart van de Amerika's maken en 'DNA' met DNA spellen
And what's really neat about it -- well, actually, this all looks like nano-artwork, but it turns out that nano-artwork is just what you need to make nano-circuits. So, you can put circuit components on the staples, like a light bulb and a light switch. Let the thing assemble, and you'll get some kind of a circuit. And then you can maybe wash the DNA away and have the circuit left over. So, this is what some colleagues of mine at Caltech did. They took a DNA origami, organized some carbon nano-tubes, made a little switch, you see here, wired it up, tested it and showed that it is indeed a switch. Now, this is just a single switch and you need half a billion for a computer, so we have a long way to go. But this is very promising because the origami can organize parts just one-tenth the size of those in a normal computer. So it's very promising for making small computers.
Het leuke is dat dit wel nano-kunst lijkt. Maar het blijkt dat nano-kunst juist datgene is wat je nodig hebt om nano-circuits te maken. Je kunt circuitcomponenten op de nietjes plaatsen. Lampjes en schakelaars. Assembleer het en je krijgt een soort circuit. Dan kun je wellicht het DNA wegwassen en het circuit overhouden. Dat deden een aantal van mijn collega's bij Caltech. Ze namen wat DNA-origami, regelden wat koolstof nano-buisjes en maakten een kleine schakelaar, sloten hem aan, testten hem en toonden aan dat het inderdaad een schakelaar is. Nu is dit maar één enkele schakelaar en je hebt er een half miljard nodig voor een computer, dus zijn we er nog niet. Maar veelbelovend is het wel. De origami kan deeltjes organiseren die maar een tiende van de grootte zijn van die in een normale computer. Dat houdt de belofte in voor het maken van kleinere computers.
Now, I want to get back to that compiler. The DNA origami is a proof that that compiler actually works. So, you start with something in the computer. You get a high-level description of the computer program, a high-level description of the origami. You can compile it to molecules, send it to a synthesizer, and it actually works. And it turns out that a company has made a nice program that's much better than my code, which was kind of ugly, and will allow us to do this in a nice, visual, computer-aided design way.
Ik wil even terug naar de compiler. DNA-origami is het bewijs dat de compiler echt werkt. Je start met iets in de computer. Je maakt een beschrijving op hoog niveau van het computerprogramma, een beschrijving op hoog niveau van de origami. Je kunt het compileren tot moleculen en het naar een synthesizer sturen en het werkt echt. Een bedrijf heeft een leuk programma gemaakt dat veel beter is dan mijn code, die nogal klungelig was. Het staat ons toe dit op een plezierige, visueel ondersteunde manier van ontwerpen te doen.
So, now you can say, all right, why isn't DNA origami the end of the story? You have your molecular compiler, you can do whatever you want. The fact is that it does not scale. So if you want to build a human from DNA origami, the problem is, you need a long strand that's 10 trillion trillion bases long. That's three light years' worth of DNA, so we're not going to do this. We're going to turn to another technology, called algorithmic self-assembly of tiles. It was started by Erik Winfree, and what it does, it has tiles that are a hundredth the size of a DNA origami. You zoom in, there are just four DNA strands and they have little single-stranded bits on them that can bind to other tiles, if they match. And we like to draw these tiles as little squares. And if you look at their sticky ends, these little DNA bits, you can see that they actually form a checkerboard pattern. So, these tiles would make a complicated, self-assembling checkerboard. And the point of this, if you didn't catch that, is that tiles are a kind of molecular program and they can output patterns. And a really amazing part of this is that any computer program can be translated into one of these tile programs -- specifically, counting. So, you can come up with a set of tiles that when they come together, form a little binary counter rather than a checkerboard. So you can read off binary numbers five, six and seven.
Nu kan je je afvragen waarom DNA-origami niet het einde is van het verhaal. Je hebt je moleculaire compiler, je kunt doen wat je maar wil. Je kan het niet opschalen. Als je een mens wil maken met DNA-origami, dan is het probleem dat je een lange streng nodig hebt die 10 biljoen biljoen basen lang is. Dat is een streng van drie lichtjaren lang. Gaan we dus niet doen. We gaan een andere technologie gebruiken. Die heet algoritmische zelfassemblage van tegels. Erik Winfree is ermee begonnen. Het werkt met delen die maar een honderste zo groot zijn als een DNA-origami. Je zoomt in, er zijn maar vier DNA-strengen met kleine enkelstrengige stukjes erop die aan andere tegels kunnen binden als ze passen. We tekenen deze tegels als kleine vierkantjes. Door de kleverige uiteinden gaan deze kleine stukjes DNA een dambordpatroon vormen. Deze tegels vormen zo een gecompliceerd, zelfassemblerend dambord. Het punt is, als je het nog niet doorhad, dat deze tegels een soort moleculair programma zijn en patronen kunnen maken. Het geweldige hiervan is dat ieder computerprogramma vertaald kan worden in een van deze deelprogramma's - specifieker, om te tellen. Een set van deze tegels vormen samen een soort binaire teller in plaats van een dambord. Daar heb je de binaire getallen 5, 6 en 7.
And in order to get these kinds of computations started right, you need some kind of input, a kind of seed. You can use DNA origami for that. You can encode the number 32 in the right-hand side of a DNA origami, and when you add those tiles that count, they will start to count -- they will read that 32 and they'll stop at 32. So, what we've done is we've figured out a way to have a molecular program know when to stop going. It knows when to stop growing because it can count. It knows how big it is. So, that answers that sort of first question I was talking about. It doesn't tell us how babies do it, however.
Om deze berekeningen goed te laten beginnen, heb je een soort input nodig, een soort zaadje. Daar kun je DNA-origami voor gebruiken. Je kunt het getal 32 coderen aan de rechterkant van een DNA-origami en wanneer je de rekenende tegels toevoegt zullen ze beginnen met tellen, ze zullen die 32 lezen en stoppen bij 32. We hebben een manier gevonden om een moleculair programma te laten weten wanneer het moet stoppen. Het weet wanneer het moet stoppen met groeien omdat het kan tellen. Het weet hoe groot het is. Dat beantwoordt de eerste vraag waar ik het over had. Het vertelt ons echter niet hoe baby’s het doen.
So now, we can use this counting to try and get at much bigger things than DNA origami could otherwise. Here's the DNA origami, and what we can do is we can write 32 on both edges of the DNA origami, and we can now use our watering can and water with tiles, and we can start growing tiles off of that and create a square. The counter serves as a template to fill in a square in the middle of this thing. So, what we've done is we've succeeded in making something much bigger than a DNA origami by combining DNA origami with tiles. And the neat thing about it is, is that it's also reprogrammable. You can just change a couple of the DNA strands in this binary representation and you'll get 96 rather than 32. And if you do that, the origami's the same size, but the resulting square that you get is three times bigger.
We kunnen dit tellen gebruiken om veel grotere dingen te maken dan met DNA-origami zou kunnen. Hier is het DNA-origami en wat we ermee kunnen doen, is 32 schrijven aan beide kanten van het DNA-origami. Nu kunnen we onze gieter gebruiken en begieten met tegels. We kunnen hierop tegels kweken en een vierkant maken. De teller dient als sjabloon om een vierkant in het midden van dit ding in te vullen. We zijn er dus in geslaagd om iets te maken dat veel groter is dan DNA-origami door DNA-origami te combineren met tegels. Het leuke eraan is dat het ook herprogrammeerbaar is. Je kunt een paar DNA-strengen veranderen in deze binaire representatie en je krijgt 96 in plaats van 32. Wanneer je dat doet, is de origami even groot maar het daarop volgende vierkant drie keer zo groot.
So, this sort of recapitulates what I was telling you about development. You have a very sensitive computer program where small changes -- single, tiny, little mutations -- can take something that made one size square and make something very much bigger. Now, this -- using counting to compute and build these kinds of things by this kind of developmental process is something that also has bearing on Craig Venter's question. So, you can ask, how many DNA strands are required to build a square of a given size? If we wanted to make a square of size 10, 100 or 1,000, if we used DNA origami alone, we would require a number of DNA strands that's the square of the size of that square; so we'd need 100, 10,000 or a million DNA strands. That's really not affordable. But if we use a little computation -- we use origami, plus some tiles that count -- then we can get away with using 100, 200 or 300 DNA strands. And so we can exponentially reduce the number of DNA strands we use, if we use counting, if we use a little bit of computation. And so computation is some very powerful way to reduce the number of molecules you need to build something, to reduce the size of the genome that you're building.
Dit vat zo'n beetje samen wat ik vertelde over ontwikkeling. Je hebt een erg gevoelig computerprogramma waar kleine wijzigingen - enkele kleine mutaties - iets dat een vierkant was, vele malen groter kan maken. Het gebruiken van tellen om te berekenen en deze dingen maken door een ontwikkelingsproces, is iets dat ook antwoord geeft op de vraag van Craig Venter. Je kan je afvragen hoeveel strengen er nodig zijn om een vierkant van een gegeven afmeting te maken. Als we een vierkant wilden van 10, 100 of 1000 van alleen DNA-origami zou het aantal DNA-strengen gelijk moeten zijn aan het kwadraat van de grootte van dat vierkant. We zouden 100, 10.000 of een miljoen DNA-strengen nodig hebben. Dat is echt niet betaalbaar. Maar als we een kleine berekening maken - gebruiken we origami, plus een aantal tellende tegels - dan kunnen we wegkomen met 100, 200 of 300 DNA-strengen. We kunnen dus het benodigde aantal DNA-strengen exponentieel verminderen, als we tellen gebruiken, als we wat rekenen toepassen. Rekenen is dus een zeer krachtige manier om het aantal benodigde moleculen om iets te bouwen te verminderen, om de grootte van het genoom dat je bouwt te verkleinen.
And finally, I'm going to get back to that sort of crazy idea about computers building computers. If you look at the square that you build with the origami and some counters growing off it, the pattern that it has is exactly the pattern that you need to make a memory. So if you affix some wires and switches to those tiles -- rather than to the staple strands, you affix them to the tiles -- then they'll self-assemble the somewhat complicated circuits, the demultiplexer circuits, that you need to address this memory. So you can actually make a complicated circuit using a little bit of computation. It's a molecular computer building an electronic computer. Now, you ask me, how far have we gotten down this path? Experimentally, this is what we've done in the last year. Here is a DNA origami rectangle, and here are some tiles growing from it. And you can see how they count. One, two, three, four, five, six, nine, 10, 11, 12, 17. So it's got some errors, but at least it counts up. (Laughter)
Tenslotte ga ik terug naar dat gekke idee over computers die computers bouwen. Als je kijkt naar het vierkant dat je bouwt met origami en een aantal tellers erop, is het patroon dat je krijgt precies het patroon dat je nodig hebt om een geheugen te maken. Als je wat draden en schakelaars op die tegels plaatst - in plaats van ze op de strengen te nieten, breng je ze aan op de tegels - dan zullen ze de enigszins ingewikkelde circuits zelf gaan assembleren, de demultiplexer circuits, die je nodig hebt om dit geheugen te adresseren. Je kunt zo een ingewikkeld circuit maken met behulp van een beetje rekenen. Het is een moleculaire computer die een elektronische computer bouwt. Nu zullen jullie mij vragen hoe ver we hiermee al staan. Dit hebben we in het afgelopen jaar gedaan. Hier is een DNA-origami rechthoek en hier zijn enkele tegels die erop staan. Je kan zien hoe ze tellen. 1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 17. Er zitten nog wat fouten in, maar het telt ten minste. (Gelach)
So, it turns out we actually had this idea nine years ago, and that's about the time constant for how long it takes to do these kinds of things, so I think we made a lot of progress. We've got ideas about how to fix these errors. And I think in the next five or 10 years, we'll make the kind of squares that I described and maybe even get to some of those self-assembled circuits.
Negen jaar geleden begonnen we hiermee. Dat is ongeveer de tijd hoe lang het duurt om dit soort dingen te doen. Ik denk dat we veel vooruitgang hebben geboekt. We hebben ideeën over hoe deze fouten te herstellen. Ik denk dat we binnen vijf of tien jaar, de vierkanten die ik beschreef, gaan maken en misschien zelfs een aantal zelf-assemblerende circuits.
So now, what do I want you to take away from this talk? I want you to remember that to create life's very diverse and complex forms, life uses computation to do that. And the computations that it uses, they're molecular computations, and in order to understand this and get a better handle on it, as Feynman said, you know, we need to build something to understand it. And so we are going to use molecules and refashion this thing, rebuild everything from the bottom up, using DNA in ways that nature never intended, using DNA origami, and DNA origami to seed this algorithmic self-assembly.
Wat moet je van deze talk onthouden? Ik wil dat je onthoudt dat om de erg diverse en complexe vormen van het leven te creëren, het leven gebruik maakt van rekenen. De manier van rekenen is moleculair. Om dit te begrijpen en er een betere greep op te krijgen, moet je, zoals Feynman zei, het bouwen om het te begrijpen. Dus gaan we moleculen gebruiken en dit ding herwerken, alles van onder af opbouwen met behulp van DNA op een manier die de natuur nooit heeft bedoeld. Met behulp van DNA-origami om deze algoritmische zelf-assemblage te starten.
You know, so this is all very cool, but what I'd like you to take from the talk, hopefully from some of those big questions, is that this molecular programming isn't just about making gadgets. It's not just making about -- it's making self-assembled cell phones and circuits. What it's really about is taking computer science and looking at big questions in a new light, asking new versions of those big questions and trying to understand how biology can make such amazing things. Thank you. (Applause)
Dit is allemaal heel cool, maar wat ik zou willen dat je hopelijk onthoudt van sommige van die grote vragen, is dat dit moleculair programmeren niet alleen gaat over het maken van gadgets. Het gaat niet alleen over het maken van zelf-geassembleerde mobiele telefoons en circuits. Waar het in de informatica echt om gaat is de grote vragen in een nieuw licht te bekijken, nieuwe versies van die grote vragen te bedenken en proberen te begrijpen hoe de biologie zo’n verbazingwekkende dingen heeft kunnen maken. Dank je. (Applaus)