From 295b343aecf330e830d79f06e0efc511e7d76da1 Mon Sep 17 00:00:00 2001
From: Jasper Ras <jras@hostnet.nl>
Date: Tue, 5 Aug 2025 08:53:21 +0200
Subject: vault backup: 2025-08-05 08:53:21

---
 .obsidian/appearance.json                            |   4 +++-
 .obsidian/graph.json                                 |   2 +-
 A cool tool that visualizes the borrow checker.md    |   5 +++++
 ... to put on the left-hand side of an assignment.md |  12 ++++++++++++
 ...from dereferencing a pointer cannot be mutated.md |   1 +
 ...sing the same data through different variables.md |   9 +++++++++
 Borrow checker.md                                    |   8 ++++++++
 Box deallocation principle.md                        |   6 ++++++
 Boxes live in the heap.md                            |  15 +++++++++++++++
 Cloning a box does a deep copy of the heap data.md   |   7 +++++++
 ... a reference to a variable is called borrowing.md |  13 +++++++++++++
 ...rencing is to access the data behind a pointer.md |  10 ++++++++++
 Downgrading a mutable reference.md                   |  10 ++++++++++
 Go Strings.md                                        |   1 +
 ...reference while an immutable reference is live.md |   2 ++
 Lifetime specifier.md                                |   3 +++
 Moved heap data principle.md                         |   6 ++++++
 ...erences are safe because they prevent aliasing.md |   7 +++++++
 Ownership.md                                         |  14 ++++++++++++++
 Pasted image 20250804184242.png                      | Bin 0 -> 54154 bytes
 Pointer safety principle.md                          |   8 ++++++++
 References are also immutable by default.md          |   1 +
 References temporarily remove permissions.md         |   8 ++++++++
 Rust principles.md                                   |   4 ++++
 Rust.md                                              |  10 ++++++++++
 Undefined behaviour is caught by the compiler.md     |  10 ++++++++++
 ...bject to permissions similar to files on linux.md |  13 +++++++++++++
 Variables lives in the stack.md                      |  19 +++++++++++++++++++
 What is a segmentation fault.md                      |   4 ++++
 When boxes are deallocated.md                        |   8 ++++++++
 30 files changed, 218 insertions(+), 2 deletions(-)
 create mode 100644 A cool tool that visualizes the borrow checker.md
 create mode 100644 A place is anything that is valid to put on the left-hand side of an assignment.md
 create mode 100644 Accessed data from dereferencing a pointer cannot be mutated.md
 create mode 100644 Aliasing is accessing the same data through different variables.md
 create mode 100644 Borrow checker.md
 create mode 100644 Box deallocation principle.md
 create mode 100644 Boxes live in the heap.md
 create mode 100644 Cloning a box does a deep copy of the heap data.md
 create mode 100644 Creating a reference to a variable is called borrowing.md
 create mode 100644 Dereferencing is to access the data behind a pointer.md
 create mode 100644 Downgrading a mutable reference.md
 create mode 100644 It is illegal to create a mutable reference while an immutable reference is live.md
 create mode 100644 Lifetime specifier.md
 create mode 100644 Moved heap data principle.md
 create mode 100644 Mutable references are safe because they prevent aliasing.md
 create mode 100644 Ownership.md
 create mode 100644 Pasted image 20250804184242.png
 create mode 100644 Pointer safety principle.md
 create mode 100644 References temporarily remove permissions.md
 create mode 100644 Rust principles.md
 create mode 100644 Undefined behaviour is caught by the compiler.md
 create mode 100644 Variables are subject to permissions similar to files on linux.md
 create mode 100644 Variables lives in the stack.md
 create mode 100644 What is a segmentation fault.md
 create mode 100644 When boxes are deallocated.md

