Thought Log

Quick notes, half-formed ideas, and learning snippets. Mostly unpolished thoughts about coding, languages, and concepts I'm exploring.

January 26, 2025

Rust Basics Syntax

Exploring Rust’s fundamental syntax and concepts. The :: notation, use statements, and #[derive] macros are everywhere in Rust code, but understanding what they actually do makes the language much more approachable.

The `::` (Path Separator) Notation

In Rust, :: is used to access items in modules, crates, and namespaces. Think of it like navigating a file system, but for code organization.

// Accessing standard library items
std::collections::HashMap
std::io::stdin

// Accessing associated functions (like static methods)
String::from("hello")
Vec::new()

// Accessing associated constants
i32::MAX
f64::EPSILON

The :: operator creates a path through the module hierarchy. std::collections::HashMap means: “In the std crate, go to the collections module, and get HashMap”.

Importing with `use`

The use keyword brings items into scope so you don’t have to write the full path every time.

// Without use - verbose
let map = std::collections::HashMap::new();

// With use - cleaner
use std::collections::HashMap;
let map = HashMap::new();

// You can also use nested paths
use std::collections::{HashMap, HashSet};
use std::io::{self, Read, Write}; // 'self' brings the parent module too

Key points:

use statements typically go at the top of the file
You can use as to rename imports: use std::io::Result as IoResult;, similar to python
Wildcards exist but are discouraged: use std::collections::*;

The Standard Library (`std`)

Rust’s standard library (std) provides essential functionality without external dependencies. It’s always available and includes:

Collections: Vec, HashMap, HashSet, BTreeMap
I/O: std::io for reading/writing, std::fs for file operations
String handling: String, str, String::from()
Error handling: Result<T, E>, Option<T>
Concurrency: std::thread, std::sync

use std::collections::HashMap;
use std::io::{self, Write};

fn main() -> io::Result<()> {
    let mut scores = HashMap::new();
    scores.insert("Alice", 100);
    
    io::stdout().write_all(b"Hello, world!\n")?;
    Ok(()) // Ok(()) returns a successful Result with no value (the () is the unit type)
}

What is a HashMap?

A HashMap is a key-value data structure that allows you to store and retrieve values by their keys. Think of it like a dictionary or lookup table where each key maps to exactly one value. The “hash” part comes from the hashing function that’s used internally to quickly locate values based on their keys.

"Alice" is the key and 100 is the value. You can insert key-value pairs with insert(), retrieve values with get(), and check if a key exists with contains_key(). HashMaps are particularly useful when you need fast lookups, insertions, and deletions based on keys.

let mut scores = HashMap::new();
scores.insert("Alice", 100);
scores.insert("Bob", 85);

// Retrieve a value
// Some(value) wraps a value that exists
if let Some(score) = scores.get("Alice") {
    println!("Alice's score: {}", score); // Prints: Alice's score: 100
}

// Check if key exists
if scores.contains_key("Bob") {
    println!("Bob is in the map");
}

Derive Macros (`#[derive]`)

The #[derive] attribute automatically implements common traits for your types. It’s like getting free implementations of useful functionality.

#[derive(Debug, Clone, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

// Now Point automatically has:
// - Debug: can be printed with {:?}
// - Clone: can be cloned with .clone()
// - PartialEq: can be compared with ==

Common derive traits:

