From ea056b6e080669ba4b6f16c2757b4e2e88ea0553 Mon Sep 17 00:00:00 2001 From: Kyren223 Date: Tue, 6 Oct 2026 09:17:37 +0300 Subject: Commit blog posts --- src/content/blogs/_degoogle-your-life.mdx | 31 +++++++++ src/content/blogs/rust-is-great.md | 101 ++++++++++++++++++++++++++++++ 2 files changed, 132 insertions(+) create mode 100644 src/content/blogs/_degoogle-your-life.mdx create mode 100644 src/content/blogs/rust-is-great.md diff --git a/src/content/blogs/_degoogle-your-life.mdx b/src/content/blogs/_degoogle-your-life.mdx new file mode 100644 index 0000000..d6fa8e1 --- /dev/null +++ b/src/content/blogs/_degoogle-your-life.mdx @@ -0,0 +1,31 @@ +--- +title: "How to de-google your life" +description: How I de-googled my life and why you should do it too +date: 2222-11-11 +--- + +## What I already de-googled +- Proton (mail, drive, calendar maybe?) +- KeepassXC +- Gitea +- Linux +- Firefox (zen) +- DuckDuckGo +- Google photos, Google Drive backup etc + + +## New stuff +- SMS "Messages" app +- Kopia (write a password management/backup/other setup blog?) +- F-droid +- Use a custom android OS? +- Control over notifications? +- Fossify (Contacts/Phone/Messages) +- CoMaps instead of Google maps +- Aurora instead of Google play +- NetGuard +- Self host notes app? maybe just use git for sync + a markdown editor on mobile? +- Disable "My files" "Usage access" +- Disable "Phone Manager" +- Weather app +- Nova launcher diff --git a/src/content/blogs/rust-is-great.md b/src/content/blogs/rust-is-great.md new file mode 100644 index 0000000..6916867 --- /dev/null +++ b/src/content/blogs/rust-is-great.md @@ -0,0 +1,101 @@ +--- +title: "Rust is great... except for the language" +description: "" +date: 2026-08-27 +--- + +For those who know me it might be weird seeing me say "Rust is great", after all, I have been +openly bashing and criticize the language for quite a while now. + +While my opinion on Rust hasn't changed, I came to a realization that made me appreciate Rust +for what it has taught me -- which I hope to share in this blog. + +## What is Rust? + +> Rust is a blazingly fast and memory-efficient language: with no runtime or garbage collector, +> Rust's rich type system and ownership model guarantees memory-safety and thread-safety, +> enabling you to eliminate many classes of bugs at compile-time. + +Well... at least that's how the Rust website describes the language, in reality this is mostly +propaganda, it's inaccurate and misleading at best. + +A more fair definition might look like: + +Rust is a language that restricts the way you are allowed to program, enabling it to make certain +guarantees that allows detecting memory and data corruption at compile time. +Rust doesn't have a garbage collector, making it usually faster than garbage-collected languages. + +So, both of these definitions seem to focus on Rust being able to guarantees that usually only +garbage collected languages can make, so how does it do that? + +Rust accomplishes that via it's most unique feature: the Ownership Model. + +## What is Ownership? + +There are 3 rules to ownership: + +- Each value in Rust has an owner +- There can only be one owner at a time +- When the owner goes out of scope, the value will be dropped (freed/deallocated) + +Assigning a value to a variable, passing it as an argument to a function[^1] or returning it will +result in what's called a "move", where the existing variable gives up it's ownership and passes +it to a new owner. + +This mostly applies to types that allocate a resource that needs freeing, which in Rust means any +type that implements the `Drop` trait. +Types that don't implement `Drop` such as integers and other primitives are "trivially copyable" +meaning the value just gets copied instead of "moving" ownership. + +Just these rules already make a few nice guarantees: + +- Values are only dropped exactly once, preventing double frees +- Values can't be used after being dropped, preventing use-after-free (UAF) +- Values will be automatically dropped, preventing SOME memory leaks. + +One issue with this, is that if you pass a few values to a function temporarily, you must return +all of them back, otherwise the caller can no longer use them. + +This is fixed by another concept called "borrowing" -- as the the name suggests, instead of giving +up ownership, it allows to "borrow" a _reference_ to a value temporarily, and later return the +reference back to owner. + +There are 2 types of references, a read-only (immutable) reference, and a read-write (mutable) +reference. By restricting the programmer to only ever have a single mutable reference OR any +number of immutable references Rust is able to guarantee a bit more: + +- Data races can't happen as a value will never be written to while also being read/written by + something else +- References are always valid (no dangling references) + +There is one more concept worth mentioning, but first, I'd like to take this opportunity to shine +a light on one of my biggest issues with the language -- the restrictiveness of it. + +While these rules do give us guarantees, they make our lives incredibly tedious, we constantly +have to keep track of what's mutable, and what isn't, and what references do we have to what, +and if we get any of that wrong, we have to stop what we are doing, read a long error message, fix +the bug, and then go back and try to remember what we actually wanted to do - and then again, +every few minutes, it destroys productivity. + +And it doesn't even need to be a complex example, even this simple code doesn't compile: +```rust +let my_list = vec![1, 2, 3, 4]; +let first: &i32 = my_list[0]; +my_list.push(5); // error: can't take mutable reference because immutable reference exists (first) +let last: &i32 = my_list[my_list.len-1]; +println!("{first} and {second}"); +``` + +This is a very simple code example that doesn't violate any of the guarantees[^2] Rust makes, yet +Rust does not compile this code. This is because not every valid program would be verifiable by +Rust, there will always be correct programs that Rust will deny. + +## Lifetimes + + + + + + + + -- cgit v1.3.1