diff --git a/.obsidian/appearance.json b/.obsidian/appearance.json
index 9e26dfe..4be7969 100644
--- a/.obsidian/appearance.json
+++ b/.obsidian/appearance.json
@@ -1 +1,3 @@
-{}
\ No newline at end of file
+{
+  "theme": "obsidian"
+}
\ No newline at end of file
diff --git a/.obsidian/graph.json b/.obsidian/graph.json
index 863f273..2dc66d1 100644
--- a/.obsidian/graph.json
+++ b/.obsidian/graph.json
@@ -17,6 +17,6 @@
   "repelStrength": 10,
   "linkStrength": 1,
   "linkDistance": 500,
-  "scale": 0.04303687666455931,
+  "scale": 0.4828332660330065,
   "close": true
 }
\ No newline at end of file
diff --git a/A cool tool that visualizes the borrow checker.md b/A cool tool that visualizes the borrow checker.md
new file mode 100644
index 0000000..425e6d2
--- /dev/null
+++ b/A cool tool that visualizes the borrow checker.md	
@@ -0,0 +1,5 @@
+[[Rust]]
+
+---
+
+https://github.com/cognitive-engineering-lab/aquascope
\ No newline at end of file
diff --git a/A place is anything that is valid to put on the left-hand side of an assignment.md b/A place is anything that is valid to put on the left-hand side of an assignment.md
new file mode 100644
index 0000000..cd679e7
--- /dev/null
+++ b/A place is anything that is valid to put on the left-hand side of an assignment.md	
@@ -0,0 +1,12 @@
+[[Borrow checker]]
+
+It is not THE left hand side of an assignment but anything that is valid to put there. But they can appear anywhere from what it looks like.
+
+It includes:
+- variables `a`
+- dereferences of places `*a`
+- Array accesses of places `a[0]`
+- Fields of places `a.0`
+- Any combination of the above
+
+The borrow checker expects a place to have certain permissions depending on the operation.
\ No newline at end of file
diff --git a/Accessed data from dereferencing a pointer cannot be mutated.md b/Accessed data from dereferencing a pointer cannot be mutated.md
new file mode 100644
index 0000000..6fe3195
--- /dev/null
+++ b/Accessed data from dereferencing a pointer cannot be mutated.md	
@@ -0,0 +1 @@
+[[Creating a reference to a variable is called borrowing]]
diff --git a/Aliasing is accessing the same data through different variables.md b/Aliasing is accessing the same data through different variables.md
new file mode 100644
index 0000000..16db4a3
--- /dev/null
+++ b/Aliasing is accessing the same data through different variables.md	
@@ -0,0 +1,9 @@
+[[Rust]]
+[[Ownership]]
+[[Dereferencing is to access the data behind a pointer]]
+[[Pointer safety principle]]
+
+
+---
+
+Mutating an alias is dangerous.
\ No newline at end of file
diff --git a/Borrow checker.md b/Borrow checker.md
new file mode 100644
index 0000000..09700ba
--- /dev/null
+++ b/Borrow checker.md	
@@ -0,0 +1,8 @@
+[[Rust]]
+[[Ownership]]
+[[Dereferencing is to access the data behind a pointer]]
+[[Aliasing is accessing the same data through different variables]]
+[[Variables are subject to permissions similar to files on linux]]
+[[References temporarily remove permissions]]
+[[Creating a reference to a variable is called borrowing]]
+[[It is illegal to create a mutable reference while an immutable reference is live]]
diff --git a/Box deallocation principle.md b/Box deallocation principle.md
new file mode 100644
index 0000000..01418d4
--- /dev/null
+++ b/Box deallocation principle.md	
@@ -0,0 +1,6 @@
+[[Rust principles]]
+[[When boxes are deallocated]]
+
+---
+
+If a variable owns a box, when Rust deallocates the variable’s frame, then Rust deallocates the box’s heap memory.
\ No newline at end of file
diff --git a/Boxes live in the heap.md b/Boxes live in the heap.md
new file mode 100644
index 0000000..ec296c9
--- /dev/null
+++ b/Boxes live in the heap.md	
@@ -0,0 +1,15 @@
+[[Rust]]
+[[Variables lives in the stack]]
+[[When boxes are deallocated]]
+[[Ownership]]
+
+---
+
+The heap is where data can live indefinitely and we can create pointers to it on the stack using a Box.
+
+```rust
+let a = Box::new([0; 1_000_000]);
+let b = a;
+```
+
+Creates an array with 1 million entries on the heap and two variables on the stack that point to it.
\ No newline at end of file
diff --git a/Cloning a box does a deep copy of the heap data.md b/Cloning a box does a deep copy of the heap data.md
new file mode 100644
index 0000000..25c861d
--- /dev/null
+++ b/Cloning a box does a deep copy of the heap data.md	
@@ -0,0 +1,7 @@
+[[Rust]]
+[[Ownership]]
+[[Moved heap data principle]]
+
+---
+
+To get around the issue of not being able to use a box after we moved ownership we can call .clone() on it. A clone is a deep copy of the heap data rather than just a shallow copy of the pointer to the original heap data.
\ No newline at end of file
diff --git a/Creating a reference to a variable is called borrowing.md b/Creating a reference to a variable is called borrowing.md
new file mode 100644
index 0000000..245d060
--- /dev/null
+++ b/Creating a reference to a variable is called borrowing.md	
@@ -0,0 +1,13 @@
+[[Rust]]
+[[References are also immutable by default]]
+[[Mutable references are safe because they prevent aliasing]]
+[[Ownership]]
+[[Dereferencing is to access the data behind a pointer]]
+
+---
+
+Creating a reference is done with an ampersand. It creates a pointer to another variable in the stack, which could be a pointer to something on the heap.
+
+This is called borrowing.
+
+A reference is a non-owning pointer; so if we create a reference to a Box we can safely have it discarded and continue using the box because the heap data is not deallocated.
\ No newline at end of file
diff --git a/Dereferencing is to access the data behind a pointer.md b/Dereferencing is to access the data behind a pointer.md
new file mode 100644
index 0000000..73cbeee
--- /dev/null
+++ b/Dereferencing is to access the data behind a pointer.md	
@@ -0,0 +1,10 @@
+[[Rust]]
+[[Ownership]]
+[[References are also immutable by default]]
+[[Accessed data from dereferencing a pointer cannot be mutated]]
+
+---
+
+The dereference operator is similar as in Go an asterisk. By dereferencing a pointer it is possible to access the data it points to.
+
+When you use the dereference operator in an assignment the variable has the same value as what the pointer holds.
\ No newline at end of file
diff --git a/Downgrading a mutable reference.md b/Downgrading a mutable reference.md
new file mode 100644
index 0000000..e1e61a2
--- /dev/null
+++ b/Downgrading a mutable reference.md	
@@ -0,0 +1,10 @@
+[[Creating a reference to a variable is called borrowing]]
+
+---
+
+It can be done:
+```rust
+let x: i32 = 1; <- R - O
+let y: &mut x;  <- R W O
+let z: &*y;     <- R - O
+```
\ No newline at end of file
diff --git a/Go Strings.md b/Go Strings.md
index 51eab51..26aed7b 100644
--- a/Go Strings.md	
+++ b/Go Strings.md	
@@ -1,4 +1,5 @@
 [[Golang]]
