miguelraz

LEARN

1. Learntla.com
2. TLA+ Exercises repo
3. TLA-seminar repo
4. https://elliotswart.github.io/pragmaticformalmodeling/
5. Practical TLA
   • PlusCal Hyperbook https://lamport.azurewebsites.net/tla/tutorial/session1.html
   • TLA+ Hyperbook https://lamport.azurewebsites.net/tla/hyperbook.html?back-link=learning.html#hyperbook
6. Examples repo

miguelraz

Plotting from Julia with Rust - "Just don't!" version :D

1. Run julia plotter.jl in a REPL, changing data1 appropriately
2. Modify your main.rs to dump the interesting files

Otherwise, you can probably setup a loop to redo this every 5 seconds - Makie is fast enough that just parsing and displaying the data should feel pretty fast.

miguelraz

#!/bin/sh

set -eu

if ! cargo fmt -- --check
then
    echo "There are some code style issues."
    echo "Run `cargo fmt` first."
    exit 1
fi

miguelraz

[
  {
    "arguments": [
      "/usr/bin/g++",
      "-march=native",
      "-mtune=native",
      "-m64",
      "-std=c++17",
      "-DPACKAGE_NAME=\"patchelf\"",
      "-DPACKAGE_TARNAME=\"patchelf\"",

miguelraz

[
  {
    "arguments": [
      "/usr/bin/gcc",
      "-march=native",
      "-mtune=native",
      "-m64",
      "-std=gnu99",
      "-D_GNU_SOURCE",
      "-Wall",

miguelraz

# TODO: https://teejeetech.com/2025/08/14/debian_13_tips/
sudo apt install curl llvm clang -y

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# . "$HOME/.cargo/env"            # For sh/bash/zsh/ash/dash/pdksh
#source "$HOME/.cargo/env.fish"  # For fish
#source $"($nu.home-path)/.cargo/env.nu"  # For nushell
# Install binstall from source :DDD
curl -L --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/cargo-bins/cargo-binstall/main/install-from-binstall-release.sh | bash

miguelraz

use core::future::Future;
use core::pin::Pin;
use core::time::Duration;
use std::future::poll_fn;
use std::task::Poll;

pub async fn try_join<'a>(
    futs: impl IntoIterator<Item = Pin<Box<dyn Future<Output = Result<(), &'a str>>>>>,
) -> Result<(), &'a str> {
    // Define the iterator outside of the loop so we can repeatedly call `futs_iter.next()` without ownership issues

miguelraz

Rust Fundamentals

Overview

• Writing Safe Rust gets you the following benefits instantly:
  • running UBSAN, ASAN, THREADSAN and RAII analysis at compile time, without the performance penalty at runtime
  • all bindings are consted by default unless they specifically opt out with let mut
  • all code you depend on is also analyzed under the same constraints by the compiler
• C++ copies variables by default, Rust transfers ownership (moves) by default. Custom types may opt into implicit Copy or explicit Clone copy semantics.

miguelraz

https://educacioncontinua.geofisica.unam.mx/index.php/sismicos-basico/

miguelraz

Cheatsheet for Julians

Why Learning Rust for Julia people in particular is special:

• We already have many features that aren't a new sale: safety and performance through a fast GC, standard memory semantics that have mechanical sympathy coupled with a powerful JIT, a modern package manager, a unit testing framework, metaprogramming, and a documentation system.
• When reaching for Rust is justified (resource constrained environments like embedded, cloud infrastructure or data bases, etc.) Julians have to go straight for FFI, erasing many of the boons of Safe Rust and dealing very quickly with unsafe code. This is topic is not the promising experience for beginners in the language.
• Julians are used to thinking about memory footprint and layout in perf-sensitive code, as well as subtyping relations - two lynchpins for understanding the ownership and borrowsing system where the role of subtyping and variance are very commonly ommitted. This topic can therefore be explained much clearer and earlie