Skylar Tibbits: Can we make things that make themselves?

Vertaald door: Els De Keyser Nagekeken door: Matthias Valvekens

Today I'd like to show you

Vandaag wil ik jullie

the future of the way we make things.

de toekomst tonen van de manier waarop we dingen maken.

I believe that soon our buildings and machines

Ik geloof dat onze gebouwen en machines

will be self-assembling,

zichzelf binnenkort zullen assembleren,

replicating and repairing themselves.

repliceren en repareren.

So I'm going to show you

Dus ik ga je laten zien

what I believe is the current state of manufacturing,

wat volgens mij de huidige stand van de productie is,

and then compare that to some natural systems.

en die dan vergelijken met een aantal natuurlijke systemen.

So in the current state of manufacturing, we have skyscrapers --

In de huidige stand van de productie hebben we wolkenkrabbers.

two and a half years [of assembly time],

Twee en een half jaar,

500,000 to a million parts,

500.000 tot een miljoen onderdelen,

fairly complex,

vrij complexe,

new, exciting technologies in steel, concrete, glass.

nieuwe en spannende technologieën in staal, beton, glas.

We have exciting machines

We hebben spannende machines

that can take us into space --

die ons naar de ruimte kunnen brengen -

five years [of assembly time], 2.5 million parts.

vijf jaar, 2,5 miljoen onderdelen.

But on the other side, if you look at the natural systems,

Maar aan de andere kant, als je kijkt naar de natuurlijke systemen,

we have proteins

hebben we eiwitten

that have two million types,

die twee miljoen soorten tellen,

can fold in 10,000 nanoseconds,

en die zich ontvouwen in 10.000 nanoseconden,

or DNA with three billion base pairs

of DNA met drie miljard basenparen

we can replicate in roughly an hour.

die we kunnen repliceren in ongeveer een uur.

So there's all of this complexity

Dus er zit een hoop complexiteit

in our natural systems,

in onze natuurlijke systemen,

but they're extremely efficient,

maar ze zijn zeer efficiënt,

far more efficient than anything we can build,

veel efficiënter dan wat we kunnen bouwen,

far more complex than anything we can build.

veel complexer dan alles wat we kunnen bouwen.

They're far more efficient in terms of energy.

Ze zijn veel efficiënter in termen van energie.

They hardly ever make mistakes.

Ze maken bijna nooit fouten.

And they can repair themselves for longevity.

En ze kunnen zichzelf herstellen om lang mee te gaan.

So there's something super interesting about natural systems.

Er is dus iets super-interessants aan natuurlijke systemen.

And if we can translate that

Als we dat kunnen vertalen

into our built environment,

naar onze gebouwde omgeving,

then there's some exciting potential for the way that we build things.

dan zijn er nog een aantal interessante mogelijkheden voor de manier waarop we dingen bouwen.

And I think the key to that is self-assembly.

Ik denk dat de sleutel daartoe zelfassemblage is.

So if we want to utilize self-assembly in our physical environment,

Als we zelfassemblage willen gebruiken in onze fysieke omgeving,

I think there's four key factors.

zijn er volgens mij vier belangrijke factoren.

The first is that we need to decode

De eerste is dat we de volledige complexiteit

all of the complexity of what we want to build --

van wat we willen bouwen, moeten ontcijferen -

so our buildings and machines.

dat wil zeggen onze gebouwen en machines.

And we need to decode that into simple sequences --

We moeten ze ontcijferen in eenvoudige sequenties -

basically the DNA of how our buildings work.

zowat het DNA van hoe onze gebouwen werken.

Then we need programmable parts

Dan hebben we programmeerbare onderdelen nodig

that can take that sequence

die deze sequenties kunnen gebruiken om

and use that to fold up, or reconfigure.

zich op te vouwen, of opnieuw te configureren.

We need some energy that's going to allow that to activate,

We hebben wat energie om ​​dat te activeren,

allow our parts to be able to fold up from the program.

om onze delen te doen opvouwen volgens het programma.

And we need some type of error correction redundancy

En we hebben een soort van foutcorrectie-redundantie

to guarantee that we have successfully built what we want.

om te garanderen dat we met succes hebben gebouwd wat we willen.

So I'm going to show you a number of projects

Ik zal een aantal projecten laten zien

