Anton Dolganin

I'm an engineer focused on solving problems, not tied to any specific language. Architecture, development, DevOps — I choose the right tools for the job and build solutions that work in production and scale without pain.

This article doesn’t aim to teach you Rust or unveil some hidden feature. It’s more like an experiment — a way to show a kid what Rust looks like on the inside (Rust, not the kid), rather than how to write idiomatic Rust code.

In other words, devs are used to judging a language by how well it fits into their mental model of “how code should be written.” And when it doesn’t? That’s when the frustration kicks in.

Here, I tried flipping the perspective — think “picture book”: how the language lives and breathes, not how we’ve learned to structure it.

⚠️ Disclaimer: This article isn’t about Copy types like i32, f64, bool, char, or &T. We're diving into move types — like String — where values are actually moved around.

Alright, let’s roll.

We’ll start with a core idea in Rust: a value (a memory cell) can only have one owner at a time. Let’s introduce a bit of “storybook” notation:

let = “let it be” = = “takes ownership” mut = “money”, yep, just a money ;)


let

Let’s let a own a House:


let a = String::from("House");

Now let’s let b own that same House. According to the rules, the previous owner has to move out — no exceptions:


let b = a;

At this point:


println!("a = {}", a);

Boom — error.

Why? Because a no longer has the right to do anything with the value (its former House). Ownership was transferred, and Rust enforces that hard.

mut

But wait — there’s more. Just owning a House doesn’t mean you can start remodeling it. Think of it like renting someone else's place — ownership without modification rights.

So this will trigger an error:


b.push_str(" with Pool"); // 🔴 error

If you want to make changes, you have to buy the House with some extra money mut.


let mut c = b;
c.push_str(" with pool");
println!("{}", c); // House with pool

Now c has the keys and the renovation permit.

&

We can share access to the House — say, by letting a buddy crash for a while. You hand them a copy of the keys using &:


let d = &c;
println!("{}", c);
println!("{}", d);

But there’s a catch. According to the social contract, if guests are inside, no renovations allowed. The following code will throw an error:


let d = &c;
c.push_str(" with sandbox");// can't renovate while guests are over
println!("{}", c);
println!("{}", d);// guest is here

You have to wait until the guests leave:


let d = &c;
println!("{}", d);// guest leaves
c.push_str(" with sandbox");

Still confused? There’s a full “guest etiquette” section at the end of the article.

& mut

Now let’s say your buddy wants to add a hot tub. Since that’s a modification to the House, you ask him to chip in — and in return, you give him the real keys with change privileges: &mut.


let e = &mut c;
e.push_str(" and with hot tub");
println!("{}", e);

Just remember: same rule applies — if someone else is holding the keys, you can’t do any remodeling. In fact, while your buddy is chilling in the hot tub, you can’t even enter the house:


let e = &mut c;
e.push_str(" and with hot tub");
println!("{}", c);
println!("{}", e);// buddy’s in the hot tub 

You have to wait for them to finish:


let e = &mut c;
e.push_str(" and with hot tub");
println!("{}", e);// buddy’s done
println!("{}", c);

This only applies when you gave out “paid” access (&mut) — not when you just let someone couch-surf with &.

mut &mut

Now we rent out the House again — to another buddy, this time with full mod rights. But this buddy also has their own extra money — mut.


let mut f = &mut c;
f.push_str(" and with garden");

Things are going well, and we decide to buy a second place: Apartment.


let mut c2 = String::from("Apartment");

Our buddy’s not slacking either — “Let me try out the Apartment too,” he says, waving his mut wallet. So he moves out of the House, into the Apartment, and starts upgrading that too:


f = &mut c2;
f.push_str(" with elevator");

Same core idea: ownership with editing rights = &mut. And declaring let mut f means this buddy isn’t tied to just one location — he can move between places and make changes. Because money mut, yep

After he’s gone, we end up with both properties modified:


println!("c: {}", c);
println!("c2: {}", c2);
//c: House with pool and with sandbox and with hot tub and with garden
//c2: Apartment with elevator

Note: When I say “the buddy left,” I mean it literally — he’s gone, out of scope. Rust tracks that. If a variable is no longer used later in the code, Rust considers it dead — like you called delete on it.

That’s why things can seem weird: while the guest is “around,” you’re blocked from doing stuff, but it’s not always clear they’ve “left.” Rust figures it out by analyzing whether the variable is used again — if not, it’s safe to proceed.

Functions

With a few rare exceptions, the same rules apply to functions too. I won’t overload this post with function examples — maybe next time :)

Rust for Kids