Skylar Tibbits: Can we make things that make themselves?

מתרגם: Ido Dekkers מבקר: Sigal Tifferet

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.

ואז אשווה אותו לכמה מערכות טבעיות.

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

אז במצב הנוכחי של היצור, יש לנו גורדי שחקים --

two and a half years [of assembly time],

שנתיים וחצי,

500,000 to a million parts,

500,000 עד מיליון חלקים,

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.

חמש שנים, 2.5 מיליון חלקים.

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,

יכולים להתקפל ב 10,000 ננושניות,

or DNA with three billion base pairs

או DNA עם שלושה מיליארד זוגות בסיס

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.

והם יכולים לתקן את עצמם במשך חייהם.

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.

ואני חושב שהמפתח לזה הוא הרכבה עצמית.

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.

בעיקרון הDNA של איך הבניינים שלנו עובדים.

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.

כדי להבטיח שבנינו בהצלחה את מה שרצינו.

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

אז אני אראה לכם כמה פרוייקטים

that my colleagues and I at MIT are working on

שעמיתיי ואני בMIT עובדים עליהם

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.

חלבונים באורך 2.5 מטר ו3.5 מטר.

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, מינוס 120, 0, 0,

120, negative 120 -- something like that;

120, מינוס 120 -- משהו כזה;

so a sequence of angles, or turns,

אז רצף זויות, או פיתולים,

and you send that sequence through the string.

ואתם שולחים את הרצף הזה דרך מחרוזת.

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

כל יחידה לוקחת את המסר שלה -- אז מינוס 120.

it rotates to that, checks if it got there

היא מסתובבת לזה, בודקת אם היא הגיעה לשם

and then passes it to its neighbor.

ואז מעבירה אותה לשכנה שלה.

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.

ישר לתוך החלקים שלכם.

So this is a NAND gate.

אז זה שער NAND.

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.

אז משמאל,קלט של [1,1] שווה ליציאה 0, שיורד למטה.

On the right-hand side,

מימין,

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

קלט של [0,0] זו יציאה 1, שעולה למעלה.

And so what that really means

אז מה שזה באמת אומר

is that our structures now contain the blueprints

זה שהמבנה שלנו עכשיו מכיל את התוכניות

of what we want to build.

של מה שהוא אמור לבנות.

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.

זה מוטמע ישירות; אין פקודות חיצוניות.

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.

או חד מימדית, דו מימדית -- לתוך השרשרת בצורה פאסיבית לגמרי.

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.

לעולם חדש שמרכיב את עצמו.

Thank you.

תודה לכם.

(Applause)

(מחיאות כפיים)