+[[Char is a unicode scalar value]]
 
 ---
 
diff --git a/It is illegal to create a mutable reference while an immutable reference is live.md b/It is illegal to create a mutable reference while an immutable reference is live.md
new file mode 100644
index 0000000..a201199
--- /dev/null
+++ b/It is illegal to create a mutable reference while an immutable reference is live.md	
@@ -0,0 +1,2 @@
+
+|
\ No newline at end of file
diff --git a/Lifetime specifier.md b/Lifetime specifier.md
new file mode 100644
index 0000000..b1c5caa
--- /dev/null
+++ b/Lifetime specifier.md	
@@ -0,0 +1,3 @@
+[[Borrow checker]]
+
+A flow permission cannot be given if a function signature states that it returns a reference but the function has multiple returns referencing potentially different variables so the borrow checker doesn't know if it's safe or not.
\ No newline at end of file
diff --git a/Moved heap data principle.md b/Moved heap data principle.md
new file mode 100644
index 0000000..a25f60a
--- /dev/null
+++ b/Moved heap data principle.md	
@@ -0,0 +1,6 @@
+[[Rust principles]]
+[[Ownership]]
+
+---
+
+If a variable `x` moves ownership of heap data to another variable `y`, then `x` cannot be used after the move.
\ No newline at end of file
diff --git a/Mutable references are safe because they prevent aliasing.md b/Mutable references are safe because they prevent aliasing.md
new file mode 100644
index 0000000..bb837f7
--- /dev/null
+++ b/Mutable references are safe because they prevent aliasing.md	
@@ -0,0 +1,7 @@
+[[Pointer safety principle]]
+[[Aliasing is accessing the same data through different variables]]
+[[Downgrading a mutable reference]]
+
+---
+
+A reference that is mutable is created with `&mut` . They are safe because all permissions are dropped from the borrowed place so it can not be read while the reference exists. It is therefore not an alias.
\ No newline at end of file
diff --git a/Ownership.md b/Ownership.md
new file mode 100644
index 0000000..5484772
--- /dev/null
+++ b/Ownership.md
@@ -0,0 +1,14 @@
+[[Rust]]
+[[When boxes are deallocated]]
+[[Moved heap data principle]]
+[[Creating a reference to a variable is called borrowing]]
+
+
+---
+
+When we assign a Box to a name we say that name owns the box. Any time we copy the pointer to that box to another name we also pass ownership to that name.
+
+After we pass ownership and move into a new scope the original variable is freed. Thus when we return to the original scope it is no longer possible to use it.
+
+![[Pasted image 20250804184242.png]]
+> Wherever the stack variable is greyed out means it is no longer the owner.
\ No newline at end of file
diff --git a/Pasted image 20250804184242.png b/Pasted image 20250804184242.png
new file mode 100644
index 0000000..2201b83
Binary files /dev/null and b/Pasted image 20250804184242.png differ
diff --git a/Pointer safety principle.md b/Pointer safety principle.md
new file mode 100644
index 0000000..d47520c
--- /dev/null
+++ b/Pointer safety principle.md	
@@ -0,0 +1,8 @@
+[[Rust principles]]
+[[Borrow checker]]
+
+---
+
+Data should never be aliased and mutated at the same time.
+
+Boxes are not allowed to be aliased. References are meant to be aliased: the pointer safety principle is ensured via the borrow checker.
\ No newline at end of file
diff --git a/References are also immutable by default.md b/References are also immutable by default.md
index f434b63..523f4d5 100644
--- a/References are also immutable by default.md	
+++ b/References are also immutable by default.md	
@@ -1,4 +1,5 @@
 [[Rust]]
