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/

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