The non-null assertion operator (!) in TypeScript bypasses type safety by forcing the compiler to treat potentially nullable values as non-null, leading to runtime crashes. Instead of using this operator, developers should employ safer alternatives: optional chaining for nested property access, nullish coalescing for default values, conditional operators for explicit branching, type guards for reusable validation, and assertion functions for enforcing invariants. These approaches maintain type safety while handling null and undefined values appropriately, following fail-fast principles and preventing silent failures.

// --------- Ownership Rules ---------
// 1. Each value in Rust has a variable that's called its owner.
// 2. There can only be onw owner at a time.
// 3. When the owner goes out of scope, the value will be dropped.

fn main() {

    // Scoping
    {   // _s is not valid here.
        let _s = "Hello, World"; // _s is valid from this point forward. 
        // do stuff with _s.
    }   // This scope is now over, and _s is no longer valid.

    // Assigning variables to another variables.
    let x = 5;
    let _y = x; // Copy (because rust copies simple types) now y = 5

    let s1 = String::from("Hello, World");
    let _s2 = s1; // Move (not (shallow because that's not how rust handles this situation) or (copy because it's to expensive to add a copy on the heap))
    let _s3 = _s2.clone(); // instead to not pass the ownership of the variable to another variable use .clone() method

    println!("The new owner S3 value: {}", _s3);
}