Rohit Sachdeva
@rohit-sachdeva.bsky.social
#Rust Senior Engineer: #rustlang / #AsyncRust / #SystemDesign / #Backend Development / Cryptography / Machine Learning
https://github.com/rsachdeva/drive-deposits
https://github.com/rsachdeva/simple-chat
https://github.com/rsachdeva
https://github.com/rsachdeva/drive-deposits
https://github.com/rsachdeva/simple-chat
https://github.com/rsachdeva
Reposted by Rohit Sachdeva
Hello World! Announcing the inaugural TokioConf. April 20-22, 2026, in Portland, OR. tokio.rs/blog/2025-06...
Announcing TokioConf 2026 | Tokio - An asynchronous Rust runtime
Tokio is a runtime for writing reliable asynchronous applications with Rust. It provides async I/O, networking, scheduling, timers, and more.
tokio.rs
June 19, 2025 at 6:31 PM
Hello World! Announcing the inaugural TokioConf. April 20-22, 2026, in Portland, OR. tokio.rs/blog/2025-06...
Carl Lerche Presentation for #Rust #Rustlang Backend Developers -- Rust: A Productive Language for Writing Database Applications: www.infoq.com/presentation...
Rust: A Productive Language for Writing Database Applications
Carl Lerche discusses Rust's potential as a productive language for building higher-level applications like web apps and backends, traditionally seen as performance-sensitive domains. He explains how ...
www.infoq.com
June 13, 2025 at 5:19 AM
Carl Lerche Presentation for #Rust #Rustlang Backend Developers -- Rust: A Productive Language for Writing Database Applications: www.infoq.com/presentation...
Reposted by Rohit Sachdeva
I suppose I should link directly to this to get a proper preview: youtu.be/thdpaw_3VTw?...
February 20, 2025 at 10:53 AM
I suppose I should link directly to this to get a proper preview: youtu.be/thdpaw_3VTw?...
Track #Rust releases from:
releases.rs
release-monitoring.org/project/7635/
github.com/rust-lang/ru...
#Rustlang
releases.rs
release-monitoring.org/project/7635/
github.com/rust-lang/ru...
#Rustlang
January 26, 2025 at 7:26 PM
Track #Rust releases from:
releases.rs
release-monitoring.org/project/7635/
github.com/rust-lang/ru...
#Rustlang
releases.rs
release-monitoring.org/project/7635/
github.com/rust-lang/ru...
#Rustlang
An async function, when called, returns a Future because the Future is return type. This is just returning its return type like any regular function. The only change is Future wraps the declared return type in async function, to make the full return when the async function is called. #asyncrust
January 24, 2025 at 3:30 AM
An async function, when called, returns a Future because the Future is return type. This is just returning its return type like any regular function. The only change is Future wraps the declared return type in async function, to make the full return when the async function is called. #asyncrust
match some_string.as_str() {
"hello" => println!("Found hello"),
_ => println!("Something else")
}
Pattern Match:
doc.rust-lang.org/reference/pa... shows String literals which are of &str type, not String. You can directly use "hello" but not "hello".to_string().
#rust #rustlang
"hello" => println!("Found hello"),
_ => println!("Something else")
}
Pattern Match:
doc.rust-lang.org/reference/pa... shows String literals which are of &str type, not String. You can directly use "hello" but not "hello".to_string().
#rust #rustlang
Patterns - The Rust Reference
doc.rust-lang.org
January 10, 2025 at 10:21 PM
match some_string.as_str() {
"hello" => println!("Found hello"),
_ => println!("Something else")
}
Pattern Match:
doc.rust-lang.org/reference/pa... shows String literals which are of &str type, not String. You can directly use "hello" but not "hello".to_string().
#rust #rustlang
"hello" => println!("Found hello"),
_ => println!("Something else")
}
Pattern Match:
doc.rust-lang.org/reference/pa... shows String literals which are of &str type, not String. You can directly use "hello" but not "hello".to_string().
#rust #rustlang
get() method: Vec vs String
// Vec get signature has:
where I: SliceIndex<[T]>
// String get signature has:
where I: SliceIndex
SliceIndex implementations:
Vec ([T]): Both single index (usize) and ranges
String (str): Only ranges even for one character[s.get(0..1)] due to UTF-8
#Rust
#Rustlang
// Vec get signature has:
where I: SliceIndex<[T]>
// String get signature has:
where I: SliceIndex
SliceIndex implementations:
Vec ([T]): Both single index (usize) and ranges
String (str): Only ranges even for one character[s.get(0..1)] due to UTF-8
#Rust
#Rustlang
January 3, 2025 at 5:20 PM
// Instead of match result {
// Ok(val) => val,
// Err(_) => compute_default()
// }
let value = result.unwrap_or_else(|_| compute_default());
// Instead of match result {
// Ok(val) => val,
// Err(_) => Default::default()
// }
let value = result.unwrap_or_default();
#Rust #Rustlang
// Ok(val) => val,
// Err(_) => compute_default()
// }
let value = result.unwrap_or_else(|_| compute_default());
// Instead of match result {
// Ok(val) => val,
// Err(_) => Default::default()
// }
let value = result.unwrap_or_default();
#Rust #Rustlang
December 26, 2024 at 10:38 PM
The common point between Rust's standard library (std) and Tokio is the Future trait (doc.rust-lang.org/std/future/t...) .
#rust #rustlang #asyncrust #tokio_rs
#rust #rustlang #asyncrust #tokio_rs
December 12, 2024 at 3:29 AM
The common point between Rust's standard library (std) and Tokio is the Future trait (doc.rust-lang.org/std/future/t...) .
#rust #rustlang #asyncrust #tokio_rs
#rust #rustlang #asyncrust #tokio_rs
An async block directly creates a Future
An async function, when called, returns a Future.
Note `when called` in async function...
#Rust #Async #Rustlang #AsyncRust
An async function, when called, returns a Future.
Note `when called` in async function...
#Rust #Async #Rustlang #AsyncRust
December 8, 2024 at 5:40 PM
An async block directly creates a Future
An async function, when called, returns a Future.
Note `when called` in async function...
#Rust #Async #Rustlang #AsyncRust
An async function, when called, returns a Future.
Note `when called` in async function...
#Rust #Async #Rustlang #AsyncRust
HashMap #rustlang
fn and_modify(self, f: F) -> Self where F: FnOnce(&mut V)
1. Closure's return type F: FnOnce(&mut V) returns ()
2. Function and_modify's return type -> Self
Two returns serve different purposes- closure return is for modification, function's return enables fluent API chaining
fn and_modify
1. Closure's return type F: FnOnce(&mut V) returns ()
2. Function and_modify's return type -> Self
Two returns serve different purposes- closure return is for modification, function's return enables fluent API chaining
December 7, 2024 at 12:16 AM
HashMap #rustlang
fn and_modify(self, f: F) -> Self where F: FnOnce(&mut V)
1. Closure's return type F: FnOnce(&mut V) returns ()
2. Function and_modify's return type -> Self
Two returns serve different purposes- closure return is for modification, function's return enables fluent API chaining
fn and_modify
1. Closure's return type F: FnOnce(&mut V) returns ()
2. Function and_modify's return type -> Self
Two returns serve different purposes- closure return is for modification, function's return enables fluent API chaining
fn execute(writer_half: OwnedWriteHalf) {
let mut writer = writer_half;
// And Reads very naturally in the code that follows
}
// 〰️
// Same as
fn execute(mut writer_half: OwnedWriteHalf) {
}
In both you get Direct link to parameter name passed
Choose by Readability. #Rust #Rustlang
let mut writer = writer_half;
// And Reads very naturally in the code that follows
}
// 〰️
// Same as
fn execute(mut writer_half: OwnedWriteHalf) {
}
In both you get Direct link to parameter name passed
Choose by Readability. #Rust #Rustlang
December 6, 2024 at 6:11 PM
The word `await` perfectly captures async essence: actively anticipating results while staying productive!
await = waiting in anticipation
wait = passive waiting
That's why #AsyncRust (and some other languages) chose await - it's all about productive anticipation! #RustLang
await = waiting in anticipation
wait = passive waiting
That's why #AsyncRust (and some other languages) chose await - it's all about productive anticipation! #RustLang
December 6, 2024 at 5:24 PM
The word `await` perfectly captures async essence: actively anticipating results while staying productive!
await = waiting in anticipation
wait = passive waiting
That's why #AsyncRust (and some other languages) chose await - it's all about productive anticipation! #RustLang
await = waiting in anticipation
wait = passive waiting
That's why #AsyncRust (and some other languages) chose await - it's all about productive anticipation! #RustLang
In select!:Multiple branches compete/race like diverging paths;Only one branch "wins" and gets executed
In join!: Different branches merge back together; Like tributaries joining into a main river; All branches must complete to form the whole
#AsyncRust #Rustlang #tokio_rs
In join!: Different branches merge back together; Like tributaries joining into a main river; All branches must complete to form the whole
#AsyncRust #Rustlang #tokio_rs
December 5, 2024 at 5:20 PM
In select!:Multiple branches compete/race like diverging paths;Only one branch "wins" and gets executed
In join!: Different branches merge back together; Like tributaries joining into a main river; All branches must complete to form the whole
#AsyncRust #Rustlang #tokio_rs
In join!: Different branches merge back together; Like tributaries joining into a main river; All branches must complete to form the whole
#AsyncRust #Rustlang #tokio_rs