that my colleagues and I at MIT are working on

waar mijn collega's en ik aan het MIT aan werken

to achieve this self-assembling future.

om deze toekomst van zelfassemblage te bereiken.

The first two are the MacroBot and DeciBot.

De eerste twee zijn de MacroBot en DeciBot.

So these projects are large-scale reconfigurable robots --

Deze projecten zijn grootschalige herconfigureerbare robots -

8 ft., 12 ft. long proteins.

eiwitten van 2,5 à 3,5 meter.

They're embedded with mechanical electrical devices, sensors.

Ze zijn volgestouwd met mechanische elektrische apparaten, sensoren.

You decode what you want to fold up into,

Je ontcijfert waarin je je wil opvouwen,

into a sequence of angles --

in een opeenvolging van hoeken -

so negative 120, negative 120, 0, 0,

dus min 120, min 120, 0, 0,

120, negative 120 -- something like that;

120, 120 negatief - zoiets;

so a sequence of angles, or turns,

dus een opeenvolging van hoeken of bochten,

and you send that sequence through the string.

en je stuurt die volgorde door de string.

Each unit takes its message -- so negative 120 --

Elke unit neemt zijn boodschap - dus min 120.

it rotates to that, checks if it got there

Het roteert daarheen, controleert of het er is geraakt,

and then passes it to its neighbor.

en dan geeft het door aan zijn buurman.

So these are the brilliant scientists,

Dit zijn de briljante wetenschappers,

engineers, designers that worked on this project.

ingenieurs, ontwerpers die aan dit project hebben gewerkt.

And I think it really brings to light:

Volgens mij wijst dit erop:

Is this really scalable?

is dit echt schaalbaar?

I mean, thousands of dollars, lots of man hours

Ik bedoel, duizenden dollars, vele manuren

made to make this eight-foot robot.

zijn gepresteerd om deze robot van acht meter te maken.

Can we really scale this up? Can we really embed robotics into every part?

Kunnen we dit opschalen? Kunnen we echt robotica inbouwen in elk deel?

The next one questions that

Het volgende stelt dat in vraag

and looks at passive nature,

en kijkt naar de passieve natuur,

or passively trying to have reconfiguration programmability.

of passief proberen om programmeerbaarheid van herconfiguratie te bereiken.

But it goes a step further,

Maar het gaat een stap verder,

and it tries to have actual computation.

en het probeert daadwerkelijke berekening te bereiken.

It basically embeds the most fundamental building block of computing,

Het omvat de meest fundamentele bouwsteen van computers,

the digital logic gate,

de digitale logische poort,

directly into your parts.

rechtstreeks in je onderdelen.

So this is a NAND gate.

Dus dit is een NAND-poort.

You have one tetrahedron which is the gate

Je hebt een tetraëder, de poort

that's going to do your computing,

die je berekening gaat doen,

and you have two input tetrahedrons.

en je hebt twee input-tetraëders.

One of them is the input from the user, as you're building your bricks.

Een van hen is de input van de gebruiker, terwijl je je bakstenen bouwt.

The other one is from the previous brick that was placed.

De andere is van de vorige steen die was geplaatst.

And then it gives you an output in 3D space.

En dan geeft het je een resultaat in een 3D-ruimte.

So what this means

Dus wat dit betekent,

is that the user can start plugging in what they want the bricks to do.

is dat de gebruiker opdrachten voor de bakstenen kan beginnen aansluiten.

It computes on what it was doing before

Het berekent op basis van wat het voordien aan het doen was

and what you said you wanted it to do.

en van jouw opdracht.

And now it starts moving in three-dimensional space --

En nu begint het te bewegen in een drie-dimensionale ruimte -

so up or down.

dus omhoog of omlaag.

So on the left-hand side, [1,1] input equals 0 output, which goes down.

Aan de linkerkant is de [1,1]-ingang gelijk aan de 0-uitgang, die naar beneden gaat.

On the right-hand side,

Aan de rechterkant

[0,0] input is a 1 output, which goes up.

is [0,0]-ingang is een 1-uitgang, die omhoog gaat.

And so what that really means

Dus wat dat echt betekent,

is that our structures now contain the blueprints

is dat onze structuren nu de blauwdrukken bevatten

of what we want to build.

