Apidays Paris 2023 - Forget TypeScript, Choose Rust to build Robust, Fast and Cheap APIs, Zacaria Chtatar, HaveSomeCode

Apidays Paris 2023 - Software and APIs for Smart, Sustainable and Sovereign Societies
December 6, 7 & 8, 2023

Forget TypeScript, Choose Rust to build Robust, Fast and Cheap APIs
Zacaria Chtatar, Backend Software Engineer at HaveSomeCode

------

Check out our conferences at https://www.apidays.global/

Do you want to sponsor or talk at one of our conferences?
https://apidays.typeform.com/to/ILJeAaV8

Learn more on APIscene, the global media made by the community for the community:
https://www.apiscene.io

Explore the API ecosystem with the API Landscape:
https://apilandscape.apiscene.io/

Transcript

1. API Days Paris Zacaria Chtatar - December 2023 https://havesome-rust-apidays.surge.sh
3. Forget TypeScript
4. Forget TypeScript Choose Rust
5. Forget TypeScript Choose Rust to build
6. Forget TypeScript Choose Rust to build Robust, Fast and Cheap APIs
7. Some context
8. 2009 JS lives in the browser
9. Until Nodejs V8 engine, modules system & NPM modules boom of easy to reuse code fullstack JS : Easy to start with, hard to master
10. Fullstack paradigm clash between static and dynamic JS doesn't help you follow strict API interfaces
11. Fullstack paradigm clash between static and dynamic JS doesn't help you follow strict API interfaces
12. TypeScript Benefits: IDE Developer experience OOP patterns compiler checks type system => better management of big codebase
13. Pain points does not save you from dealing with JS adds types management adds static layer onto dynamic layer
14. Pain points does not save you from dealing with JS adds types management adds static layer onto dynamic layer JSDoc answers to the precise problem of hinting types without getting in your way
15. New stakes, new needs
16. Stakes Needs worldwide scale privacy market competition environment human lives scalability security functionality computation time memory footprint safety
17. Stakes Needs worldwide scale privacy market competition environment human lives scalability security functionality computation time memory footprint safety TypeScript is not enough
18. Introducing Rust Fast, Reliable, Productive: pick three
19. Stable
21. enums struct FakeCat { alive: bool, hungry: bool, } let zombie = FakeCat { alive: false, hungry: true }; // ???
22. enums struct FakeCat { alive: bool, hungry: bool, } let zombie = FakeCat { alive: false, hungry: true }; // ??? Rust makes it easy to make invalid state unrepresentable
23. enums struct FakeCat { alive: bool, hungry: bool, } let zombie = FakeCat { alive: false, hungry: true }; // ??? Rust makes it easy to make invalid state unrepresentable enum RealCat { Alive { hungry: bool }, // enums can contain structs Dead, } let cat = RealCat::Alive { hungry: true }; let dead_cat = RealCat::Dead;
24. Option enum // full code of the solution to the billion dollar mistake // included in the standard library enum Option<T> { None, Some(T), } let item: Option<Item> = get_item(); match item { Some(item) => map_item(item), None => handle_none_case(), // does not compile if omitted }
25. What is wrong with this function ? function getConfig(path: string): string { return fs.readFileSync(path); }
26. What is wrong with this function ? function getConfig(path: string): string { return fs.readFileSync(path); } There is no hint that readFileSync can throw an error under some conditions
27. Result enum enum Result<T, E> { Ok(T), Err(E), } fn get_config(path: &str) -> Result<String, io::Error> { fs::read_to_string(path) } // That's a shortcut, don't send me to prod ! fn dirty_get_config(path: &str) -> String { fs::read_to_string(path).unwrap() // panics in case of error }
28. Result enum enum Result<T, E> { Ok(T), Err(E), } fn get_config(path: &str) -> Result<String, io::Error> { fs::read_to_string(path) } // That's a shortcut, don't send me to prod ! fn dirty_get_config(path: &str) -> String { fs::read_to_string(path).unwrap() // panics in case of error } We need to clarify what can go wrong
29. Result enum enum Result<T, E> { Ok(T), Err(E), } fn get_config(path: &str) -> Result<String, io::Error> { fs::read_to_string(path) } // That's a shortcut, don't send me to prod ! fn dirty_get_config(path: &str) -> String { fs::read_to_string(path).unwrap() // panics in case of error } We need to clarify what can go wrong It's even better when it's embedded in the language
30. 2016 : Do you remember the ? le -pad incident Source
31. crates.io no crate (package) unpublish can disable crate only for new projects
32. Linux: The Kernel
33. Linux: The Kernel attract young devs
34. Linux: The Kernel attract young devs 2/3 of vunerabilities come from memory management
35. Linux: The Kernel attract young devs 2/3 of vunerabilities come from memory management Kernel is in C and Assembly
36. Linux: The Kernel attract young devs 2/3 of vunerabilities come from memory management Kernel is in C and Assembly Linus Torvalds : C++
37. Fast
38. 2017 : Energy efficiency accross programing languages
39. Github: 45 million repos 28 TB of unique content Code Search index
40. Github: 45 million repos 28 TB of unique content Code Search index several months with Elasticsearch 36h with Rust and Kafka 640 queries /s
41. Cloudflare: HTTP proxy
42. Cloudflare: HTTP proxy nginx not fast enough
43. Cloudflare: HTTP proxy nginx not fast enough hard to customize in C
44. Cloudflare: HTTP proxy nginx not fast enough hard to customize in C allows to share connections between threads
45. Cloudflare: HTTP proxy nginx not fast enough hard to customize in C allows to share connections between threads = 160x less connections to the origins
46. Cloudflare: HTTP proxy nginx not fast enough hard to customize in C allows to share connections between threads = 160x less connections to the origins = 434 years less handshakes per day
47. Discord: Message read service
48. Discord: Message read service cache of a few billion entries
49. Discord: Message read service cache of a few billion entries every connection, message sent and read...
50. Discord: Message read service cache of a few billion entries every connection, message sent and read... latences every 2 minutes because of Go Garbage Collector
51. Discord: Message read service cache of a few billion entries every connection, message sent and read... latences every 2 minutes because of Go Garbage Collector
52. Cheap
53. cpu & memory less bugs learning curve less cases to test
54. Attractive
55. Attractive Most admired language according to for 8 years ! StackOverflow
56. Attractive Most admired language according to for 8 years ! StackOverflow Only place where there is more devs available than offers
57. Growing community
58. Features static types compiled no GC compiler developed in Rust low and high level : zero cost abstraction no manual memory management : Ownership & Borrow checker
59. Features static types compiled no GC compiler developed in Rust low and high level : zero cost abstraction no manual memory management : Ownership & Borrow checker => There is no blackbox between you and the machine
60. Features static types compiled no GC compiler developed in Rust low and high level : zero cost abstraction no manual memory management : Ownership & Borrow checker => There is no blackbox between you and the machine => Better predictability
61. Features static types compiled no GC compiler developed in Rust low and high level : zero cost abstraction no manual memory management : Ownership & Borrow checker => There is no blackbox between you and the machine => Better predictability => Awesome developer experience
62. Ownership rules
63. Ownership rules Only one variable owns data at a time
64. Ownership rules Only one variable owns data at a time Multiple readers or one writer
65. Ownership rules Only one variable owns data at a time Multiple readers or one writer => Memory is freed as soon as variable is out of scope
66. Ownership rules Only one variable owns data at a time Multiple readers or one writer => Memory is freed as soon as variable is out of scope It's like a fundamental problem has been solved
67. The compiler fn say(message: String) { println!("{}", message); } fn main() { let message = String::from("hey"); say(message); say(message); }
68. Tools cargo test : Integration Tests, Unit Ttests cargo fmt cargo bench clippy : lint bacon : reload rust-analyzer : IDE developer experience
69. Cargo doc stays up to date cargo doc --open /// Formats the sum of two numbers as a string. /// /// # Examples /// /// ``` /// let result = mycrate::sum_as_string(5, 10); /// assert_eq!(result, "15"); /// ``` pub fn sum_as_string(a: i32, b: i32) -> String { (a + b).to_string() } 1 2 3 4 5 6 7 8 9
70. Cargo doc stays up to date cargo doc --open /// Formats the sum of two numbers as a string. /// /// # Examples /// /// ``` /// let result = mycrate::sum_as_string(5, 10); /// assert_eq!(result, "15"); /// ``` pub fn sum_as_string(a: i32, b: i32) -> String { (a + b).to_string() } 1 2 3 4 5 6 7 8 9 /// let result = mycrate::sum_as_string(5, 10); /// assert_eq!(result, "15"); /// Formats the sum of two numbers as a string. 1 /// 2 /// # Examples 3 /// 4 /// ``` 5 6 7 /// ``` 8 pub fn sum_as_string(a: i32, b: i32) -> String { (a + b).to_string() } 9
71. Cargo doc stays up to date cargo doc --open /// Formats the sum of two numbers as a string. /// /// # Examples /// /// ``` /// let result = mycrate::sum_as_string(5, 10); /// assert_eq!(result, "15"); /// ``` pub fn sum_as_string(a: i32, b: i32) -> String { (a + b).to_string() } 1 2 3 4 5 6 7 8 9 /// let result = mycrate::sum_as_string(5, 10); /// assert_eq!(result, "15"); /// Formats the sum of two numbers as a string. 1 /// 2 /// # Examples 3 /// 4 /// ``` 5 6 7 /// ``` 8 pub fn sum_as_string(a: i32, b: i32) -> String { (a + b).to_string() } 9 /// Formats the sum of two numbers as a string. /// /// # Examples /// /// ``` /// let result = mycrate::sum_as_string(5, 10); /// assert_eq!(result, "15"); /// ``` pub fn sum_as_string(a: i32, b: i32) -> String { (a + b).to_string() } 1 2 3 4 5 6 7 8 9
73. Possible struggles projects move slower embrace the paradigm takes 3 to 6 months to become productive build time work with external libraries ecosystem calmer than JS
74. Project lifetime
75. In other languages simple things are easy and complex things are possible, in Rust simple things are possible and complex things are EASY.
76. Get started as dev - reference - condensed reference - exercises - quick walkthrough - complete walkthrough - quick videos - longer videos - Youtube & paid bootcamp - not sponsored - keywords discovery - keywords discovery Rust book Rust by example Rustlings A half-hour to learn Rust Comprehensive Rust by Google Noboilerplate Code to the moon Let's get rusty Awesome Rust Roadmap
77. Get started as manager
78. Get started as manager find dev interested in Rust: there are a lot
79. Get started as manager find dev interested in Rust: there are a lot start with simple projects: CLI lambdas microservice network app devops tools
80. Get started as manager find dev interested in Rust: there are a lot start with simple projects: CLI lambdas microservice network app devops tools Make the world a safer, faster and sustainable place
81. Thank you Slides : - https://havesome-rust-apidays.surge.sh @ChtatarZacaria havesomecode.io
82. Q&A
83. Governance Release every 6 weeks Backward compatibility Breaking changes are opt-in thanks to Rust Project Rust Foundation editions