Today I'd like to show you the future of the way we make things. I believe that soon our buildings and machines will be self-assembling, replicating and repairing themselves. So I'm going to show you what I believe is the current state of manufacturing, and then compare that to some natural systems.
Vandaag wil ik jullie de toekomst tonen van de manier waarop we dingen maken. Ik geloof dat onze gebouwen en machines zichzelf binnenkort zullen assembleren, repliceren en repareren. Dus ik ga je laten zien wat volgens mij de huidige stand van de productie is, en die dan vergelijken met een aantal natuurlijke systemen.
So in the current state of manufacturing, we have skyscrapers -- two and a half years [of assembly time], 500,000 to a million parts, fairly complex, new, exciting technologies in steel, concrete, glass. We have exciting machines that can take us into space -- five years [of assembly time], 2.5 million parts.
In de huidige stand van de productie hebben we wolkenkrabbers. Twee en een half jaar, 500.000 tot een miljoen onderdelen, vrij complexe, nieuwe en spannende technologieën in staal, beton, glas. We hebben spannende machines die ons naar de ruimte kunnen brengen - vijf jaar, 2,5 miljoen onderdelen.
But on the other side, if you look at the natural systems, we have proteins that have two million types, can fold in 10,000 nanoseconds, or DNA with three billion base pairs we can replicate in roughly an hour. So there's all of this complexity in our natural systems, but they're extremely efficient, far more efficient than anything we can build, far more complex than anything we can build. They're far more efficient in terms of energy. They hardly ever make mistakes. And they can repair themselves for longevity.
Maar aan de andere kant, als je kijkt naar de natuurlijke systemen, hebben we eiwitten die twee miljoen soorten tellen, en die zich ontvouwen in 10.000 nanoseconden, of DNA met drie miljard basenparen die we kunnen repliceren in ongeveer een uur. Dus er zit een hoop complexiteit in onze natuurlijke systemen, maar ze zijn zeer efficiënt, veel efficiënter dan wat we kunnen bouwen, veel complexer dan alles wat we kunnen bouwen. Ze zijn veel efficiënter in termen van energie. Ze maken bijna nooit fouten. En ze kunnen zichzelf herstellen om lang mee te gaan.
So there's something super interesting about natural systems. And if we can translate that into our built environment, then there's some exciting potential for the way that we build things. And I think the key to that is self-assembly.
Er is dus iets super-interessants aan natuurlijke systemen. Als we dat kunnen vertalen naar onze gebouwde omgeving, dan zijn er nog een aantal interessante mogelijkheden voor de manier waarop we dingen bouwen. Ik denk dat de sleutel daartoe zelfassemblage is.
So if we want to utilize self-assembly in our physical environment, I think there's four key factors. The first is that we need to decode all of the complexity of what we want to build -- so our buildings and machines. And we need to decode that into simple sequences -- basically the DNA of how our buildings work. Then we need programmable parts that can take that sequence and use that to fold up, or reconfigure. We need some energy that's going to allow that to activate, allow our parts to be able to fold up from the program. And we need some type of error correction redundancy to guarantee that we have successfully built what we want.
Als we zelfassemblage willen gebruiken in onze fysieke omgeving, zijn er volgens mij vier belangrijke factoren. De eerste is dat we de volledige complexiteit van wat we willen bouwen, moeten ontcijferen - dat wil zeggen onze gebouwen en machines. We moeten ze ontcijferen in eenvoudige sequenties - zowat het DNA van hoe onze gebouwen werken. Dan hebben we programmeerbare onderdelen nodig die deze sequenties kunnen gebruiken om zich op te vouwen, of opnieuw te configureren. We hebben wat energie om dat te activeren, om onze delen te doen opvouwen volgens het programma. En we hebben een soort van foutcorrectie-redundantie om te garanderen dat we met succes hebben gebouwd wat we willen.
So I'm going to show you a number of projects that my colleagues and I at MIT are working on to achieve this self-assembling future. The first two are the MacroBot and DeciBot. So these projects are large-scale reconfigurable robots -- 8 ft., 12 ft. long proteins. They're embedded with mechanical electrical devices, sensors. You decode what you want to fold up into, into a sequence of angles -- so negative 120, negative 120, 0, 0, 120, negative 120 -- something like that; so a sequence of angles, or turns, and you send that sequence through the string. Each unit takes its message -- so negative 120 -- it rotates to that, checks if it got there and then passes it to its neighbor.
Ik zal een aantal projecten laten zien waar mijn collega's en ik aan het MIT aan werken om deze toekomst van zelfassemblage te bereiken. De eerste twee zijn de MacroBot en DeciBot. Deze projecten zijn grootschalige herconfigureerbare robots - eiwitten van 2,5 à 3,5 meter. Ze zijn volgestouwd met mechanische elektrische apparaten, sensoren. Je ontcijfert waarin je je wil opvouwen, in een opeenvolging van hoeken - dus min 120, min 120, 0, 0, 120, 120 negatief - zoiets; dus een opeenvolging van hoeken of bochten, en je stuurt die volgorde door de string. Elke unit neemt zijn boodschap - dus min 120. Het roteert daarheen, controleert of het er is geraakt, en dan geeft het door aan zijn buurman.
So these are the brilliant scientists, engineers, designers that worked on this project. And I think it really brings to light: Is this really scalable? I mean, thousands of dollars, lots of man hours made to make this eight-foot robot. Can we really scale this up? Can we really embed robotics into every part? The next one questions that and looks at passive nature, or passively trying to have reconfiguration programmability. But it goes a step further, and it tries to have actual computation. It basically embeds the most fundamental building block of computing, the digital logic gate, directly into your parts.
Dit zijn de briljante wetenschappers, ingenieurs, ontwerpers die aan dit project hebben gewerkt. Volgens mij wijst dit erop: is dit echt schaalbaar? Ik bedoel, duizenden dollars, vele manuren zijn gepresteerd om deze robot van acht meter te maken. Kunnen we dit opschalen? Kunnen we echt robotica inbouwen in elk deel? Het volgende stelt dat in vraag en kijkt naar de passieve natuur, of passief proberen om programmeerbaarheid van herconfiguratie te bereiken. Maar het gaat een stap verder, en het probeert daadwerkelijke berekening te bereiken. Het omvat de meest fundamentele bouwsteen van computers, de digitale logische poort, rechtstreeks in je onderdelen.
So this is a NAND gate. You have one tetrahedron which is the gate that's going to do your computing, and you have two input tetrahedrons. One of them is the input from the user, as you're building your bricks. The other one is from the previous brick that was placed. And then it gives you an output in 3D space. So what this means is that the user can start plugging in what they want the bricks to do. It computes on what it was doing before and what you said you wanted it to do. And now it starts moving in three-dimensional space -- so up or down. So on the left-hand side, [1,1] input equals 0 output, which goes down. On the right-hand side, [0,0] input is a 1 output, which goes up. And so what that really means is that our structures now contain the blueprints of what we want to build.
Dus dit is een NAND-poort. Je hebt een tetraëder, de poort die je berekening gaat doen, en je hebt twee input-tetraëders. Een van hen is de input van de gebruiker, terwijl je je bakstenen bouwt. De andere is van de vorige steen die was geplaatst. En dan geeft het je een resultaat in een 3D-ruimte. Dus wat dit betekent, is dat de gebruiker opdrachten voor de bakstenen kan beginnen aansluiten. Het berekent op basis van wat het voordien aan het doen was en van jouw opdracht. En nu begint het te bewegen in een drie-dimensionale ruimte - dus omhoog of omlaag. Aan de linkerkant is de [1,1]-ingang gelijk aan de 0-uitgang, die naar beneden gaat. Aan de rechterkant is [0,0]-ingang is een 1-uitgang, die omhoog gaat. Dus wat dat echt betekent, is dat onze structuren nu de blauwdrukken bevatten van wat we willen bouwen.
So they have all of the information embedded in them of what was constructed. So that means that we can have some form of self-replication. In this case I call it self-guided replication, because your structure contains the exact blueprints. If you have errors, you can replace a part. All the local information is embedded to tell you how to fix it. So you could have something that climbs along and reads it and can output at one to one. It's directly embedded; there's no external instructions.
Alle informatie over wat er gebouwd is, zit ingebouwd. Dus dat betekent dat we een bepaalde vorm van zelf-replicatie hebben. In dit geval noem ik het zelf-geleide replicatie, omdat je structuur de exacte blauwdrukken bevat. In geval van fouten, kan je een onderdeel vervangen. Alle lokale informatie is ingebed om je te vertellen hoe dit te verhelpen. Je zou dus iets kunnen hebben dat erlangs klimt en het afleest, en een één-op-één-resultaat aflevert Het is rechtstreeks ingebouwd, er zijn geen externe instructies.
So the last project I'll show is called Biased Chains, and it's probably the most exciting example that we have right now of passive self-assembly systems. So it takes the reconfigurability and programmability and makes it a completely passive system. So basically you have a chain of elements. Each element is completely identical, and they're biased. So each chain, or each element, wants to turn right or left. So as you assemble the chain, you're basically programming it. You're telling each unit if it should turn right or left. So when you shake the chain, it then folds up into any configuration that you've programmed in -- so in this case, a spiral, or in this case, two cubes next to each other. So you can basically program any three-dimensional shape -- or one-dimensional, two-dimensional -- up into this chain completely passively.
Het laatste project dat ik zal je laten zien, heet Bevooroordeelde Ketens, en het is waarschijnlijk het meest opwindende voorbeeld dat op dit moment hebben van passieve zelfassemblagesystemen. Het neemt de herconfigureerbaarheid en de programmeerbaarheid en maakt er een volledig passief systeem van. Dus eigenlijk heb je een keten van elementen. Elk element is volledig identiek, en ze zijn bevooroordeeld. Dus elke keten, of elk element, wil rechts of links. Als je de ketting monteert, ben je eigenlijk aan het programmeren. Je vertelt elke eenheid of ze naar rechts of naar links moet draaien. Dus als je de ketting te schudt, vouwt ze zich op in elke configuratie die je erin hebt geprogrammeerd - dus in dit geval, een spiraal, of in dit geval, twee kubussen naast elkaar. Dus je kunt in principe een drie-dimensionale vorm programmeren - of een-dimensionaal, twee-dimensionale - in deze keten, volledig passief.
So what does this tell us about the future? I think that it's telling us that there's new possibilities for self-assembly, replication, repair in our physical structures, our buildings, machines. There's new programmability in these parts. And from that you have new possibilities for computing. We'll have spatial computing. Imagine if our buildings, our bridges, machines, all of our bricks could actually compute. That's amazing parallel and distributed computing power, new design possibilities. So it's exciting potential for this. So I think these projects I've showed here are just a tiny step towards this future, if we implement these new technologies for a new self-assembling world.
Dus wat zegt dit ons over de toekomst? Ik denk dat het ons vertelt dat er nieuwe mogelijkheden voor zelfassemblage, replicatie, reparatie zitten in onze fysieke structuren, onze gebouwen, machines. Er zit nieuwe programmeerbaarheid in deze onderdelen. Daaruit volgen nieuwe mogelijkheden voor computergebruik. We zullen ruimtelijke berekening krijgen. Stel je voor dat onze gebouwen, onze bruggen, machines, al onze stenen eigenlijk konden rekenen. Dat is een verbazingwekkende parallelle en gedistribueerde rekenkracht, dat zijn nieuwe designmogelijkheden. Dit heeft dus veel spannende mogelijkheden. Volgens mij zijn deze projecten die ik je heb laten zien, slechts een kleine stap op weg naar deze toekomst, als we deze nieuwe technologieën implementeren, naar een nieuwe wereld die zichzelf assembleert.
Thank you.
Dank u.
(Applause)
(Applaus)