van wat we willen bouwen.

So they have all of the information embedded in them of what was constructed.

Alle informatie over wat er gebouwd is, zit ingebouwd.

So that means that we can have some form of self-replication.

Dus dat betekent dat we een bepaalde vorm van zelf-replicatie hebben.

In this case I call it self-guided replication,

In dit geval noem ik het zelf-geleide replicatie,

because your structure contains the exact blueprints.

omdat je structuur de exacte blauwdrukken bevat.

If you have errors, you can replace a part.

In geval van fouten, kan je een onderdeel vervangen.

All the local information is embedded to tell you how to fix it.

Alle lokale informatie is ingebed om je te vertellen hoe dit te verhelpen.

So you could have something that climbs along and reads it

Je zou dus iets kunnen hebben dat erlangs klimt en het afleest,

and can output at one to one.

en een één-op-één-resultaat aflevert

It's directly embedded; there's no external instructions.

Het is rechtstreeks ingebouwd, er zijn geen externe instructies.

So the last project I'll show is called Biased Chains,

Het laatste project dat ik zal je laten zien, heet Bevooroordeelde Ketens,

and it's probably the most exciting example that we have right now

en het is waarschijnlijk het meest opwindende voorbeeld dat op dit moment hebben

of passive self-assembly systems.

van passieve zelfassemblagesystemen.

So it takes the reconfigurability

Het neemt de herconfigureerbaarheid

and programmability

en de programmeerbaarheid

and makes it a completely passive system.

en maakt er een volledig passief systeem van.

So basically you have a chain of elements.

Dus eigenlijk heb je een keten van elementen.

Each element is completely identical,

Elk element is volledig identiek,

and they're biased.

en ze zijn bevooroordeeld.

So each chain, or each element, wants to turn right or left.

Dus elke keten, of elk element, wil rechts of links.

So as you assemble the chain, you're basically programming it.

Als je de ketting monteert, ben je eigenlijk aan het programmeren.

You're telling each unit if it should turn right or left.

Je vertelt elke eenheid of ze naar rechts of naar links moet draaien.

So when you shake the chain,

Dus als je de ketting te schudt,

it then folds up

vouwt ze zich op

into any configuration that you've programmed in --

in elke configuratie die je erin hebt geprogrammeerd -

so in this case, a spiral,

dus in dit geval, een spiraal,

or in this case,

of in dit geval,

two cubes next to each other.

twee kubussen naast elkaar.

So you can basically program

Dus je kunt in principe

any three-dimensional shape --

een drie-dimensionale vorm programmeren -

or one-dimensional, two-dimensional -- up into this chain completely passively.

of een-dimensionaal, twee-dimensionale - in deze keten, volledig passief.

So what does this tell us about the future?

Dus wat zegt dit ons over de toekomst?

I think that it's telling us

Ik denk dat het ons vertelt

that there's new possibilities for self-assembly, replication, repair

dat er nieuwe mogelijkheden voor zelfassemblage, replicatie, reparatie zitten

in our physical structures, our buildings, machines.

in onze fysieke structuren, onze gebouwen, machines.

There's new programmability in these parts.

Er zit nieuwe programmeerbaarheid in deze onderdelen.

And from that you have new possibilities for computing.

Daaruit volgen nieuwe mogelijkheden voor computergebruik.

We'll have spatial computing.

We zullen ruimtelijke berekening krijgen.

Imagine if our buildings, our bridges, machines,

Stel je voor dat onze gebouwen, onze bruggen, machines,

all of our bricks could actually compute.

al onze stenen eigenlijk konden rekenen.

That's amazing parallel and distributed computing power,

Dat is een verbazingwekkende parallelle en gedistribueerde rekenkracht,

new design possibilities.

dat zijn nieuwe designmogelijkheden.

So it's exciting potential for this.

Dit heeft dus veel spannende mogelijkheden.

So I think these projects I've showed here

Volgens mij zijn deze projecten die ik je heb laten zien,

are just a tiny step towards this future,

slechts een kleine stap op weg naar deze toekomst,

if we implement these new technologies

als we deze nieuwe technologieën implementeren,

for a new self-assembling world.

naar een nieuwe wereld die zichzelf assembleert.

Thank you.

Dank u.

(Applause)

(Applaus)