
Learn Rust the Dangerous Way - generichuman
http://cliffle.com/p/dangerust/
======
derefr
I’ve had an idea for a while now, of writing a tutorial that works similar to
this one, but backwards. I have no time to write the tutorial, but here’s the
idea:

Behind the scenes, write a short C program, and compile it into LLVM IR
through Clang. Present the code first as its LLVM IR representation, then work
through how you’d manually _decompile_ it back into C, hopefully giving a
result that will compile back to the same LLVM IR.

(You’d be teaching some of the fundamentals of compiler theory here, in
“reverse order”, but IMHO that’s exactly what you need if you’re to understand
where C and Rust really diverge.)

Then, walk through the decompilation process again, except this time with Rust
semantics, to end up with _unsafe_ Rust that compiles to identical LLVM IR as
the C code does.

And then, finally, treating the unsafe Rust as the new IR, walk through how
you’d decompile that unsafe Rust into safe Rust, introducing each static-
analysis compiler pass that Rust does in reverse, adding one feature at a
time, until the code is all safe Rust, but can be theoretically partial-
compiled into the earlier unsafe-Rust code†, and from there into the same LLVM
IR as the other two examples.

The idea here is that this tutorial would be a way of “reading history
backwards” (ala [https://slatestarcodex.com/2013/04/11/read-history-of-
philos...](https://slatestarcodex.com/2013/04/11/read-history-of-philosophy-
backwards/)). I.e., rather than coming into a world with a fully-formed Rust
and a fully-formed C, you’d start with a world that only has ASM; and then
introduce C into it; and then introduce Rust into it, seeing how each
introduction changes what you can do.

† It’d be helpful if rustc had a mode where it could emit some sort of “core
Rust” IR, that was all unsafe{} and had only the barest types, in the vein of
early C++ compilers that emit C, or how the Erlang compiler works. Sadly, I
don’t think rustc is architected in a way that’d allow this. (Though, paging
steveklabnik to correct me.)

~~~
roblabla
> It’d be helpful if rustc had a mode where it could emit some sort of “core
> Rust” IR, that was all unsafe{} and had only the barest types, in the vein
> of early C++ compilers that emit C, or how the Erlang compiler works. Sadly,
> I don’t think rustc is architected in a way that’d allow this. (Though,
> paging steveklabnik to correct me.)

MIR seems to be the closest thing to a "Core Rust". You still have access to
all the types, but everything is desugared down to the barest possible syntax.
While and for loops are desuggared to loop+break, complex field accesses are
split into temporary to ease borrow analysis, etc...

I'm not sure what happens to unsafe block, but I suspect those gets stripped
as well, and MIR is assumed to be valid. There's a tool called miri that can
be used to find UB by running the MIR - if you manage to trigger UB, miri will
error out telling you what went wrong.

Might be worth looking into it :D

------
ArmandGrillet
The notes of the tutorial are well included and answer all the questions I ask
myself while reading, it's making the tutorial much more enjoyable than the
ones I usually read. A great read if you're interested in Rust but haven't
played with it yet IMO.

------
pgt
Wayback Machine link from 23 Dec 2019:
[http://web.archive.org/web/20191223074202/http://cliffle.com...](http://web.archive.org/web/20191223074202/http://cliffle.com/p/dangerust/)

~~~
iudqnolq
Does anyone have copies of the next articles in the series? Wayback doesn't.

~~~
masklinn
Do you mean the hypothetical part 6? It doesn't exist. Part 5 was published on
December 14th but the author hasn't released anything since (I wouldn't be
surprised if they were busy given it's the end-of-year).

~~~
iudqnolq
No, I mean parts 2-5

~~~
masklinn
All of them work for me right now.

~~~
iudqnolq
On Wayback or directly? It times out for me directly and isn't indexed by
Wayback afaict

~~~
masklinn
Direct. Tried again, works fine. It probably got a bit under the weather when
it finally reached the front page, especially given it's also at the top of
/r/programming right now.

------
sedatk
This is probably the best Rust tutorial that I’ve ever seen. Feels curated for
me.

------
Rerarom
HN death grip

~~~
brobinson
Death Grips is Online

------
whoevercares
Nowadays it seems quite rare to find someone using C for low level without
solid CS background. In fact I bet a good percent of CS major undergraduate or
even graduate can’t write good C code.

~~~
jeffdavis
I'm confused about how the two sentences are related. Can you elaborate?

~~~
whoevercares
It might make more sense during the ages when programming is still considered
a speciality, then CS as a major has some virtue and it’s largely a pre-req.
Of course nowadays the bar is low enough