+[[Mutable references are safe because they prevent aliasing]]
 
 ---
 
diff --git a/References temporarily remove permissions.md b/References temporarily remove permissions.md
new file mode 100644
index 0000000..817b801
--- /dev/null
+++ b/References temporarily remove permissions.md	
@@ -0,0 +1,8 @@
+[[Variables are subject to permissions similar to files on linux]]
+[[Creating a reference to a variable is called borrowing]]
+[[Pointer safety principle]]
+[[References are also immutable by default]]
+
+---
+
+Borrowing from a variable temporarily removes its write and own permissions. Thus guaranteeing the safety principle.
\ No newline at end of file
diff --git a/Rust principles.md b/Rust principles.md
new file mode 100644
index 0000000..dc39b12
--- /dev/null
+++ b/Rust principles.md	
@@ -0,0 +1,4 @@
+[[Rust]]
+
+[[Box deallocation principle]]
+[[Moved heap data principle]]
diff --git a/Rust.md b/Rust.md
index 39825ee..be302f9 100644
--- a/Rust.md
+++ b/Rust.md
@@ -1,4 +1,6 @@
 [[Why it is good to learn rust]]
+[[A cool tool that visualizes the borrow checker]]
+[[Rust principles]]
 [[Cargo]]
 [[Items that are always imported by default in Rust are called the prelude]]
 [[Static class functions are called associated functions]]
