Miguel Raz Guzmán Macedo miguelraz

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

Run julia plotter.jl in a REPL, changing data1 appropriately
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.

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.

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

Rust Speed Optimizations

From setting core_affinity to measuring L1i cache misses with good ol' perf or poking at hardware counters, if there's standard perf tooling you expect to work, it should work well in Rust too (but it might look a bit different than what you expect.)

The Rust community has a healthy suite of monitoring for hundreds of perf mentrics, see perf.rust-lang.org.

Let's look at some Rust specific flavors of what you should know.

	#!/bin/sh

	set -eu

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

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

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

	# 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 wasmtime

	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