jake. ~ / pages / longform-computer-texts

longform-computer-texts

Feed: Pascal's Scribbles Title: Long-form Texts on Interesting Detailsof Computers Date: Wed, 15 Apr 2020 18:00:00 -0400 Link:https://deterministic.space/several-months-of-reading-material.html

It seems especially recently I’ve come across more and more long-formtexts (think: hour-long blog posts; free books; series of posts). Iespecially like the ones that go into the very fine details of someniche topic and maybe also ramble a bit about completely unrelated buthighly entertaining asides. And while I will probably never have enoughtime to read them all, I decided to at least collect some of them herefor future reference. I’ll do my best to add summaries, and to updatethis list semi-regularly.

Contents

  • “Learn Rust With Entirely Too Many Linked Lists” by AlexisBeingessner
  • “Programming Algorithms” by Vsevolod Domkin
  • “Aspects of Rust” by multiple people
  • “Reading files the hard way” by Amos Wenger
  • “Making our own ping” by Amos Wenger
  • “Making our own executable packer” by Amos Wenger
  • “Parsing” by Aleksey Kladov
  • “JavaScript Allongé” by Reg “raganwald” Braithwaite
  • “Crafting Interpreters” by Robert Nystrom
  • “A relatively simple Datalog engine in Rust” by Frank McSherry
  • “Non-lexical lifetimes” by Niko Matsakis
  • “Shifgrethor” by Without Boats
  • “Rayon/Parallel Iterators” by Niko Matsakis
  • “How Rust optimizes async/await” by Tyler Mandry
  • “Writing an OS in Rust” by Philipp Oppermann
  • “Learning Parser Combinators With Rust” by Bodil Stokke
  • “Manish vs. ASCII” by Manish Goregaokar
  • “The Wayland Protocol” by Drew DeVault

“Learn Rust With Entirely Too Many Linked Lists” by AlexisBeingessner

(\~180 pages; archived)

The premise of this book is that writing a linked list is a beginner’sexercise in C but quite difficult to get right in Rust. So it takes thatas an opportunity to do just what the title says: It teaches you Rust byimplementing a linked list type in Rust, in five (as of April 2020)different ways.

Niches: data structures; linked lists; rust; smart pointers

Last update I saw: 2019-03-21

“Programming Algorithms” by Vsevolod Domkin

(\~300 pages; archived)

Book covering a lot of different data structures and algorithms. “Itsaim is to systematically explain how to write efficient programs and,also, the approaches and tools for determining why the program isn’tefficient enough.”

Niches: data structures; algorithms; lisp

Last update I saw: 2020-04-16

“Aspects of Rust” by multiple people

Several stand-alone posts by various people whose only connection isthat they cover nice aspects of Rust.

Niches: rust

  1. A half-hour to learn Rust (archived)

    Whirlwind tour through Rust as a language by Amos Wenger.

  2. Typed Key Pattern (archived)

    By Aleksey Kladov.

  3. The Secret Life of Cows (archived)

    The Clone-on-Write smart pointer explained by yours truly.

  4. Newtype Index Pattern (archived)

    By Aleksey Kladov.

  5. How to implement a trait for &str and &\[&str\] (archived)

    Some musing on traits and borrows by yours truly.

  6. Declarative memory management (archived)

    By Amos Wenger. Introducing the complexities of memory managementand the ways Rust tries to represent them in a nice roundabout way.

  7. Return-type based dispatch (archived)

    By yours. By specifying at some later point in the code which typeyou want your function to return, the compiler can go back and fillin the blanks.

  8. Working with strings in Rust (archived)

    By Amos Wenger. Following the memory management post, this looks athow strings are actually pretty complicated and what Rust does aboutthem.

“Reading files the hard way” by Amos Wenger

Writing files seems like a solved problem. But that doesn’t mean wecan’t solve it again from scratch.

Niches: POSIX; file systems; syscalls

  1. Part 1 (node.js, C, rust, strace) (archived)
  2. Part 2 (x86 asm, linux kernel) (archived)
  3. Part 3 (ftrace, disk layouts, ext4) (archived)