Debug: Enables formatting with {:#?} for debugging
Clone: Allows creating copies with .clone()
Copy: Makes the type copyable (for small types like integers), although so far i’ve assumed that as default when borrowing - need to read more on this
PartialEq / Eq: Enables == and != comparisons
PartialOrd / Ord: Enables ordering (<, >, etc.)
Hash: Enables use in HashMap and HashSet keys
Default: Provides a default value

#[derive(Debug, Clone, PartialEq, Hash)]
struct Atom {
    id: u32,
    element: String,
    coordinates: [f64; 3],
}

// All of these work automatically:
let atom1 = Atom { id: 1, element: String::from("C"), coordinates: [0.0, 0.0, 0.0] };
let atom2 = atom1.clone(); // Clone trait
println!("{:?}", atom1); // Debug trait
let mut map = HashMap::new();
map.insert(atom1, "carbon"); // Hash trait
map.insert(atom2, "carbon");

Bringing It Together

Here’s a complete example showing all these concepts:

use std::collections::HashMap;

#[derive(Debug, Clone, PartialEq)]
struct Experiment {
    id: u32,
    temperature: f64,
    results: Vec<f64>,
}

fn main() {
    // Using std::collections::HashMap
    let mut experiments = HashMap::new();
    
    // Creating instances using :: notation
    let exp1 = Experiment {
        id: 1,
        temperature: 298.15,
        results: vec![1.0, 2.0, 3.0],
    };
    
    // Clone works because of #[derive(Clone)]
    let exp2 = exp1.clone();
    
    // Debug works because of #[derive(Debug)]
    println!("Experiment: {:?}", exp1);
    
    // PartialEq works because of #[derive(PartialEq)]
    assert_eq!(exp1, exp2); // assert_eq! panics if the two values are not equal, useful for testing
    
    experiments.insert(exp1.id, exp1);
}

Understanding these basics makes Rust code much more readable. The :: notation shows the module hierarchy, use statements clean up repetitive paths, std provides the foundation, and #[derive] gives you powerful traits without writing boilerplate.

More to come!

January 23, 2025

Rust Ownership Borrowing Lifetimes Molecular Dynamics Simulations

A more established look at Rust’s ownership model in familiar territory computational simulations. The borrow checker prevents you from accidentally corrupting your data structures.

Ownership in Molecular Simulations

In molecular dynamics simulations, we track atom positions over time. Each atom position has a unique identity, coordinates, and state. Just like a bank account, we need to ensure data integrity while allowing operations to modify or read these positions.

Struct Definitions

#[derive(Debug)]
struct AtomPosition {
    id: u32,
    coordinates: [f64; 3],  // x, y, z
    atom_type: String,
}

impl AtomPosition {
    fn new(id: u32, atom_type: String) -> Self {
        AtomPosition {
            id,
            atom_type,
            coordinates: [0.0, 0.0, 0.0],
        }
    }

    fn update_position(&mut self, new_coords: [f64; 3]) -> [f64; 3] {
        self.coordinates = new_coords;
        self.coordinates
    }

    fn apply_force(&mut self, force: [f64; 3], timestep: f64) -> [f64; 3] {
        // Simplified: update position based on force
        self.coordinates[0] += force[0] * timestep;
        self.coordinates[1] += force[1] * timestep;
        self.coordinates[2] += force[2] * timestep;
        self.coordinates
    }

    fn summary(&self) -> String {
        format!("Atom {} ({}) at [{:.2}, {:.2}, {:.2}]", 
                self.id, self.atom_type, 
                self.coordinates[0], self.coordinates[1], self.coordinates[2])
    }
}

#[derive(Debug)]
struct Simulation {
    atoms: Vec<AtomPosition>,
}

impl Simulation {
    fn new() -> Self {
        Simulation { atoms: vec![] }
    }

    fn add_atom(&mut self, atom: AtomPosition) {
        self.atoms.push(atom);
    }

    fn total_energy(&self) -> f64 {
        // Simplified: sum of some energy metric
        self.atoms.iter()
            .map(|atom| {
                // Calculate energy based on position
                atom.coordinates[0].powi(2) + 
                atom.coordinates[1].powi(2) + 
                atom.coordinates[2].powi(2)
            })
            .sum()
    }

    fn summary(&self) -> Vec<String> {
        self.atoms
            .iter()
            .map(|atom| atom.summary())
            .collect::<Vec<String>>()
    }
}

Borrowing and References

The & operator creates a reference, allowing us to read data without taking ownership:

fn print_atom(atom: &AtomPosition) {
    println!("{:#?}", atom);
}

fn modify_atom(atom: &mut AtomPosition) {
    atom.coordinates = [1.0, 2.0, 3.0];
}

In simulations, this is crucial. We need to be able to:

Read atom positions for analysis (&AtomPosition) - multiple readers allowed
Modify atom positions during simulation steps (&mut AtomPosition) - exclusive access required

Ownership and Moving

fn main() {
    let atom = AtomPosition::new(1, String::from("C"));  // Ownership assigned to 'atom'
    let atom_ref = &atom;  // Borrowing - atom still owned by 'atom' binding
    let atom_ref2 = &atom;  // Multiple immutable borrows allowed
    
    print_atom(atom_ref);
    print_atom(atom_ref2);
    
    // let other_atom = atom;  // This would move ownership - atom no longer valid
    // print_atom(&atom);      // Error: atom was moved
    
    // Mutable reference example
    let mut atom = AtomPosition::new(1, String::from("C"));
    modify_atom(&mut atom);  // Exclusive mutable access
    println!("{:#?}", atom);
}

Lifetimes and Scope

fn make_and_print_atom() {
    let atom = AtomPosition::new(1, String::from("C"));
    println!("{:#?}", atom);
    // 'atom' lifetime ends here - memory is freed
}

// The following won't compile - returning a reference to a local variable
fn make_and_print_atom_keep() -> &AtomPosition {
    let atom = AtomPosition::new(1, String::from("C"));
    println!("{:#?}", atom);
    &atom  // Error: atom is dropped at end of function
}

The lifetime of atom is tied to its scope. Once the function returns, the value is dropped. This prevents dangling references - a common source of bugs in C/C++.

–

Key Insights

Ownership prevents data races: In parallel simulations, Rust’s ownership model ensures that only one thread can mutate atom positions at a time, preventing race conditions.
Borrowing enables efficient analysis: We can read atom positions from multiple analysis functions without copying data, crucial for large molecular systems.
Lifetimes ensure memory safety: The compiler tracks when data is valid, preventing use-after-free errors that plague C/C++ simulations.
Move semantics optimize performance: When transferring atom data between simulation stages, ownership moves rather than expensive deep copies.

The borrow checker annoying at first, but it prevents catastrophic errors that would only show up during a long-running simulation or in production code.

January 15, 2025

Rust Ownership

Started diving into Rust’s ownership model today. The borrow checker is some combination of frustrating and brilliant. Realized that most of my mental model from C++ doesn’t quite map over - Rust’s approach is more about preventing problems at compile time rather than managing them at runtime.

Thought Log

The `::` (Path Separator) Notation

Importing with `use`

The Standard Library (`std`)

Derive Macros (`#[derive]`)

Bringing It Together

Ownership in Molecular Simulations

Struct Definitions

Borrowing and References

Ownership and Moving

Lifetimes and Scope

Key Insights

Key Learnings

Example Code

Thought Log

The :: (Path Separator) Notation

Importing with use

The Standard Library (std)

Derive Macros (#[derive])

Bringing It Together

Ownership in Molecular Simulations

Struct Definitions

Borrowing and References

Ownership and Moving

Lifetimes and Scope

Key Insights

Key Learnings

Example Code

The `::` (Path Separator) Notation

Importing with `use`

The Standard Library (`std`)

Derive Macros (`#[derive]`)