Rust en contraste

Rust es un lenguaje a la vez de bajo nivel (pegado al metal) y alto nivel (con un gran poder de abstracción). ¿Cómo se logra esto? Lo exploraremos en contraste con lenguajes más habituales y otras tendencias actuales, echando un ojo a cómo queda en la práctica.

Transcript

1. en contraste ust
2. Rust is a systems programming language that runs 
 blazingly fast, prevents almost all crashes, and
 eliminates data races.
3. Contrastes • C: Tipos débiles, control crudo, sin runtime. • Python: Tipos dinámicos, control indirecto, runtime con GC. • Go: Tipos fuertes, control directo, runtime con concurrencia y GC. • C++: Tipos fuertes, control crudo, sin runtime. • Haskell: Tipos muy fuertes, memoria abstraída, runtime con concurrencia y GC.
4. Rust: http://is.gd/FyQvQi Python: http://codepad.org/KNiwdCOY C: http://codepad.org/ESxskYTi
5. Rust vs C
6. fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(p);
 return 0;
 }
7. fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(p);
 return 0;
 } Point{x: 1, y:2} point{x: 1, y:2}
8. fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(p);
 return 0;
 } Point{x: 1, y:2} point{x: 1, y:2}
9. Point{x: 1, y:2} point{x: 1, y:2} point{x: 1, y:2} fn print_point(p: Point) {
 println!("({}, {})", p.x, p.y);
 } void print_point(point p) {
 printf("(%d, %d)\n", p.x, p.y);
 } move
10. fn print_point(p: Point) {
 println!("({}, {})", p.x, p.y);
 } void print_point(point p) {
 printf("(%d, %d)\n", p.x, p.y);
 } Point{x: 1, y:2} point{x: 1, y:2} point{x: 1, y:2}
11. fn print_point(p: Point) {
 println!("({}, {})", p.x, p.y);
 } void print_point(point p) {
 printf("(%d, %d)\n", p.x, p.y);
 } point{x: 1, y:2}
12. fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(p);
 return 0;
 } point{x: 1, y:2}
13. fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(p);
 return 0;
 }
14. Rust vs Python
15. fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p);
 } p = Point(1, 2)
 print_point(p)

16. fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p);
 } Point{x: 1, y:2} p = p = Point(1, 2)
 print_point(p)
 point{x: 1, y:2}
17. fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p);
 } Point{x: 1, y:2} p = p = Point(1, 2)
 print_point(p)
 point{x: 1, y:2}
18. Point{x: 1, y:2} fn print_point(p: Point) {
 println!("({}, {})", p.x, p.y);
 } p = def print_point(p):
 print('(%s, %s)' % (p.x, p.y))
 point{x: 1, y:2} p =
19. fn print_point(p: Point) {
 println!("({}, {})", p.x, p.y);
 } Point{x: 1, y:2} p = def print_point(p):
 print('(%s, %s)' % (p.x, p.y))
 point{x: 1, y:2} p =
20. fn print_point(p: Point) {
 println!("({}, {})", p.x, p.y);
 } p = def print_point(p):
 print('(%s, %s)' % (p.x, p.y))
 point{x: 1, y:2}
21. fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p);
 } p = Point(1, 2)
 print_point(p)
 point{x: 1, y:2}
22. fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p);
 } p = Point(1, 2)
 print_point(p)
 point{x: 1, y:2}
23. Rust: http://is.gd/O4Z19J Python: http://codepad.org/6bSRT3Lx C: http://codepad.org/zUAAbrPd
24. Rust vs C
25. fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p); print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(p); print_point(p);
 return 0;
 }
26. Point{x: 1, y:2} point{x: 1, y:2} fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p); print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(p); print_point(p);
 return 0;
 }
27. Point{x: 1, y:2} point{x: 1, y:2} fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p); print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(p); print_point(p);
 return 0;
 }
28. Point{x: 1, y:2} point{x: 1, y:2} point{x: 1, y:2} fn print_point(p: Point) {
 println!("({}, {})", p.x, p.y);
 } void print_point(point p) {
 printf("(%d, %d)\n", p.x, p.y);
 }
29. fn print_point(p: Point) {
 println!("({}, {})", p.x, p.y);
 } void print_point(point p) {
 printf("(%d, %d)\n", p.x, p.y);
 } Point{x: 1, y:2} point{x: 1, y:2} point{x: 1, y:2}