“Making our own ping” by Amos Wenger

  1. A short (and mostly wrong) history of computer networking(archived)
  2. Windows dynamic libraries, calling conventions, and transmute

(archived)

  1. FFI-safe types in Rust, newtypes and MaybeUninit(archived)
  2. Designing and implementing a safer API on top of LoadLibrary

(archived)

  1. A simple ping library, parsing strings into IPv4 address(archived)
  2. The builder pattern, and a macro that keeps FFI code DRY(archived)
  3. Finding the default network interface through WMI(archived)
  4. Binding C APIs with variable-length structs and UTF-16(archived)
  5. Consuming Ethernet frames with the nom crate (archived)
  1. Improving error handling - panics vs. proper errors(archived)
  2. Parsing IPv4 packets, including numbers smaller than bytes

(archived)

  1. Parsing and serializing ICMP packets with cookie-factory.(archived)
  2. Crafting ARP packets to find a remote host’s MAC address(archived)
  3. Crafting ICMP-bearing IPv4 packets with the help of bitvec

(archived)

“Making our own executable packer” by Amos Wenger

  1. What’s in a Linux executable? (archived)
  2. Running an executable without exec (archived)
  3. Position-independent code (archived)
  4. ELF relocations (archived)
  5. The simplest shared library (archived)
  6. Loading multiple ELF objects (archived)
  7. Dynamic symbol resolution (archived)
  8. Dynamic linker speed and correctness (archived)
  9. GDB scripting and Indirect functions (archived)
  1. Safer memory-mapped structures (archived)
  2. More ELF relocations (archived)
  3. A nostd Rust binary (archived)
  4. Thread-local storage (archived)

“Parsing” by Aleksey Kladov

Not a real series of articles but a collection of posts by someone whoseGithub bio reads “Stuck writing parsers”.

Niches: parsers

  1. Modern Parser Generator (archived)
  2. Simple but Powerful Pratt Parsing (archived)
  3. From Pratt to Dijkstra (archived)

“JavaScript Allongé” by Reg “raganwald” Braithwaite

(\~530 pages; archived)

Niches: functional programming; obscure JavaScript

Last update I saw: 2019-04-26

“Crafting Interpreters” by Robert Nystrom

(\~800 pages; archived)

Last update I saw: 2020-04-05

“A relatively simple Datalog engine in Rust” by Frank McSherry

(\~20 pages; archived)

Building a datalog engine in Rust.

Niches: datalog

“Non-lexical lifetimes” by Niko Matsakis

One of the main features of the Rust language is the concept ofownership and lifetimes. This series of posts by Niko Matsakis, one ofthe designers of the Rust language, is about the theory and practicalimplementation of a revamped and more complete way of this in the Rustcompiler. It starts in early 2016 and goes all the way to after theyfeature landed (end of 2018).

  1. Introduction (archived)
  2. Non-lexical lifetimes based on liveness (archived)
  3. Adding the outlives relation (archived)
  4. Using liveness and location (archived)
  5. Nested method calls via two-phase borrowing (archived)
  6. Draft RFC and prototype available (archived)
  7. An alias-based formulation of the borrow checker(archived)
  8. MIR-based borrow check (NLL) status update (archived)
  9. MIR-based borrowck is almost here (archived)
  1. Interprocedural conflicts (archived)
  2. Polonius and region errors (archived)
  3. Polonius and the case of the hereditary harrop predicate

(archived)

“Shifgrethor” by Without Boats

A proposed API for a GC in Rust.

  1. Garbage collection as a Rust library (archived)
  2. Notes on tracing garbage collectors (archived)
  3. Rooting (archived)
  4. Tracing (archived)

“Rayon/Parallel Iterators” by Niko Matsakis

Niches: concurrency

  1. Rayon: Data parallelism in Rust (archived)
  2. Parallel Iterators Part 1: Foundations (archived)
  3. Parallel Iterators Part 2: Producers (archived)
  4. Parallel Iterators, part 3: Consumers (archived)

“How Rust optimizes async/await” by Tyler Mandry

