
Write a mini-Redis in Rust: learn async programming with Tokio - VitalyAnkh
https://tokio.rs/tokio/tutorial
======
sanxiyn
This is a fine tutorial, but I must note that Rust async programming is a bad
way to learn about Rust, and also is a bad way to learn about async
programming. You should learn the basics of both Ruts and async programming
elsewhere, and then try Rust async programming.

If you disagree, take a look at compile error in
[https://tokio.rs/tokio/tutorial/streams](https://tokio.rs/tokio/tutorial/streams)
and think again. That is in fact NOT atypical. (Amusing paradox: you get less
errors once you learned, but you get the most terrible errors when you are the
least equipped to deal with them.)

To slightly exaggerate, I spend about half my time in Rust support chat
channel in my locality to discourage people from trying Rust async programming
without getting the basics of Rust. Their logic go: I am interested in Rust
only for async network programming, I am not interested in Rust sync network
programming, I also learn best by try using something in a project straight
away, so I will just learn Rust by writing a Rust async programming project!
This literally 100% fails, but people who do this really really want to do it
that way, and discouragement doesn't really work, and they get really
frustrated, and... I am not sure how to solve this.

~~~
dpc_pw
Yeah. `async` involves a lot of sophisticated and bleeding edge machinery, and
is not really "fully ready" for wide-consumption, IMO.

What's funny is that while `async` is great tool to have 99% of programs will
not see a difference.

~~~
sanxiyn
I think wide consumption is getting there, but I don't think it will be ever
ready for consumption by learners. There is just a lot under the hood.

(It pains me to write that because otherwise I am very much against Joel's law
of leaky abstractions, I believe in aiming for leak-proof abstractions, and I
know they are possible. It's just that it probably is not always possible, and
it is especially hard to abstract learnability, and it is a lot of work even
when it is possible.)

While I also think most people do not need async and will not see differences,
I focus on learning aspect and refrain from saying "you probably don't need
it", because I found people are not stupid and people who insist on async
usually have actual need for async. This may be due to what kind of people
congregate on my local community and may not hold elsewhere though.

------
Fiahil
Hold on, there is way more documentation than before ! Things like “when to
use std::sync::mutex vs tokio::sync::mutex” were not there 1 version ago !
additionally, framing and streams will be of great help for my current
project!

------
kanobo
Redis is one of those things that deceptively looks like it would be easy to
build in the eyes of a beginner engineer but in reality is a great technical
achievement.

~~~
kjeetgill
Don't just tease the subject, share some highlights!

------
rcarmo
This is pretty neat. I’ve always thought Redis was a good way (and arguably a
better one) to get to grips with network code in a new language/runtime.

I did it for asyncio, Go, Clojure and a few other things.