@@ -23,3 +25,11 @@
 [[If is not a statement but an expression]]
 [[Returning values from loops]]
 [[Loop over an array with for-in]]
+[[Undefined behaviour is caught by the compiler]]
+[[Variables lives in the stack]]
+[[Boxes live in the heap]]
+[[Cloning a box does a deep copy of the heap data]]
+[[Aliasing is accessing the same data through different variables]]
+[[Borrow checker]]
+[[A place is anything that is valid to put on the left-hand side of an assignment]]
+
diff --git a/Undefined behaviour is caught by the compiler.md b/Undefined behaviour is caught by the compiler.md
new file mode 100644
index 0000000..62adbff
--- /dev/null
+++ b/Undefined behaviour is caught by the compiler.md	
@@ -0,0 +1,10 @@
+[[Rust]]
+[[What is a segmentation fault]]
+
+Undefined behaviour is prevented by compiler checks. For example we can't use an undefined variable in a function call. If that were unchecked it's behaviour is undefined:
+- it could cause a segvault
+- it could cause no harm
+- it could become the target of a hack
+
+A list of behaviours considered undefined:
+https://doc.rust-lang.org/reference/behavior-considered-undefined.html
\ No newline at end of file
diff --git a/Variables are subject to permissions similar to files on linux.md b/Variables are subject to permissions similar to files on linux.md
new file mode 100644
index 0000000..5a47739
--- /dev/null
+++ b/Variables are subject to permissions similar to files on linux.md	
@@ -0,0 +1,13 @@
+[[Rust]]
+[[A place is anything that is valid to put on the left-hand side of an assignment]]
+[[Lifetime specifier]]
+
+---
+
+Rust has a permission system similar to file permissions for variables:
+- R: read: data can be copied
+- W: write: data can be mutated
+- O: own: data can be moved or dropped
+- F: Flow: expected when a function input uses a reference or when a function returns a reference
+
+The default is : "RO". `mut` adds "W".
\ No newline at end of file
diff --git a/Variables lives in the stack.md b/Variables lives in the stack.md
new file mode 100644
index 0000000..a929a67
--- /dev/null
+++ b/Variables lives in the stack.md	
@@ -0,0 +1,19 @@
+[[Rust]]
+[[Boxes live in the heap]]
+
+
+---
+
+The stack consists of frames.
+
+Frames are just mappings of names to values within a single scope, they are tightly coupled to a specific function
+
+Freeing is the act of discarding such a frame.
+
+If we assign a variable such as 
+```rust
+let a = [0; 1_000_000];
+let b = a;
+```
+
+the value of a is **copied** to b (thus we get two huge arrays). This is **expensive**. Think about what happens when we call a function.
\ No newline at end of file
diff --git a/What is a segmentation fault.md b/What is a segmentation fault.md
new file mode 100644
index 0000000..63dac0a
--- /dev/null
+++ b/What is a segmentation fault.md	
@@ -0,0 +1,4 @@
+[[Linux]]
+[[Rust]]
+
+A segmentation fault is raised by the kernel when a program attempts to access a segment of memory that does not belong to the process or for example is not writable and it tries to write there.
\ No newline at end of file
diff --git a/When boxes are deallocated.md b/When boxes are deallocated.md
new file mode 100644
index 0000000..96c2c34
--- /dev/null
+++ b/When boxes are deallocated.md	
@@ -0,0 +1,8 @@
+[[Rust]]
+[[Boxes live in the heap]]
+[[Ownership]]
+
+
+---
+
+A box's heap memory is freed automatically when the frame of the variable who owns the box is freed.
\ No newline at end of file
-- 
cgit v1.2.3