This document provides an overview of the Go and Rust programming languages. It discusses Go's history from 1973 to present day and compares features of Go and Rust such as performance, concurrency, and memory management. Rust is highlighted as a potential replacement for C due to its prevention of common security vulnerabilities like buffer overflows through its borrowing system and garbage collection. The document advocates adding Rust to one's toolbox of programming languages.

1. GO IS GETTING
RUSTY

3. me {
Name: "Alon Nativ",
Status: "Married + 2",
Company: "ClimaCell",
Position: "System Architect",
StartProgramingAge: 5,
}

6. HISTORY
1973 1983 1991 1995 1996

7. 2009 2010

8. GO VS RUST

9. VS
CC Renée French

11. FERRIS

12. RUST IS FASTER

13. GO HAS GC

14. CONCURRENCY

15. PROGRAMING LANGUAGES
ARE LIKE RELIGIONS ON
SCALE

16. REAL WORLD EXAMPLES

17. K8s ‫ק9ס‬

23. Istio

24. SERVICE MASH
Network of microservices
that make up such
applications and the
interactions between them.

25. Control Plane
C++
Data Plane

28. API BREAKS

29. PERFORMANCE

31. C

33. ● Use after free
● Double free
● Memory leaks
● Buffer overreads/overwrites
● Null pointers
● Data races

35. “Around 70 percent of all the
vulnerabilities in Microsoft
products addressed through a
security update each year are
memory safety issues”
Matt Mileer, MS security engineer ZDNet, 11.02.2019

36. NO GC NO CODE!

39. fn main() {
let x = String::from("Go!");
println!("{}", x);
}

40. fn main() {
let x = String::from("Go!");
println!("{}", x);
}

41. fn main() {
let x = String::from("Go!");
println!("{}", x);
}

42. fn main() {
let x = String::from("Go!");
println!("{}", x);
}

43. fn main() {
let x = String::from("Go!");
println!("{}", x);
} Memory get’s FREE!

44. fn main() {
let x = String::from("Go!");
let y = x;
println!("{}", x);
println!("{}", y);
}

45. fn main() {
let x = String::from("Go!");
let y = x;
println!("{}", x);
}
error[E0382]: borrow of moved value:`x`
^ value borrowed
here after move

46. fn main() {
let x = String::from("Go!");
let y = x;
println!("{}", x);
println!("{}", y);
}
Move ownership x → y

47. fn main() {
let x = String::from("Go!");
let y = &x;
println!("{}", x);
println!("{}", y);
}
Immutable borrow

49. fn main() {
let mut v = vec![1, 2, 3];
let v2 = &v;
v.push(4);
println!("{:?}", v2);
println!("{:?}", v);
}

50. fn main() {
let mut v = vec![1, 2, 3];
let v2 = &v;
v.push(4);
println!("{:?}", v2);
println!("{:?}", v);
}
Immutable borrow

51. fn main() {
let mut v = vec![1, 2, 3];
let v2 = &v;
v.push(4);
println!("{:?}", v2);
println!("{:?}", v);
}

52. fn main() {
let mut v = vec![1, 2, 3];
let v2 = &v;
v.push(4);
println!("{:?}", v2);
println!("{:?}", v);
}

53. fn main() {
let mut v = vec![1, 2, 3];
let v2 = &v;
v.push(4);
println!("{:?}", v2);
println!("{:?}", v);
}

54. fn main() {
let mut v = vec![1, 2, 3];
let v2 = &v;
v.push(4);
println!("{:?}", v2);
println!("{:?}", v);
}
error[E0502]: cannot borrow `v` as
mutable because it is also borrowed as
immutable
| ^^^^^^^^^ mutable borrow occurs
here

56. 1 2 3
let mut v = vec![1, 2, 3];

57. 1 2 3
let v2 = &v;

58. 1 2 3
1 2 3 4
v.push(4)

59. 1 2 3
1 2 3 4
v.push(4)

60. 1 2 3 4
👿
println!("{:?}", v2);

61. CC Zero - CC0

62. fn main() {
let mut v = vec![1, 2, 3];
let v2 = &v;
v.push(4);
println!("{:?}", v2);
println!("{:?}", v);
}

63. fn main() {
let mut v = vec![1, 2, 3];
let v2 = &v;
v.push(4);
println!("{:?}", v2);
println!("{:?}", v);
}

64. fn main() {
let mut v = vec![1, 2, 3];
let v2 = &v;
println!("{:?}", v2);
v.push(4);
println!("{:?}", v);
}

65. fn main() {
let mut v = vec![1, 2, 3];
let v2 = &v;
println!("{:?}", v2);
v.push(4);
println!("{:?}", v);
}
v2 - no one use it from here

67. MUTABLE

68. MUTABLE
MUTABLEMUTABLEMUTABLEMUTABLEMUTABLEIMMUTABLE

69. MUTABLE
MUTABLE
MUTABLEMUTABLEMUTABLEMUTABLEMUTABLEIMMUTABLE

71. “Rust is the first new* language
that could replace C in every
role”
Jeremy Fitzhardinge Facebook Engineer, RustConf 2019

72. STACK OVERFLOW
SURVEY 4 YEARS
IN A ROW

77. CC Brain Black

78. GO
RUST

79. ADD RUST TO YOUR
TOOLBOX

80. Rust Book
Community
Diving Into Rust For The First Time
A Case for Oxidation: The Rust Programming Language
Rust: A Language for the Next 40 Years - Carol Nichols
#rust-beginners http://irc.mozilla.org/

81. Thank You!
@anativ
@anativ