Test MDX File V12

RustMemoryLab Demo

Rust Memory Lab

Drag a Rust type onto the stack. Owned types — Box, String, Vec — also claim space on the heap.

derekmolloy.ie

Stackbase = 0x7FFFFFE0

32 / 32 bytes used0 free

+10

+18

0x00603000

ptr

0x00603004

len

0x05

cap

0x05

byte 0

Heapbase = 0x00603000

9 / 32 bytes used23 free

+10

+18

"hello"

byte 0

Type Palette — drag onto the stack

bool1B

i81B

char4B

i324B

f324B

i648B

f648B

Box<i32>8B + heap

String24B + heap

Vec<i32>24B + heap

integer types

floating point

character

boolean

owned (heap-backed)

Declared bindings

Type	Name	Value	Stack addr	Stack	Heap
Box<i32>	a	42	0x7FFFFFE0	8 B	4 B
String	b	hello	0x7FFFFFE8	24 B	5 B

Try this:Click Worked example. Notice that a: Box<i32> stores an 8-byte pointer on the stack and just 4 bytes on the heap — the value lives over there. b: String is the heaviest: 24 bytes of stack record (pointer + length + capacity) plus the actual UTF-8 bytes on the heap. Together they fill the 32-byte stack exactly. Now clear all and drag an i32 in — it claims 4 stack bytes and zero heap. Then drag a char — it claims 4 bytes too, not 1. Rust's char is a Unicode scalar value, not a byte.

MutLab Demo

Rust Mutability Lab

Toggle mut on the binding and on the reference. To mutate through r, you need both.

derekmolloy.ie

Sourcequadrant: x (immutable) + no reference

let x: i32 = 5;

Stackone binding · optional reference

base = 0x7FFFFFD8

i32

4B·FFD8

Configure the source

x type

x mut?

r borrow

Run a statement

Try this:Set x mut? to let x, declare r, and set its borrow to &mut x. Notice the red banner: Rust refuses, because you can't hand out a mutable reference to an immutable binding. Now flip x mut? to let mut x and the configuration compiles. Press *r = … and watch the value update through the reference. Finally, switch x type to String. The rules are identical, but the action becomes r.push_str(", world") and the heap data updates instead.

ThreadLab Demo

Rust Thread Lab

What can cross the thread boundary? Three walls — 'static, Send, and Mutex — and how to cross each.

derekmolloy.ie

Phase:pre-spawnspawnedjoined

Stack — mainbase = 0x7FFFFFD8

Frame is empty. Declare a binding to begin.

Heap — shared between threadsbase ≈ 0x00603000

Heap is empty. Vec, Rc, Arc, and Mutex all allocate here.

1 · Declare in main

3 · Spawn the thread

Try this:Declare v, leave its capture mode at &, and press the plain spawn. Rust refuses — the closure might outlive main. Switch to spawn move and it compiles. Now reset and try the same with rc — even with move, Rust refuses because Rc isn't Send. Swap to arc and it works. Finally, declare shared, capture it as .clone(), spawn-move, and increment through the lock — both threads now share write access, mediated by the Mutex.

BugHuntLab Demo

Bug Hunt

C++

The code below should produce the output shown, but bugs are hiding in it. Drag a ladybird onto each bug you spot. No compiler needed.

derekmolloy.ie

Found0/5

Remaining5

False alarms0

-· 0%

Drag a ladybird onto a suspicious line.

greet.cppEasy

1#include <iostream>

3int main() {

4 int ready = 1;

5 if (ready = 1) {

6 std::cout << 'Hello, world!' << "\n";

7 }

9 for (int i = 1; i < 5; i++) {

10 std::cin >> i << " "

11 }

12 std::cout << "\n";

13 return 0;

14}

Bug jar

Drag onto a suspect spot in the code. A wrong drop is a false alarm.

Intended output

Print a greeting, then count from 1 to 5 on one line.

Hello, world!
1 2 3 4 5

RustBugHuntLab Demo

Rust Bug Hunt

Rust

The code below should produce the output shown, but bugs are hiding in it. Drag a ladybird onto each bug you spot. No compiler needed.

derekmolloy.ie

Found0/5

Remaining5

False alarms0

-· 0%

Drag a ladybird onto a suspicious line.

greet.rsEasy

1fn double(x: i32) -> i32 {

2 x * 2;

3}

5fn main() {

6 println('Hello, world!');

8 let n = 21;

9 let result = double(n);

10 n += 1;

11 println!("Double of {} is {}", result);

12}

Bug jar

Drag onto a suspect spot in the code. A wrong drop is a false alarm.

Intended output

Print a greeting, then double a number and print the result.

Hello, world!
Double of 21 is 42