Niches: compilers; memory layout

  1. Part I (archived)
  2. Part II: Program analysis (archived)

“Writing an OS in Rust” by Philipp Oppermann

Niches: operating systems, assembler

  1. A Freestanding Rust Binary (archived)
  2. A Minimal Rust Kernel (archived)
  3. VGA Text Mode (archived)
  4. Testing (archived)
  5. CPU Exceptions (archived)
  6. Double Faults (archived)
  7. Hardware Interrupts (archived)
  8. Introduction to Paging (archived)
  9. Paging Implementation (archived)
  1. Heap Allocation (archived)
  2. Allocator Designs (archived)
  3. Async/Await (archived)

“Learning Parser Combinators With Rust” by Bodil Stokke

(\~60 pages; archived)

Assuming you know Rust, this teaches you the fundamentals of parsercombinators in a very hands-on way.

Niches: parsers

“Manish vs. ASCII” by Manish Goregaokar

Several posts on why assuming text is ASCII is unhelpful.

Niches: unicode

  1. Let’s Stop Ascribing Meaning to Code Points (archived)

    tl;dr you should not index into a Unicode text, like, ever.

  2. Breaking Our Latin-1 Assumptions (archived)

    Examples for scripts/languages that really don’t work if you assumeyou have ASCII text.

  3. Picking Apart the Crashing iOS String (archived)

    Fun analysis of a Unicode rendering bug that crashed iOS devices.

“The Wayland Protocol\[185\]” by Drew DeVault

(\~156 pages; archived\[186\])

“Wayland is the next-generation display server for Unix-likesystems\[…\] This book will help you establish a firm understanding ofthe concepts, design, and implementation of \[it\]”.

Niches: wayland; graphics; protocols; unix

