From 65066f2ca3813f3563e1cb8626fd93de365d61ea Mon Sep 17 00:00:00 2001 From: Clar Charr Date: Mon, 2 Jan 2017 15:47:00 -0500 Subject: [PATCH] Reword 'stupid' and 'crazy' in docs. --- atomics.md | 8 ++++---- meet-safe-and-unsafe.md | 2 +- races.md | 10 +++++----- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/atomics.md b/atomics.md index 1efca08..7b4c44f 100644 --- a/atomics.md +++ b/atomics.md @@ -24,10 +24,10 @@ exactly what we said but, you know, fast. Wouldn't that be great? # Compiler Reordering -Compilers fundamentally want to be able to do all sorts of crazy transformations -to reduce data dependencies and eliminate dead code. In particular, they may -radically change the actual order of events, or make events never occur! If we -write something like +Compilers fundamentally want to be able to do all sorts of complicated +transformations to reduce data dependencies and eliminate dead code. In +particular, they may radically change the actual order of events, or make events +never occur! If we write something like ```rust,ignore x = 1; diff --git a/meet-safe-and-unsafe.md b/meet-safe-and-unsafe.md index 978d051..15d84fd 100644 --- a/meet-safe-and-unsafe.md +++ b/meet-safe-and-unsafe.md @@ -22,7 +22,7 @@ Well, Rust *has* a safe programming language. Let's step back a bit. Rust can be thought of as being composed of two programming languages: *Safe Rust* and *Unsafe Rust*. Safe Rust is For Reals Totally Safe. Unsafe Rust, unsurprisingly, is *not* For Reals Totally Safe. In fact, Unsafe Rust lets you -do some really crazy unsafe things. +do some really, *really* unsafe things. Safe Rust is the *true* Rust programming language. If all you do is write Safe Rust, you will never have to worry about type-safety or memory-safety. You will diff --git a/races.md b/races.md index f0732cf..5145987 100644 --- a/races.md +++ b/races.md @@ -21,11 +21,11 @@ prevent *all* race conditions would be pretty awful to use, if not just incorrect. So it's perfectly "fine" for a Safe Rust program to get deadlocked or do -something incredibly stupid with incorrect synchronization. Obviously such a -program isn't very good, but Rust can only hold your hand so far. Still, a -race condition can't violate memory safety in a Rust program on -its own. Only in conjunction with some other unsafe code can a race condition -actually violate memory safety. For instance: +something nonsensical with incorrect synchronization. Obviously such a program +isn't very good, but Rust can only hold your hand so far. Still, a race +condition can't violate memory safety in a Rust program on its own. Only in +conjunction with some other unsafe code can a race condition actually violate +memory safety. For instance: ```rust,no_run use std::thread;