Search for a command to run...
The Bank Card and Bank Account Analogy
No comments yet. Be the first to comment.
You are handing over the keys to your entire digital life just to send a single PDF. And it’s time to stop.
What our first week actually showed—and what it did not prove.
This is why we built SEYFR: you deserve to stay in charge of your most important files.
Letting Child Components Talk to Parents
Understanding Rust's ownership system can be tough at first, but once you think of variables as bank cards and values as bank accounts, everything starts to make sense.
let card_one = String::from("Bank Account: PIN 1234");
let card_two = card_one; // card_one is invalidated (dropped), now card_two owns the account
println!("{}", card_one); // ❌ ERROR!
// If the teller borrows card_one to try and print your bank details after you dropped it,
// they'll find the card is invalid.
println!("{}", card_two); // âś…
// If they borrow card_two however, they'll successfully print your bank info.
👉 Only one card can own the account at a time. When ownership is moved, the old card becomes useless.
let card_one = String::from("Bank Account");
let card_two = card_one.clone(); // make a copy of both the card and the account
println!("{} and {}", card_one, card_two); // âś…
👉 Now we have two cards each pointing to its own separate account. The accounts just happen to hold similar info, but they are distinct items.
let card_one = String::from("Bank Account");
let card_copy_one = &card_one; // borrow and read as much as you want as long as you can't change
let card_copy_two = &card_one; // borrow and read as much as you want as long as you can't change
println!("{}, {}", card_copy_one, card_copy_two ); // âś…
👉 Multiple read-only copies are fine. No one can change anything, but everyone can check the balance.
Let's say you want to change your account info:
let mut card_one = String::from("Bank Account");
// A financial assistant temporarily borrows your card, but this time with edit rights (mutable borrow)
let editor = &mut card_one;
println!("{}", card_one); // ❌
// If the financial assistant is still working with the card, you're not allowed to use it.
editor.push_str(" - PIN Updated"); // they update your PIN
But when the edit is complete: You are free to use it
let mut card_one = String::from("Bank Account");
let editor = &mut card_one;
editor.push_str(" - PIN Updated"); // âś… Editor finished
println!("{}", card_one); // âś… Back to the owner
Note: After the financial assistant is done changing your account and handed over ownership to you, they are not allowed to use their mutable borrow to read or update your bank account anymore.
let mut card_one = String::from("Bank Account");
let editor = &mut card_one;
editor.push_str(" - PIN Updated"); // âś… Editor finished
println!("{}", card_one); // âś… Back to the owner
println!("{}", editor); // ❌
// Once the mutable borrow is done, you can't keep using the editor to access the account.
👉 Only one mutable borrow is allowed at a time. And during that time, the owner can't access the card.
Only one owner (card) at a time.
You can clone to make a copy (new card + new account).
You can borrow immutably multiple times to read, but not change.
You can borrow mutably only once, exclusively, to edit.
Rust is like a strict bank that always knows who's holding the card, and won’t let you mess up account access rules.
🧠Once you understand the card/account model, you understand Rust’s safety rules.
SEYFR is built in Rust and uses Iroh to send files between supported devices. Its design page explains the real architecture—including BLAKE3 content hashes, verified data chunks, encrypted connections, and why the QR code identifies the transfer but does not contain the file.