Links:

  • ``` example https://deterministic.space/feed.xml#learn-rust-with-entirely-too-many-linked-lists-by-alexis-beingessner (link) ```↩

  • ``` example https://deterministic.space/feed.xml#programming-algorithms-by-vsevolod-domkin (link) ```↩

  • ``` example https://deterministic.space/feed.xml#aspects-of-rust-by-multiple-people (link) ```↩

  • ``` example https://deterministic.space/feed.xml#reading-files-the-hard-way-by-amos-wenger (link) ```↩

  • ``` example https://deterministic.space/feed.xml#making-our-own-ping-by-amos-wenger (link) ```↩

  • ``` example https://deterministic.space/feed.xml#making-our-own-executable-packer-by-amos-wenger (link) ```↩

  • ``` example https://deterministic.space/feed.xml#parsing-by-aleksey-kladov (link) ```↩

  • ``` example https://deterministic.space/feed.xml#javascript-allong%C3%A9-by-reg-raganwald-braithwaite (link) ```↩

  • ``` example https://deterministic.space/feed.xml#crafting-interpreters-by-robert-nystrom (link) ```↩

  • ``` example https://deterministic.space/feed.xml#a-relatively-simple-datalog-engine-in-rust-by-frank-mcsherry (link) ```↩

  • ``` example https://deterministic.space/feed.xml#non-lexical-lifetimes-by-niko-matsakis (link) ```↩

  • ``` example https://deterministic.space/feed.xml#shifgrethor-by-without-boats (link) ```↩

  • ``` example https://deterministic.space/feed.xml#rayonparallel-iterators-by-niko-matsakis (link) ```↩

  • ``` example https://deterministic.space/feed.xml#how-rust-optimizes-asyncawait-by-tyler-mandry (link) ```↩

  • ``` example https://deterministic.space/feed.xml#writing-an-os-in-rust-by-philipp-oppermann (link) ```↩

  • ``` example https://deterministic.space/feed.xml#learning-parser-combinators-with-rust-by-bodil-stokke (link) ```↩

  • ``` example https://deterministic.space/feed.xml#manish-vs-ascii-by-manish-goregaokar (link) ```↩

  • ``` example https://deterministic.space/feed.xml#the-wayland-protocol-by-drew-devault (link) ```↩

  • ``` example https://rust-unofficial.github.io/too-many-lists/index.html (link) ```↩

  • ``` example https://web.archive.org/web/20200416132847/https://rust-unofficial.github.io/too-many-lists/index.html (link) ```↩

  • ``` example https://leanpub.com/progalgs/read (link) ```↩

  • ``` example https://web.archive.org/web/20200416131734/https://leanpub.com/progalgs/read (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/a-half-hour-to-learn-rust/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416203813/https://fasterthanli.me/blog/2020/a-half-hour-to-learn-rust/ (link) ```↩

  • ``` example https://matklad.github.io/2018/05/24/typed-key-pattern.html (link) ```↩

  • ``` example https://web.archive.org/web/20200426170858/https://matklad.github.io/2018/05/24/typed-key-pattern.html (link) ```↩

  • ``` example https://deterministic.space/secret-life-of-cows.html (link) ```↩

  • ``` example https://web.archive.org/web/20200426171212/https://deterministic.space/secret-life-of-cows.html (link) ```↩

  • ``` example https://matklad.github.io/2018/06/04/newtype-index-pattern.html (link) ```↩

  • ``` example https://web.archive.org/web/20200426170901/https://matklad.github.io/2018/06/04/newtype-index-pattern.html (link) ```↩

  • ``` example https://deterministic.space/return-type-based-dispatch.html (link) ```↩

  • ``` example https://web.archive.org/web/20200426171311/https://deterministic.space/return-type-based-dispatch.html (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/declarative-memory-management/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416202910/https://fasterthanli.me/blog/2019/declarative-memory-management/ (link) ```↩

  • ``` example https://deterministic.space/return-type-based-dispatch.html (link) ```↩

  • ``` example https://web.archive.org/web/20200426171311/https://deterministic.space/return-type-based-dispatch.html (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/working-with-strings-in-rust/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416203533/https://fasterthanli.me/blog/2020/working-with-strings-in-rust/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/reading-files-the-hard-way/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416203146/https://fasterthanli.me/blog/2019/reading-files-the-hard-way/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/reading-files-the-hard-way-2/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416203148/https://fasterthanli.me/blog/2019/reading-files-the-hard-way-2/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/reading-files-the-hard-way-3/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416203157/https://fasterthanli.me/blog/2019/reading-files-the-hard-way-3/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/making-our-own-ping/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416134726/https://fasterthanli.me/blog/2019/making-our-own-ping/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/making-our-own-ping-2/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416145917/https://fasterthanli.me/blog/2019/making-our-own-ping-2/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/making-our-own-ping-3/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416145936/https://fasterthanli.me/blog/2019/making-our-own-ping-3/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/making-our-own-ping-4/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416145936/https://fasterthanli.me/blog/2019/making-our-own-ping-4/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/making-our-own-ping-5/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416145942/https://fasterthanli.me/blog/2019/making-our-own-ping-5/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/making-our-own-ping-6/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416145943/https://fasterthanli.me/blog/2019/making-our-own-ping-6/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/making-our-own-ping-7/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416145943/https://fasterthanli.me/blog/2019/making-our-own-ping-7/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/making-our-own-ping-8/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416150009/https://fasterthanli.me/blog/2019/making-our-own-ping-8/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/making-our-own-ping-9/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416150006/https://fasterthanli.me/blog/2019/making-our-own-ping-9/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/making-our-own-ping-10/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416150009/https://fasterthanli.me/blog/2019/making-our-own-ping-10/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/making-our-own-ping-11/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416150021/https://fasterthanli.me/blog/2019/making-our-own-ping-11/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/making-our-own-ping-12/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416150207/https://fasterthanli.me/blog/2019/making-our-own-ping-12/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/making-our-own-ping-13/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416150054/https://fasterthanli.me/blog/2019/making-our-own-ping-13/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2019/making-our-own-ping-14/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416150207/https://fasterthanli.me/blog/2019/making-our-own-ping-14/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/whats-in-a-linux-executable/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416203931/https://fasterthanli.me/blog/2020/whats-in-a-linux-executable/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/running-an-executable-without-exec/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416203942/https://fasterthanli.me/blog/2020/running-an-executable-without-exec/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/position-independent-code/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416203931/https://fasterthanli.me/blog/2020/position-independent-code/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/elf-relocations/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416203942/https://fasterthanli.me/blog/2020/elf-relocations/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/the-simplest-shared-library/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416203942/https://fasterthanli.me/blog/2020/the-simplest-shared-library/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/loading-multiple-elf-objects/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416203946/https://fasterthanli.me/blog/2020/loading-multiple-elf-objects/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/dynamic-symbol-resolution/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416203951/https://fasterthanli.me/blog/2020/dynamic-symbol-resolution/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/dynamic-linker-speed-and-correctness/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416203951/https://fasterthanli.me/blog/2020/dynamic-linker-speed-and-correctness/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/gdb-scripting-and-indirect-functions/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416203954/https://fasterthanli.me/blog/2020/gdb-scripting-and-indirect-functions/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/safer-memory-mapped-structures/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416204004/https://fasterthanli.me/blog/2020/safer-memory-mapped-structures/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/more-elf-relocations/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416204015/https://fasterthanli.me/blog/2020/more-elf-relocations/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/a-no-std-rust-binary/ (link) ```↩

  • ``` example https://web.archive.org/web/20200426170253/https://fasterthanli.me/blog/2020/a-no-std-rust-binary/ (link) ```↩

  • ``` example https://fasterthanli.me/blog/2020/thread-local-storage/ (link) ```↩

  • ``` example https://web.archive.org/web/20200504104021/https://fasterthanli.me/blog/2020/thread-local-storage/ (link) ```↩

  • ``` example https://matklad.github.io/2018/06/06/modern-parser-generator.html (link) ```↩

  • ``` example https://web.archive.org/web/20200426170539/https://matklad.github.io/2018/06/06/modern-parser-generator.html (link) ```↩

  • ``` example https://matklad.github.io/2020/04/13/simple-but-powerful-pratt-parsing.html (link) ```↩

  • ``` example https://web.archive.org/web/20200416155208/https://matklad.github.io/2020/04/13/simple-but-powerful-pratt-parsing.html (link) ```↩

  • ``` example https://matklad.github.io/2020/04/15/from-pratt-to-dijkstra.html (link) ```↩

  • ``` example https://web.archive.org/web/20200416155220/https://matklad.github.io/2020/04/15/from-pratt-to-dijkstra.html (link) ```↩

  • ``` example https://leanpub.com/javascriptallongesix/read (link) ```↩

  • ``` example https://web.archive.org/web/20200416145246/https://leanpub.com/javascriptallongesix/read (link) ```↩

  • ``` example http://craftinginterpreters.com/contents.html (link) ```↩

  • ``` example https://web.archive.org/web/20200411062649/http://craftinginterpreters.com/contents.html (link) ```↩

  • ``` example https://github.com/frankmcsherry/blog/blob/81e9555bbee110954f2c3d35caf86ea7e7612fa6/posts/2018-05-19.md (link) ```↩

  • ``` example https://web.archive.org/web/20200423163205/https://github.com/frankmcsherry/blog/blob/81e9555bbee110954f2c3d35caf86ea7e7612fa6/posts/2018-05-19.md (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2016/04/27/non-lexical-lifetimes-introduction/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416170054/https://smallcultfollowing.com/babysteps/blog/2016/04/27/non-lexical-lifetimes-introduction/ (link) ```↩

  • ``` example http://smallcultfollowing.com/babysteps/blog/2016/05/04/non-lexical-lifetimes-based-on-liveness/ (link) ```↩

  • ``` example https://web.archive.org/web/20190917065228/http://smallcultfollowing.com/babysteps/blog/2016/05/04/non-lexical-lifetimes-based-on-liveness/ (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2016/05/09/non-lexical-lifetimes-adding-the-outlives-relation/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416170116/https://smallcultfollowing.com/babysteps/blog/2016/05/09/non-lexical-lifetimes-adding-the-outlives-relation/ (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2017/02/21/non-lexical-lifetimes-using-liveness-and-location/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416170119/https://smallcultfollowing.com/babysteps/blog/2017/02/21/non-lexical-lifetimes-using-liveness-and-location/ (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2017/03/01/nested-method-calls-via-two-phase-borrowing/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416170122/https://smallcultfollowing.com/babysteps/blog/2017/03/01/nested-method-calls-via-two-phase-borrowing/ (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2017/07/11/non-lexical-lifetimes-draft-rfc-and-prototype-available/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416170125/https://smallcultfollowing.com/babysteps/blog/2017/07/11/non-lexical-lifetimes-draft-rfc-and-prototype-available/ (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2018/04/27/an-alias-based-formulation-of-the-borrow-checker/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416170128/https://smallcultfollowing.com/babysteps/blog/2018/04/27/an-alias-based-formulation-of-the-borrow-checker/ (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2018/06/15/mir-based-borrow-check-nll-status-update/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416170132/https://smallcultfollowing.com/babysteps/blog/2018/06/15/mir-based-borrow-check-nll-status-update/ (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2018/10/31/mir-based-borrowck-is-almost-here/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416170139/https://smallcultfollowing.com/babysteps/blog/2018/10/31/mir-based-borrowck-is-almost-here/ (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2018/11/01/after-nll-interprocedural-conflicts/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416170144/https://smallcultfollowing.com/babysteps/blog/2018/11/01/after-nll-interprocedural-conflicts/ (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2019/01/17/polonius-and-region-errors/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416170147/https://smallcultfollowing.com/babysteps/blog/2019/01/17/polonius-and-region-errors/ (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2019/01/21/hereditary-harrop-region-constraints/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416170150/https://smallcultfollowing.com/babysteps/blog/2019/01/21/hereditary-harrop-region-constraints/ (link) ```↩

  • ``` example https://boats.gitlab.io/blog/post/shifgrethor-i/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416172628/https://boats.gitlab.io/blog/post/shifgrethor-i/ (link) ```↩

  • ``` example https://boats.gitlab.io/blog/post/shifgrethor-ii/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416172630/https://boats.gitlab.io/blog/post/shifgrethor-ii/ (link) ```↩

  • ``` example https://boats.gitlab.io/blog/post/shifgrethor-iii/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416172636/https://boats.gitlab.io/blog/post/shifgrethor-iii/ (link) ```↩

  • ``` example https://boats.gitlab.io/blog/post/shifgrethor-iv/ (link) ```↩

  • ``` example https://web.archive.org/web/20200416172639/https://boats.gitlab.io/blog/post/shifgrethor-iv/ (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2015/12/18/rayon-data-parallelism-in-rust/ (link) ```↩

  • ``` example https://web.archive.org/web/20200423162646/https://smallcultfollowing.com/babysteps/blog/2015/12/18/rayon-data-parallelism-in-rust/ (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2016/02/19/parallel-iterators-part-1-foundations/ (link) ```↩

  • ``` example https://web.archive.org/web/20200423162647/https://smallcultfollowing.com/babysteps/blog/2016/02/19/parallel-iterators-part-1-foundations/ (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2016/02/25/parallel-iterators-part-2-producers/ (link) ```↩

  • ``` example https://web.archive.org/web/20200423162653/https://smallcultfollowing.com/babysteps/blog/2016/02/25/parallel-iterators-part-2-producers/ (link) ```↩

  • ``` example https://smallcultfollowing.com/babysteps/blog/2016/11/14/parallel-iterators-part-3-consumers/ (link) ```↩

  • ``` example https://web.archive.org/web/20200423162650/https://smallcultfollowing.com/babysteps/blog/2016/11/14/parallel-iterators-part-3-consumers/ (link) ```↩

  • ``` example https://tmandry.gitlab.io/blog/posts/optimizing-await-1/ (link) ```↩

  • ``` example https://web.archive.org/web/20200417142143/https://tmandry.gitlab.io/blog/posts/optimizing-await-1/ (link) ```↩

  • ``` example https://tmandry.gitlab.io/blog/posts/optimizing-await-2/ (link) ```↩

  • ``` example https://web.archive.org/web/20200417142149/https://tmandry.gitlab.io/blog/posts/optimizing-await-2/ (link) ```↩

  • ``` example https://os.phil-opp.com/freestanding-rust-binary/ (link) ```↩

  • ``` example https://web.archive.org/web/20200419114640/https://os.phil-opp.com/freestanding-rust-binary/ (link) ```↩

  • ``` example https://os.phil-opp.com/minimal-rust-kernel/ (link) ```↩

  • ``` example https://web.archive.org/web/20200419114644/https://os.phil-opp.com/minimal-rust-kernel/ (link) ```↩

  • ``` example https://os.phil-opp.com/vga-text-mode/ (link) ```↩

  • ``` example https://web.archive.org/web/20200419114648/https://os.phil-opp.com/vga-text-mode/ (link) ```↩

  • ``` example https://os.phil-opp.com/testing/ (link) ```↩

  • ``` example https://web.archive.org/web/20200419114651/https://os.phil-opp.com/testing/ (link) ```↩

  • ``` example https://os.phil-opp.com/cpu-exceptions/ (link) ```↩

  • ``` example https://web.archive.org/web/20200419114838/https://os.phil-opp.com/cpu-exceptions/ (link) ```↩

  • ``` example https://os.phil-opp.com/double-fault-exceptions/ (link) ```↩

  • ``` example https://web.archive.org/web/20200419114841/https://os.phil-opp.com/double-fault-exceptions/ (link) ```↩

  • ``` example https://os.phil-opp.com/hardware-interrupts/ (link) ```↩

  • ``` example https://web.archive.org/web/20200419114844/https://os.phil-opp.com/hardware-interrupts/ (link) ```↩

  • ``` example https://os.phil-opp.com/paging-introduction/ (link) ```↩

  • ``` example https://web.archive.org/web/20200419115000/https://os.phil-opp.com/paging-introduction/ (link) ```↩

  • ``` example https://os.phil-opp.com/paging-implementation/ (link) ```↩

  • ``` example https://web.archive.org/web/20200419115003/https://os.phil-opp.com/paging-implementation/ (link) ```↩

  • ``` example https://os.phil-opp.com/heap-allocation/ (link) ```↩

  • ``` example https://web.archive.org/web/20200419115006/https://os.phil-opp.com/heap-allocation/ (link) ```↩

  • ``` example https://os.phil-opp.com/allocator-designs/ (link) ```↩

  • ``` example https://web.archive.org/web/20200419115009/https://os.phil-opp.com/allocator-designs/ (link) ```↩

  • ``` example https://os.phil-opp.com/async-await/ (link) ```↩

  • ``` example https://web.archive.org/web/20200419115012/https://os.phil-opp.com/async-await/ (link) ```↩

  • ``` example https://bodil.lol/parser-combinators/ (link) ```↩

  • ``` example https://web.archive.org/web/20200423162949/https://bodil.lol/parser-combinators/ (link) ```↩

  • ``` example https://manishearth.github.io/blog/2017/01/14/stop-ascribing-meaning-to-unicode-code-points/ (link) ```↩

  • ``` example https://web.archive.org/web/20200430223156/https://manishearth.github.io/blog/2017/01/14/stop-ascribing-meaning-to-unicode-code-points/ (link) ```↩

  • ``` example https://manishearth.github.io/blog/2017/01/15/breaking-our-latin-1-assumptions/ (link) ```↩

  • ``` example https://web.archive.org/web//https://manishearth.github.io/blog/2017/01/15/breaking-our-latin-1-assumptions/ (link) ```↩

  • ``` example https://manishearth.github.io/blog/2018/02/15/picking-apart-the-crashing-ios-string/ (link) ```↩

  • ``` example https://web.archive.org/web/20200430223226/https://manishearth.github.io/blog/2018/02/15/picking-apart-the-crashing-ios-string/ (link) ```↩

    • In this article
    Revisions
    DateHash
    2023-02-22ea5044fc
    Navigation
    Previousadvice
    Nextfitness
    Uppages