30. fn print_point(p: Point) {
 println!("({}, {})", p.x, p.y);
 } void print_point(point p) {
 printf("(%d, %d)\n", p.x, p.y);
 } point{x: 1, y:2}
31. point{x: 1, y:2} fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p); print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(p); print_point(p);
 return 0;
 } ERROR!!! error: use of moved value: `p`
32. Rust: http://is.gd/9lCe0A Python: http://codepad.org/6bSRT3Lx C: http://codepad.org/GmrSgOz9
33. fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p); print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(&p); print_point(&p);
 return 0;
 }
34. Point{x: 1, y:2} point{x: 1, y:2} fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p); print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(&p); print_point(&p);
 return 0;
 }
35. Point{x: 1, y:2} point{x: 1, y:2} fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p); print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(&p); print_point(&p);
 return 0;
 }
36. point{x: 1, y:2} p = & fn print_point(p: &Point) {
 println!("({}, {})", p.x, p.y);
 } void print_point(point* p) {
 printf("(%d, %d)\n", p->x, p->y);
 } p = & Point{x: 1, y:2} borrow
37. fn print_point(p: &Point) {
 println!("({}, {})", p.x, p.y);
 } void print_point(point* p) {
 printf("(%d, %d)\n", p->x, p->y);
 } point{x: 1, y:2} p = & p = & Point{x: 1, y:2}
38. fn print_point(p: &Point) {
 println!("({}, {})", p.x, p.y);
 } void print_point(point* p) {
 printf("(%d, %d)\n", p->x, p->y);
 } point{x: 1, y:2} Point{x: 1, y:2}
39. point{x: 1, y:2} fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p); print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(&p); print_point(&p);
 return 0;
 } Point{x: 1, y:2}
40. point{x: 1, y:2} fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p); print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(&p); print_point(&p);
 return 0;
 }
41. fn main() {
 let p = Point{x: 1, y: 2};
 print_point(p); print_point(p);
 } int main() {
 point p = {.x = 1, .y = 2};
 print_point(&p); print_point(&p);
 return 0;
 }
42. Rust: http://is.gd/7yA3n7 Python: http://codepad.org/ijrFOJgn C: http://codepad.org/bIT0VToR
43. Rust: http://is.gd/7yA3n7 Rust: http://is.gd/p5AUre Rust: http://is.gd/W2qALa Python: http://codepad.org/ijrFOJgn C: http://codepad.org/bIT0VToR
44. Rust: http://is.gd/qRwW17 Python: http://codepad.org/A56flItO C: http://codepad.org/7FVZrnit
45. Rust vs Python
46. p = make_point() 
 print_point(p) fn main() {
 let p = make_point();
 print_point(p); }
47. p = make_point() 
 print_point(p) fn main() {
 let p = make_point();
 print_point(p); }
48. def make_point():
 return Point(1, 2) fn make_point() -> Point {
 Point{x: 1, y: 2}
 }
49. def make_point():
 return Point(1, 2) fn make_point() -> Point {
 Point{x: 1, y: 2}
 } point{x: 1, y:2} Point{x: 1, y:2}
50. Point{x: 1, y:2} p = point{x: 1, y:2} p = make_point() 
 print_point(p) fn main() {
 let p = make_point();
 print_point(p); }
51. Point{x: 1, y:2} p = point{x: 1, y:2} p = make_point() 
 print_point(p) fn main() {
 let p = make_point();
 print_point(p); }
52. p = make_point() 
 print_point(p) fn main() {
 let p = make_point();
 print_point(p); } point{x: 1, y:2}
53. p = make_point() 
 print_point(p) fn main() {
 let p = make_point();
 print_point(p); } point{x: 1, y:2}
54. Rust: http://is.gd/Ce25p5 Python: http://codepad.org/A56flItO C: http://codepad.org/6NMZeNRL
55. Rust vs Python
56. p = make_point() 
 print_point(p) fn main() {
 let p = make_point();
 print_point(p); }
57. p = make_point() 
 print_point(p) fn main() {
 let p = make_point();
 print_point(p); }
58. def make_point():
 return Point(1, 2) fn make_point() -> &Point {
 &Point{x: 1, y: 2}
 }
59. def make_point():
 return Point(1, 2) point{x: 1, y:2} Point{x: 1, y:2} fn make_point() -> &Point {
 &Point{x: 1, y: 2}
 }
60. p = & p = point{x: 1, y:2} p = make_point() 
 print_point(p) fn main() {
 let p = make_point();
 print_point(p); } ERROR!!! error: missing lifetime specifier
