Add section on uninitialized memory

Author: Manishearth

src/advanced_unsafety/undef_memory.md

@@ -1 +1,39 @@
-# Undef memory
+# Uninitialized memory
+
+> _"I'm Nobody! Who are you? Are you — Nobody — too?"_
+> — _Emily Dickinson_
+
+While we have covered [invalid values], there's another thing that behaves a lot like invalid values, but has nothing to do with actual bit patterns: Uninitialized memory.
+
+An easy way to think about uninitialized memory is that there's an additional value (often called `undef` using LLVM's term for it) that does not map to any concrete bit pattern, but can be introduced in abstract in various ways, and makes _most_ values invalid.
+
+If you explicitly wish to work with uninitialized and partially-initialized types, [`MaybeUninit<T>`] is a useful abstraction since it can be "initialized" with no overhead and then written to in parts.
+
+## Sources of uninitialized memory
+
+### `mem::uninitialized()`
+
+[`mem::uninitialized()`] is a deprecated API that has a very tempting shape, it lets you do things like `let x = mem::uninitialized()` for cases when you want to construct the value in bits. It's basically _always_ UB to use, since it immediately sets `x` to uninitialized memory, which is UB.
+
+Use [`MaybeUninit<T>`] instead.
+
+### Padding
+
+@@@ Beef up this section
+
+Padding bytes in structs and enums are often but not always uninitialized. This means that treating a struct as a bag of bytes (by, say, treating `&Struct` as `&[u8; size_of::<Struct>()]` and reading from there) is UB even if you don't write invalid values to those bytes, since you are ginning up uninitialized `u8`s.
+
+
+### Moved-from values
+
+### Freshly allocated memory
+
+
+## When you might end up making an uninitialized value
+
+## Things you might see if you made an uninitialized value
+
+
+ [invalid values]: ./invalid_values.md
+ [`mem::uninitialized()`]: https://doc.rust-lang.org/stable/std/mem/fn.uninitialized.html
+ [`MaybeUninit<T>`]: https://doc.rust-lang.org/stable/std/mem/union.MaybeUninit.html