61. Rust vs C
62. p = & p = & int main() {
 point* p = make_point();
 print_point(p);
 return 0;
 } fn main() {
 let p = make_point();
 print_point(p); } ERROR!!! error: missing lifetime specifier
63. p = & p = & int main() {
 point* p = make_point();
 print_point(p);
 return 0;
 } fn main() {
 let p = make_point();
 print_point(p); } ERROR!!! error: missing lifetime specifier (1571071448, 32767)
64. p = & p = & int main() {
 point* p = make_point();
 print_point(p);
 return 0;
 } fn main() {
 let p = make_point();
 print_point(p); } ERROR!!! error: missing lifetime specifier
65. p = & int main() {
 point* p = make_point();
 print_point(p);
 return 0;
 } fn main() {
 let p = make_point();
 print_point(p); } ERROR!!! error: missing lifetime specifier
66. Rust: http://is.gd/e3FV5F Python: http://codepad.org/A56flItO C: http://codepad.org/4cHyTNqz
67. Rust vs Python
68. p = make_point() 
 print_point(p) fn main() {
 let p = &*make_point();
 print_point(p); }
69. p = make_point() 
 print_point(p) fn main() {
 let p = &*make_point();
 print_point(p); }
70. def make_point():
 return Point(1, 2) fn make_point() -> Box<Point> {
 Box::new(Point{x: 1, y: 2})
 }
71. def make_point():
 return Point(1, 2) point{x: 1, y:2} p = box fn make_point() -> Box<Point> {
 Box::new(Point{x: 1, y: 2})
 } Point{x: 1, y:2}
72. p = & p = point{x: 1, y:2} p = make_point() 
 print_point(p) fn main() {
 let p = &*make_point();
 print_point(p); } Point{x: 1, y:2}
73. p = & p = point{x: 1, y:2} p = make_point() 
 print_point(p) fn main() {
 let p = &*make_point();
 print_point(p); } Point{x: 1, y:2}
74. point{x: 1, y:2} p = make_point() 
 print_point(p) fn main() {
 let p = &*make_point();
 print_point(p); } Point{x: 1, y:2}
75. p = make_point() 
 print_point(p) fn main() {
 let p = &*make_point();
 print_point(p); } point{x: 1, y:2}
76. Rust vs C
77. p = & int main() {
 point* p = make_point();
 print_point(p);
 return 0;
 } p = & fn main() {
 let p = &*make_point();
 print_point(p); } Point{x: 1, y:2} point{x: 1, y:2}
78. int main() {
 point* p = make_point();
 print_point(p);
 return 0;
 } (1, 2) p = & fn main() {
 let p = &*make_point();
 print_point(p); } Point{x: 1, y:2} p = & point{x: 1, y:2} (1, 2)
79. int main() {
 point* p = make_point();
 print_point(p);
 return 0;
 } fn main() {
 let p = &*make_point();
 print_point(p); } point{x: 1, y:2} Point{x: 1, y:2}
80. int main() {
 point* p = make_point();
 print_point(p);
 return 0;
 } fn main() {
 let p = &*make_point();
 print_point(p); } point{x: 1, y:2}
81. int main() {
 point* p = make_point();
 print_point(p);
 return 0;
 } fn main() {
 let p = &*make_point();
 print_point(p); } point{x: 1, y:2} 10 horas más tarde...
82. Rust: http://is.gd/e3FV5F Python: http://codepad.org/A56flItO C: http://codepad.org/4cHyTNqz C: http://codepad.org/d9MtkrnT
83. Ownership Los valores pertenecen a un scope. Los valores se prestan durante un scope. Borrow inmutable Borrow mutable Move Point{x: 1, y:2} Point{x: 1, y:2} • Copia de memoria. • Original no reutilizable. Point{x: 1, y:2} & Point{x: 1, y:2} • Puntero. • Original inutilizado. • Puede haber varios en
 un mismo scope. Point{x: 1, y:2} & Point{x: 1, y:2} • Puntero. • Original inutilizado. • Sólo uno en un mismo
 scope.
84. – Alfred N. Whitehead “Civilization advances by extending the number of important operations which we can perform without thinking about them.”
85. – Rob Pike: Less is exponentially more “Bell Labs centers were originally assigned three-letter numbers: 111 for Physics Research, 127 for Computing Sciences Research, and so on. In the early 1980s a memo came around announcing that as our understanding of research had grown, it had become necessary to add another digit so we could better characterize our work. So our center became 1127. Ron Hardin joked, half-seriously, that if we really understood our world better, we could drop a digit and go down from 127 to just 27.”
86. Tipos: ¿qué son? • ¿Anotaciones de cuánta memoria ocupa cada variable y cada valor? • ¿Taxonomía del dominio de nuestro programa, con operaciones asociadas? • ¿Lo que el compilador puede comprobar por nosotros sobre nuestros valores, variables y operaciones?
87. Tipado estático • Potente abstracción. • Que el compilador puede comprobar. • Y que, adicionalmente, puede ayudar al compilador a compilar eficientemente. • En Rust, con este significado, incluye las reglas de ownership (borrow checker).
88. np->size
89. PropertyDataEditorRegistryBuilderFactory defaultPropertyDataEditorRegistryBuilderFactory = null; defaultPropertyDataEditorRegistryBuilderFactory .getPropertyDataEditorRegistryBuilder();
 NULLPOINTEREXCEPTION!!!
90. let m: Option<MyType> = None; m.do_something(); NO COMPILA!!!
91. let m: Option<MyType> = None; if let Some(x) = m { x.do_something(); }
 m.and_then(|&x| { x.do_something(); }
 match m { case Some(x) => { x.do_something(); }, case None => { ... }, }
92. El coste de la abstracción Lo que en C parece... ... en realidad es... time_t* t = add_duration(&times[i], duration); free(t); No hay abstracción = No hay coste time_t* t = add_duration(&times[i], duration); free(t);
93. El coste de la abstracción Lo que en Go parece... ... en realidad es... t := times[i].Add(duration) if (times.len < i) {
 panic(__static_bounds_err);
 }
 *Time t = Time_Add(times->contents[i], duration); garbage_collector();
 scheduler();
 Coste de la runtime = ¿?
94. El coste de la abstracción Lo que en Python parece... ... en realidad es... t = times[i].add(duration) Obj* times = lookup(scope, 'times');
 Obj* gi = lookup(times->attrs, '__getitem__');
 Obj* call = lookup(gi, '__call__');
 Obj* i = lookup(scope, 'i');
 Obj* args = make_args(2); // Malloc, etc.
 Obj* kwargs = make_kwargs(0);
 args[0] = times;
 args[1] = i;
 // Incluye bounds checking, lookups, etc.
 Obj* t = call->call(args, kwargs);
 Obj* add = lookup(t->attrs, 'add');
 call = lookup(add, '__call__');
 Obj* duration = lookup(scope, 'duration');
 args = make_args(2); // Malloc, etc.

95. args = make_args(2); // Malloc, etc.
 Obj* kwargs = make_kwargs(0);
 args[0] = t;
 args[1] = duration;
 t = call->call(args, kwargs); Más: coste de la runtime (GC)
96. El coste de la abstracción Lo que en Rust parece... ... en realidad es... let t = times[i].add(duration); if (times.len < i) {
 panic(__static_bounds_err);
 }
 *Time t = Time_add(times->contents[i], duration); drop(t); Coste de la runtime = ninguno
97. El coste de la abstracción Lo que en Go parece... ... en realidad es... t := times.At(i).(*Time).Add(duration) if (LinkedList_Length(&times) < i) {
 panic(__static_bounds_err);
 }
 Iface* at = LinkedList_At(&times, i);
 if (at->type != __type__time_ptr) {
 panic(__static_type_assert);
 }
 if (at->value == NULL) {
 panic(__static_null_ptr);
 }
 Time* t = Time_Add((Time*)at->value,
 duration);
 garbage_collector();
 scheduler(); Dynamic dispatch
98. El coste de la abstracción Lo que en Rust parece... ... en realidad es... let t = times[i].add(duration); if (LinkedList_Length_for_Time_ptr( &times) < i) {
 panic(__static_bounds_err);
 }
 Time* at = LinkedList_At_for_Time_ptr( &times, i);
 Time* t = Time_Add(at, duration);
 drop(t); Tipos genéricos = Static dispatch
99. Rust: http://is.gd/AWJgfv Go: http://play.golang.org/p/OqnRtU1QyN
100. Rust
101. fn make_point_and_print_later() {
 let p = Point{x: 1, y: 2};
 Thread::spawn(|| {
 timer::sleep( Duration::seconds(1));
 print_point(&p);
 });
 println!("Created {} and ...
 }
102. fn make_point_and_print_later() {
 let p = Point{x: 1, y: 2};
 Thread::spawn(|| {
 timer::sleep( Duration::seconds(1));
 print_point(&p);
 });
 println!("Created {} and ...
 } Point{x: 1, y:2}
103. fn make_point_and_print_later() {
 let p = Point{x: 1, y: 2};
 Thread::spawn(|| {
 timer::sleep( Duration::seconds(1));
 print_point(&p);
 });
 println!("Created {} and ...
 } Point{x: 1, y:2}
104. fn make_point_and_print_later() {
 let p = Point{x: 1, y: 2};
 Thread::spawn(|| {
 timer::sleep( Duration::seconds(1));
 print_point(&p);
 });
 println!("Created {} and ...
 } Point{x: 1, y:2} p = & || {
 timer::sleep(Duration::seconds(1));
 print_point(&p);
 }
105. fn make_point_and_print_later() {
 let p = Point{x: 1, y: 2};
 Thread::spawn(|| {
 timer::sleep( Duration::seconds(1));
 print_point(&p);
 });
 println!("Created {} and ...
 } Point{x: 1, y:2} p = & || {
 timer::sleep(Duration::seconds(1));
 print_point(&p);
 }
106. fn make_point_and_print_later() {
 let p = Point{x: 1, y: 2};
 Thread::spawn(|| {
 timer::sleep( Duration::seconds(1));
 print_point(&p);
 });
 println!("Created {} and ...
 } p = & || {
 timer::sleep(Duration::seconds(1));
 print_point(&p);
 }
107. fn make_point_and_print_later() {
 let p = Point{x: 1, y: 2};
 Thread::spawn(|| {
 timer::sleep( Duration::seconds(1));
 print_point(&p);
 });
 println!("Created {} and ...
 } p = & || {
 timer::sleep(Duration::seconds(1));
 print_point(&p);
 } ERROR!!! error: cannot infer an appropriate lifetime due to conflicting requirements
108. Rust: http://is.gd/AWJgfv Rust: http://is.gd/sO4WyN Go: http://play.golang.org/p/OqnRtU1QyN
109. Rust: http://is.gd/AWJgfv Rust: http://is.gd/sO4WyN Rust: http://is.gd/J2TTnF Go: http://play.golang.org/p/OqnRtU1QyN
110. fn make_point_and_print_later() {
 let p = Point{x: 1, y: 2};
 Thread::spawn(move|| {
 timer::sleep( Duration::seconds(1));
 print_point(&p);
 });
 } Point{x: 1, y:2} || {
 timer::sleep(Duration::seconds(1));
 print_point(&p);
 }
111. Go
112. func makePointAndPrintLater() {
 p := Point{x: 1, y: 2}
 go func() {
 time.Sleep(time.Second)
 printPoint(&p)
 }()
 fmt.Printf("Created %v and...
 }
113. Point{x: 1, y:2} func makePointAndPrintLater() {
 p := Point{x: 1, y: 2}
 go func() {
 time.Sleep(time.Second)
 printPoint(&p)
 }()
 fmt.Printf("Created %v and...
 }
114. Point{x: 1, y:2} func makePointAndPrintLater() {
 p := Point{x: 1, y: 2}
 go func() {
 time.Sleep(time.Second)
 printPoint(&p)
 }()
 fmt.Printf("Created %v and...
 } p = & func() {
 time.Sleep(time.Second)
 printPoint(&p)
 }
115. p = & func makePointAndPrintLater() {
 p := Point{x: 1, y: 2}
 go func() {
 time.Sleep(time.Second)
 printPoint(&p)
 }()
 fmt.Printf("Created %v and...
 } p = & func() {
 time.Sleep(time.Second)
 printPoint(&p)
 } point{x: 1, y:2}
116. p = & func makePointAndPrintLater() {
 p := Point{x: 1, y: 2}
 go func() {
 time.Sleep(time.Second)
 printPoint(&p)
 }()
 fmt.Printf("Created %v and...
 } p = & func() {
 time.Sleep(time.Second)
 printPoint(&p)
 } point{x: 1, y:2}
117. p = & func makePointAndPrintLater() {
 p := Point{x: 1, y: 2}
 go func() {
 time.Sleep(time.Second)
 printPoint(&p)
 }()
 fmt.Printf("Created %v and...
 } p = & func() {
 time.Sleep(time.Second)
 printPoint(&p)
 } point{x: 1, y:2}
118. func makePointAndPrintLater() {
 p := Point{x: 1, y: 2}
 go func() {
 time.Sleep(time.Second)
 printPoint(&p)
 }()
 fmt.Printf("Created %v and...
 } p = & func() {
 time.Sleep(time.Second)
 printPoint(&p)
 } point{x: 1, y:2}
119. func makePointAndPrintLater() {
 p := Point{x: 1, y: 2}
 go func() {
 time.Sleep(time.Second)
 printPoint(&p)
 }()
 fmt.Printf("Created %v and...
 } p = & func() {
 time.Sleep(time.Second)
 printPoint(&p)
 } point{x: 1, y:2}
120. func makePointAndPrintLater() {
 p := Point{x: 1, y: 2}
 go func() {
 time.Sleep(time.Second)
 printPoint(&p)
 }()
 fmt.Printf("Created %v and...
 } func() {
 time.Sleep(time.Second)
 printPoint(&p)
 } point{x: 1, y:2}
121. func makePointAndPrintLater() {
 p := Point{x: 1, y: 2}
 go func() {
 time.Sleep(time.Second)
 printPoint(&p)
 }()
 fmt.Printf("Created %v and...
 } func() {
 time.Sleep(time.Second)
 printPoint(&p)
 } point{x: 1, y:2}
122. Rust: http://is.gd/AWJgfv Rust: http://is.gd/sO4WyN Rust: http://is.gd/J2TTnF Rust: http://is.gd/4Rgz2o Go: http://play.golang.org/p/OqnRtU1QyN
123. fn make_point_and_print_later() {
 let p = Arc::new( Point{x: 1, y: 2});
 let p_ref = p.clone();
 Thread::spawn(move|| {
 timer::sleep( Duration::seconds(1));
 print_point(&*p_ref);
 });
 println!("Created {} and ...
 } point{x: 1, y:2} refs = 2 p = arc p_ref = arc
124. fn make_point_and_print_later() {
 let p = Arc::new( Point{x: 1, y: 2});
 let p_ref = p.clone();
 Thread::spawn(move|| {
 timer::sleep( Duration::seconds(1));
 print_point(&*p_ref);
 });
 println!("Created {} and ...
 } p_ref = arc || {
 timer::sleep(Duration::seconds(1));
 print_point(&*p_ref);
 } point{x: 1, y:2} refs = 2 p = arc
125. fn make_point_and_print_later() {
 let p = Arc::new( Point{x: 1, y: 2});
 let p_ref = p.clone();
 Thread::spawn(move|| {
 timer::sleep( Duration::seconds(1));
 print_point(&*p_ref);
 });
 println!("Created {} and ...
 } p_ref = arc || {
 timer::sleep(Duration::seconds(1));
 print_point(&*p_ref);
 } point{x: 1, y:2} refs = 2 p = arc
126. fn make_point_and_print_later() {
 let p = Arc::new( Point{x: 1, y: 2});
 let p_ref = p.clone();
 Thread::spawn(move|| {
 timer::sleep( Duration::seconds(1));
 print_point(&*p_ref);
 });
 println!("Created {} and ...
 } p_ref = arc || {
 timer::sleep(Duration::seconds(1));
 print_point(&*p_ref);
 } point{x: 1, y:2} refs = 1
127. fn make_point_and_print_later() {
 let p = Arc::new( Point{x: 1, y: 2});
 let p_ref = p.clone();
 Thread::spawn(move|| {
 timer::sleep( Duration::seconds(1));
 print_point(&*p_ref);
 });
 println!("Created {} and ...
 } p_ref = arc || {
 timer::sleep(Duration::seconds(1));
 print_point(&*p_ref);
 } point{x: 1, y:2} refs = 1
128. fn make_point_and_print_later() {
 let p = Arc::new( Point{x: 1, y: 2});
 let p_ref = p.clone();
 Thread::spawn(move|| {
 timer::sleep( Duration::seconds(1));
 print_point(&*p_ref);
 });
 println!("Created {} and ...
 } || {
 timer::sleep(Duration::seconds(1));
 print_point(&*p_ref);
 } point{x: 1, y:2} refs = 0
129. • Rust no te da: • Runtime (Garbage Collector, green threads) • Integración de features en el lenguaje • Rust te da: • Ownership. • Sistema de tipos moderno y potente.
130. ¡Gracias! @tcardv