Virtual diary for progress on all fronts


  1. Not all extern "C" functions need to be #[no_mangle].

  2. You need to tell the Rust compiler about which mod files you are importing, as well as the imports at the root of the crate:

use input::get_name;
use output::{goodbye, hello};
mod input;
mod output;
  1. Absolute paths in the current crate need crate, which means the root of the current crate. crate::treats::Treat is doable but verbose and Treat can work if used within the same module. If defined one "module up", use super::Treat

  2. When refactoring, it can get annoying to do that many changes, so you combine both:

use crate::Treats::Treat;
  1. You don't need to import DayKind to store a DayKind var - Rust only requires importing it if used by name.

  2. Rust Path Aliases can be done with pub use crate::day_kind::DayKind at the top of the file. This allows really nested mods to just work like forest::enter() after pub use the::secret::entrance::to::the::forest::enter; .

  3. pub is a module level distinction, not a crate-level distinction. If you write pub(crate) then you can make it so that other crates don't see it as public but all those inside your own crate do.

  4. Upward visibility rules for modules:

  1. Important to use the criterion::black_box so that Rust doesn't optimize the code away!

  2. #[repr(C)] lays out types as a C/C++ compiler would. #[repr(transparent)] is applicable to types with a single field only. Useful with newtype to guarantee same layout.

  3. #[repr(packed)] will layout a struct literally like how you wrote it out which is useful in low mem scenarios: embedded, sending bandwidth, etc. (with penalties for unaligned accesses, obvi.)

  4. #[repr(align(n))] is useful for avoiding false sharing.

  5. Consider that instead of fully generic code you only write non-generic outer functions and then generic helper inner functions.

  6. To be a trait object you must have a trait implementation and its vtable. Not all traits are object-safe - none of the trait's methods can be generic or use the Self type, can't have any static methods (no &Self).

  7. Orphan Rule: You can implement a trait for a type only if the trait or the type is local to your crate - this respects the property of coherence (one and only one implementation can be called by the compiler). BUT! Caveats:

  1. If keys in a HashMap must implement Hash + Eq, those are the trait bounds. String: Clone is also a trait bound (though always true) and where io::Error: From<MyError<T>>; too.

  2. Instead of HashMap<K, V, S> where the keys need a generic T and values are usize and you write

where T: Hash + Eq, S: BuildHasher + Default

you can do

where HashMap<T, usize, S>: FromIterator
  1. Higher ranked lifetime: F: for<'a> Fn(&'a T) -> &'a U.

  2. Some traits tell you you can use functions:

Hash -> hash
Clone -> clone
Debug -> fmt

etc. But some don't have an associated methods or types and are known as marker traits: Send, Sync, Copy, Sized, Unpin. All except Copy here are autotraits: compiler auto implements them for types unless something borks.

  1. Some types don't have a name you can type into code, but they exist and called existential types. Caller only (almost only) rely on the return type that implements those traits and nothing else. They also provide zero-cost type erasure.

  2. These are the same:

fn foo(s: impl ToString) == fn foo<S: ToString>(s: S)
  1. Remember the Rust API guidelines.

  2. 99% of all times your types should be Debug, Clone, Send, Sync, Default and if not, document why.

  1. Prefer blanket implementations like &T where T: Trait, &mut T where T: Trait, Box<T> where T: Trait.

  2. Wrapper types like Deref and AsRef feel like magic.

  3. frobnicate(s: impl AsRef<str>) -> impl AsRef<str> can take both a String and an &str, or dispatch to not monomorphize loads and do frobnicate(s: &dyn AsRef<str>).

  4. Sometimes, starting from concrete nd going to generic args is not necessarily backwards compatible: fn foo(v: &Vec<usize>) to fn foo(v: impl AsRef<[usize]>) because compiler can't necessarily deduce return type of foo(&iter.collect()).

  5. Use #[doc(alias = "...")] to make types and methods discoverable under other names.

  6. If your function takes in 3 booleans, your user might screw up the arg orders vs if you require explicit structs to be passed.

  7. std::marker::PhantomData<Stage> is metadata that is eliminated at compile time o.0. Use it to encode illegal states as unrepresentable:

struct Grounded;
struct Launched;

struct Rocket<Stage = Grounded> {
    stage: std::marker::PhantomData<Stage>,

impl Default for Rocket<Grounded> {}
impl Rocket<Grounded> {
    pub fn launch(self) -> Rocket<Launched> {}

impl Rocket<Launched> {
    pub fn accelerate(&mut self) {}
    pub fn decelerate(&mut self) {}

impl<Stage> Rocket<Stage> {
    pub fn color(&self) -> Color {}
    pub fn weight(&self) -> Kilograms {}

"If your function ignores a pointer arg unless a given Boolean is true, just combine the two args". You can make an enum that stands for false and no ptr and one variant for true that holds a ptr.

  1. Consider adding #[must_use].

  2. pub(crate) and pub(in path) both work! The fewer public types, the more dev freedom!

  3. Use #[non_exhaustive] to prohibit users from using implicit constructors.

  4. Sealed traits can be used only and not implemented by other crates.


  1. format!() returns a String, and is useful in match arms that return a String::from("...").

  2. eprintln! prints to STDERR, and doesn't interfere with printing to STDOUT.

  3. fgets is used to read data from a file: if (fgets(line, 100, stdin) == NULL) {}.

  4. Refactor like a boss:

int solve(char *line, int *solution)
fn solve(line: *const c_char, solution: *mut c_int) -> c_int
  1. Export the C types from libc::{c_char, c_int} and add libc to your crates.

  2. To get Rust to be called from C we need:

  1. Cargo workspaces: sometimes, you need to go to your $root/Cargo.toml and add your project name under [workspaces] so that cargo build is happy.

  2. To create a dylib with Rust, just do

crate-type = "[cdylib]"
  1. We need to let the linker know that the Rust binary inside target/ is available as target/debug/

ln -s $(pwd)/target/debug/ /lib/
  1. Remember to keep forward declarations like

int solve(char *line, int *solution);

so that the C compiler can defer compilation.

  1. Now we can compile and link vs libcalculate with -lcalculate.

gcc main.c -o bin -lcalculate

This fails! We need to add a #[no_mangle] and pub extern "C" to our solve(...) in Rust.

  1. We only need to rebuild cargo build, there's no need to recompile the C code because it's a dynamic library, neat! The library is loaded by the OS every time we run calculator.

  2. CStr is borrowed memory from C. To validate that you are not reallocating a string, check

println!("r_str.as_ptr(): {:p}, line: {:p}", r_str.as_ptr(), line);

Which means we can avoid reallocating any buffers/vecs in C when manipulated inside Rust.

  1. Move your business logic to standalone Rust functions to get the type safety benefits/reusability. Setup the big functions to bridge as needed and then factor out into Rust business logic so you don't need to keep touching the big C functions.

  2. VecDeque will give you LIFO ordering with push_front and pop_front methods.

  3. Because push only accepts i32, match.other.parse() doesn't need turbofish as compiler can reason it out.

  4. Highly recommended to provide a Display implementation for error types.

  5. &str usage avoids reallocation :D.

  6. To find executables, do:

find objs -executable -type f
  1. You have to sometimes generate metadata for stuff like types called ngx_***. Since you don't always get to write the C binding, you can use tools, like the build script.

  2. You need use std::io::Write; to use file.write_all(...).

  3. To run a command with a certain env var, do env GREET_LANG="es" cargo run.

  4. match langugae.as_ref() is useful to stay with &strs.

  5. Ughhhhhhh Rust stringy metaprogramminggggggg

let rust_code = format!("fn greet() {{
    println!(\"{}\"); }}", greeting);
  1. Genius idea: leverage build scripts AND bindgen and have your C API written out for you :D. You can include it under Cargo.toml/[build-dependencies] as bindgen = "0.56.0".

  2. You need One Big Header file that contains all the other ones, sorta like wrapper.h

#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_http.h>

and then a Rust

fn main() {
    let nginx_dir = "nginx-1.19.3";
    let bindings = bindgen::builder()
            format!("-I{}/src/core", nginx_dir),
            format!("-I{}/src/event", nginx_dir),
  1. The file is 30k long, but you want to place it in the out directory, which you can know where it is via env vars set by cargo, or via

let out_dir = std::env::var("OUT_DIR").unwrap();

    .write_to_file(format!("{}/", out_dir))
    .expect("unable to write bindings");
  1. include!("") works like the C/C++ #include <vector>

  2. env!("OUT_DIR") can check env vars ar compile time, errs if not provided.

  3. concat!(env!("OUT_DIR"), "/") to join the paths at compile time.

  4. Your scripts will probs have include!(concat!(env!("OUT_DIR"), "/"));

  5. let request = &*r;. Is called reborrowing which converts a pointer to a Rust reference. You need to check that

  1. Strategy for buffer reuses:

  1. You can have many &str made from substrings of String, since &str is just a pointer and a length (read-only, view).

  2. end.offset_from(start) as usize needs a cast because start can be greater than end.

  3. Pull from local creates with

calculate = {path = "../calculate"}
  1. Rust to Rust dylibs need rlib in addition to cdylib.


  1. usize is in hexadecimal.

  2. The function type of fn noop() {} is *const fn() -> (), aka "a const pointer to a function that takes no args and returns unit". unit is Rust's "nothingness".

  3. If you are in the middle of a call stack and can't unwinde, you can do nonlocal control transfer, which can be done via setjmp and longjmp. setjmp sends a label/marker location and longjmp jumps back to a previously marked location.

  4. Intrinsic functions are functions made available by the compiler, not by the PL.

  5. How to treat

const JMP_BUF_WIDTH: usize = mem::size_of::<usize>() * 8;
type jmp_buf = [i8; JMP_BUF_WIDTH];
static mut RETURN_HERE: jmp_buf = [0; JMP_BUF_WIDTH];

RETURN_HERE as a pointer?

unsafe { &RETURN_HERE as *const i8 as *mut i8}
  1. There's mutable pointers *mut and immutable pointers *const.


  1. For file handling, check out OpenOptions:

let fs = OpenOptions::new()
            .write(true) // is overridden by append

Then you can

let hello = PathBuf::from("/tmp/hello.txt");
  1. Creating a lib crate allows you to create different binary executables from the same without reinventing it.

  2. [[bin]] in your Cargo.toml allows you to specify multiple binary targets

  3. USAGE can be setup to conditionally compile on different targets:

use libactionkv::ActionKV;

#[cfg(target_os = "windows")]
const USAGE: &str = "
    akv_mem.exe FILE get KEY
    akv_mem.exe FILE delete KEY

#[cfg(not(target_os = "windows"))]
const USAGE: &str ="
    akv_mem FILE get KEY
    akv_mem FILE delete KEY
  1. debug_asssert_eq!(data.len(), data_len as usize); these are disabled during --release builds, but enabled during debug builds.

  2. Indexing notation is supported via the Index trait.

  3. Trait objects appear in 3 forms: &dyn Trait, &mut dyn Trait, Box<dyn Trait>. Box<dyn Trait> is owned, the other 2 are not. Trait objects add polymorphism - they use less disk space for some small runtime overhead.

  4. Dynamic traits look a bit like this:

fn main() {
    let mut it = Thing::Sword;
    let d = Dwarf {};
    let e = Elf {};
    let h = Human {};

    let party: Vec<&dyn Enchanter> = vec![&e, &h, &d];
    let spellcaster = party.choose(&mut rand::thread_rng()).unwrap();

    spellcaster.enchant(&mut it);
  1. Trait objects are a form of type erasure - compiler does not have access to the original type during the call to enchant(). Trait are mostly used for

    • heterogenous collection

    • returning a value (functions can return multiple concrete types with trait objects)

    • supporting dynamic dispatch

  2. ? is syntactic sugar for try!: Ok(value) => value, Err(err) => returns early and attempts to convert err to error type defined in the calling function.

  3. Remember the newtype pattern for aliasing without extra overhead:

struct MacAddress([u8; 6]);
  1. If your PL is expression based, control flow structures also return values. This is a good tool for implementing state machines:

enum HttpState {

loop {
    state = match state {
        HttpState::Connect if !socket.is_active() => {...; HttpState::Request}
        HttpState::Request if socket.may_send() => {...; HttpState::Response;}
        HttpState::Response if socket.can_recv() => {...; HttpState::Response}
        HttpState::Response if !socket.may_recv() => {...; break;}
        _ => state,
  1. struct Clock; is a Zero Sized Type and does not occupy any memory in the resulting application and is purely a compile-time construct.

  2. Anon funcs in Rust can be seen as let add = |a, b| {a + b};. Anon funcs can't be defined in global scope.

  3. To spawn a thread, use std::thread::spawn(). It takes no args, and thus you see this syntax: thread::spawn(|| {...}). If you want to use vars in the parent scope, that's called a capture. If you want to move ownership, you need to specify it with thread::spawn(move || {...}). You NEED move if you want to use capture variables.

  4. Guidelines for using captures:

    • reduce friction at compile time, use Copy

    • Values starting from outer scopes may need static lifetimes

    • Spawned subthreads can outlive their parents -> that's why you need to move ownership to subthreads.

  5. To regain mutable access on each iteration, don't do this:

for handle in &handlers {
// but rather this
while let Some(handle) = handlers.pop() {

because it gains mutable access on each iteration, until the handlers vector is empty - but removing the ampersand also works :

for handle in handlers {
  1. When doing a yield

while start.elapsed() < pause {

thread::yield_now() is a signal to the OS that the current thread should be unscheduled. Bad: You don't know if you actually wait for 20ms. An alternative: bypass the OS and go through to CPU directly via std::sync::atomic::spin_loop_hint().spin_loop_hint() turns off functionality and saves power usage. Bad: your cpu might not have that capability.

  1. To get rid of the shared variable here:

let handle = thread::spawn(|| {
    let start = time::Instant::now();
    let duration = time::Duration::from_millis(20); // THIS DOESN'T NEED EVERY THREAD TO BE CREATED
    while start.elapse() < pause {

where you can instead use the move

use std::{thread, time};

fn main() {
    let pause = time::Duration::from_millis(20);
    let handle1 = thread::spawn(move || {
    let handle2 = thread::spawn(move || {

  1. Closures and funcs are different. Closures are anon structs that implement std::ops::FnOnce trait and maybe std::ops::Fn and std::ops::FnMut. Those structs are invisible from source code but contain the variables of the closure inside of them

  2. Instead of the for byte in input.bytes() {let step = match byte {}; steps.push(step);}, try input.bytes().map(|byte| {}).collect();.

  3. Translating into Rayon (where a sequence of Forward(isize) {TurnLeft|TurnRight} == Vec<Operation> is collected):

use rayon::prelude::*;

fn parse(input:&str) -> Vec<Operation> {
        .map(|byte| match byte {
            b'0' => Home,
            b'1'..=b'9' => {
                let distance = (byte - 0x30) as isize;
                Forward(distance * (HEIGHT/10))
            b'a' | b'b' | b'c' => TurnLeft,
            b'd' | b'e' | b'f' => TurnRight,
            _ => Noop(*byte),
  1. But what happens when you don't have a tidy iteration you can throw Rayon at? Consider a thread pool and a task queue.

  1. rustup target list gives you a list of targets that Rust can compile to.

  2. #[repr(u8)] Instructs the compiler to use a single byte to represent the values.

  3. kill -l to list all signals supported by the OS. SIGSTOP and then SIGCONT can be used to stop and resume a running program!

  4. To make a global in Rust, do:

static mut SHUT_DOWN: bool = false; // to change do: unsafe {SHUT_DOWN = true;}
  1. To register a signal handler:

use libc::{SIGTERM, SIGUSR1};
fn main () {
    register_signal_handlers(); // Must be done early
fn register_signal_handlers() {
    unsafe {
        libc::signal(SIGTERM, handle_sigterm as usize); // fn must be passed as func pointer to C
        libc::signal(SIGUSR1, handle_sigterm as usize);
fn handle_sigterm(_signal: i32) {
    register_signal_handlers(); // again early, try not to miss any
    unsafe { SHUT_DOWN = true; }
  1. static appears in a single location in memory. const can be duplicated in locations where they are accessed. 502.


  1. The big 4:

    • use refs

    • clone the values

    • reduce the need for long lifetimes

    • clever type wrappers

  2. Clone lets you .clone(), Copy is implicit and lets you copy instead of move (must be on primitive types).

  3. Rc<T> is very useful when cloning would be very expensive.

  4. Rc<T> does not allow mutation, Rc<RefCell<T>> does.

  5. In multithreaded code, Rc<T> -> Arc<T> and Rc<RefCell<T>> -> Arc<Mutex<T>>.

  6. println!("{:032b}", x); left pad x with 32 0s

  7. Rust numbers have methods like 1.2_f32.ceil().

  8. Cow means Copy on Write and are useful when someone gives you a buffer.

  9. *mut T and *const T are basically the same. &mut T and &T compile down to pointers.

  10. If you want to accept both &str and String, you can try

fn is_strong<T: AsRef<str>>(password: T) -> bool {
    password.as_ref().len() > 5 {...}
  1. Dynamically sized types (DSTs) don't change sizes, but are assigned a size at runtime (like slices [T]).

  2. while let Ok(_) {...} loop until f.read_exact(&mut buffer) returns an Err.

  3. For commandline args use std::env::args() with nth().

  4. expect("foo") is a nicer version of unwrap().

  5. instead of

pub fn hamming0(a: &str, b: &str) -> i32 {
    .map(|(a, b)| a != b)
    .fold(0, |acc, i| { acc + i as i32})

I can do

pub fn hamming0(a: &str, b: &str) -> i32 {
    zip(a, b)
        .filter(|(a, b)| a != b)

and with usize instead of i32 you can also get some speedups.


  1. Ryan James Spencer kindly shared his article about Magnifying glasses for Rust.

  2. Instead of stringly typed data, go for enums.

  3. traits are close to interfaces/contracts/type classes.

impl trait Read {
    fn read(self: &Self, save_to: &mut Vec<u8>) -> Result<usize, String> // You need a func signature

impl Read for File {}
  1. //! is used to document the thing that was just read by tehe compiler.

  2. cargo doc --no-deps can speed up doc generation by quite a while.

  3. There's a difference between a variable's lifetime and its scope. A variable can be dropped after it is consumed by a function

and not used, but then Rust can refuse to compile if you do try to use it.

  1. If I define functions like fn foo(x: i32) -> Foo, then I can let a = 3; let a = foo(a); and have the ownership passed because of the return type.


  1. If I want to filter all BinaryBuilder platforms to only Linux, I can do

filter!(Sys.islinux(), supported_platforms())

instead of the platforms = [ ... ] dance.

  1. When using, remember that

use std::simd::*;

Is what let's your code compile and that you don't need a main(), just pub fn and you're on your merry way.

  1. Finally, here's the dot_product_scalar_0 in Rust Godbolt, with a sweet view and llvm-mca to boot.

Here's the SIMD Rust godbolt comparisons and the Rust snippet that worked

use std::simd::*;

// A lot of knowledgeable use of SIMD comes from knowing specific instructions that are
// available - let's try to use the `mul_add` instruction, which is the fused-multiply-add we were looking for.
pub unsafe fn dot_prod_simd_2(a: &[f32], b: &[f32]) -> f32 {
    assert_eq!(a.len(), b.len());
    // TODO handle remainder when a.len() % 4 != 0
    let mut res = f32x4::splat(0.0);
        .map(|&a| f32x4::from_array(a))
        .zip(b.array_chunks::<4>().map(|&b| f32x4::from_array(b)))
        .for_each(|(a, b)| {
            res = a.mul_add(b, res);

Notice the #[target_feature(enable="avx2")], the pub unsafe

  1. fn dead_end() -> !{} the ! is for funcs that crash and is known as the Never type.


  1. All of Rust operators are defined within traits. Ach so...

  1. String is to Vec<u8> as str is to [u8].

  2. Array sizes are known at compile time [T; 4] - just a homogenous container.

Slices don't have a known size at compile time [T], so they have are usually used as &[T], and are dynamically sized (but don't contract or expand at runtime!).

  1. The term view comes from databases where a read-only view is way faster without needing to copy. However, since Rust wants to know sizes of everything in your program, but slices don't know that, you need a & reference.

Vectors though, those are growable!

  1. You can ref a whole tuple:

for &(i, line) in x.iter() { ... }
  1. rustup doc opens up the stdlib docs.


  1. std::ops::Add is the trait, std::ops::Add::add is the operation. Thus, this snippet

let mut sum = a
        .map(|&a| f32x4::from_array(a))
        .zip(b.array_chunks::<4>().map(|&b| f32x4::from_array(b)))
        .map(|(a, b)| a * b)
        .fold(f32x4::splat(0.0), std::ops::Add::add) // Note it's not `std::ops::Add`


  1. When setting up rust.code-workspaces, you can ignore them if you do git config --global core.excludesFile ~/.gitignore and then add


to the file


  1. A neat chunks example:

pub fn of_rna(&self, rna: &str) -> Option<Vec<&'a str>> {
            .map(|seq| self.name_for(seq.unwrap()))
            .take_while(|&codon| codon != Some(STOP))
            .collect::<Option<Vec<&'a str>>()
  1. stack.pop().and_then() is very useful.

  2. This was also a neat trick:

for word in note.iter() {
        *words.entry(word).or_insert(0) += 1;
  1. Another useful pattern to create a HashSet:

pub fn is_pangram(sentence: &str) -> bool {
    let all:  HashSet<char> = HashSet::from_iter("abcdefghijklmnopqrstuvwxyz".chars());
    let used: HashSet<char> = HashSet::from_iter(sentence.to_lowercase().chars());
  1. This is just neat syntactic sugar:

//impl<T: PartialEq + Add<Output = T> + Sub + PartialOrd + Default> Triangle<T> {
impl<T> Triangle<T> 
    where T: PartialEq + Add + Sub + PartialOrd + Default {
  1. This is a useful pattern:

    .fold(HashMap::new(), |mut counts, word| {


  1. Brushing up on some Rust via exercism and hansrodtang has some nifty code for an isogram:

use std::collections::HashSet;
pub fn check(candidate: &str) -> bool {
    let mut set = HashSet::new();
    .filter(|c| c.is_alphabetic())
    .all(|c| set.insert(c))


  1. PartialExecuter.jl Will interpret code and then kill it as an LLVM pass. VERY juicy Julia opportunities per method tables :D


  1. Break Dancing: Low overhead, ARchiteture nuetral software branch tracing


  1. I found these cargo shortcuts useful from the Cargo book:

rr = "run --release"
ti = "test -- --ignored"
tq = "test -- --test --quiet --test-threads 8"
tt = "test -- --test-threads 8 --test"

These cut down on the crate testing time.

  1. BQN lists are written with the ligature character:

⟨ + ´ ∘ × ⟩

    +‿´‿∘‿×  ≡  ⟨+,´,∘,×⟩
  1. BQN exported names use .

  2. Trainsssssssss.


  1. scanl in Julia is accumulate. To solve this Increasing Array problem I would write

xs = [1,3,5,1,7]
sol(xs) = accumulate(max, xs) - xs |> sum

and in BQN

Sol ← +´∘(⌈`-⊢) # Credit to Asher Mancinelli


  1. Bodo Scholz Tensor comprehensions in SaC.


  1. Makie has a few tricks up its sleeve:

  1. Pro-tip: When trying to figure out a package:

# eg for Makie, I would have found this useful before wasting a few hours...
export Observable, Observable, lift, map_once, to_value, on, onany, @lift, off, connect!
  1. wtf is this syntax yo

function updater(i, f::Flatten)
    function (val)


function (YOLO)
    YOLO + 1


  1. content is useful for not indexing into the contents(f[1,1]) figure in Makie.


  1. Pluto autoreload trick:

using Pluton: run
run(; auto_relaod_from_file=true);


  1. To change the Julia prompt:

Base.active_repl.interface.modes[1].prompt = "julia 😷>"

credit to rickhg12hs.

  1. Damn, today was really cool. Sounds like Nautilus.jl project has some real legs. I got toggle buttons working but there's still so much to build.

Also, I blocked twitter and social media on my phone. Time to hunker down. Also this number is a good sign. I've started to do a small number of impossible things before breakfast... I kinda like this streak.

  1. Joined Lemmster's TLA+ workshop last minute. Maybe I should try it out for realsies sometime.


  1. Time to actually learn the freakin' commands to the Julia REPL:


  1. Jeebus I spent way too much time on Franklin blog today.

  2. This DataFrames.jl worksheet is super userful.


  1. Why meshgrid is inefficient and what the Julia anternative is: 2D array copmrehension

inflate(f, xs, ys) = [f(x,y) for x in xs, y in ys]

# call version 1: with a named function
inflate(foo, xs, ys) 

# call version 2: anonymous function syntax
inflate((x,y) -> sin(x) + 2 * y^2 / cos(x,y), xs, ys)

# call version 3: with a do block
inflate(xs, ys) do x, y
    sin(x) + 2 * y^2 / cos(x,y)


  1. GPU call with Julian. We can optimize the ffmpeg pipeline to reduce the critical path. We were doing:

When we can do instead

  1. Tips for job interviews:

When was the lat time you promoted someone on your team? Why did the last person leave? How do you nurture the wellbeing of people under a challenging environemnt? When was the last time you supported a direct report's growth, even if it meant leaving the company? Can I speak to some latino/women who have held this role before?


  1. Got this oneliner for downloading from JuliaCon talk title urllink.mp4:

miguelraz@cyclops ~/J/src> bat posters.csv | awk '{print $NF}' | rg "mp4" |xargs  wget -v

And it would be parallel with a xargs -n 1 -P 8 filename to download with 8 cores simultaneously.

  1. Rescued the ffmpeg script for processing JuliaCon videos. Should shape into a nice package. Need to recruit CI wizards + a cron job so that it can be kicked on demand for uploads.


  1. Let's help Simeon out with that globals PR. Maybe also the freakin' blog post. And then the LLVM13->LLVM14 upgrade.


  1. FUTHARK BABY! Futhark is a Haskell-like, ML, pure functional language that is super parallel, compiles to GPUs and has a REPL! It's just amazing


  1. Limited Direct Execution - setup all the stuff for a program, run it's main(), free mem and process from task list. But how do you know it didn't do bad stuff, and how can you time share with that? The OS has facilities that can limit the running programs, otherwise it would be just another library.

  2. To go from user mode to kernel mode you need to use a system call, which looks like a normal C function. These functions use a trap instruction,and when done a return from trap instruction (while de escalating kernel privileges).

A bit of state from program counters, flags, registers and trap will be pushed into a per-process kernel stack, and popped when execution resumes. To know which code to run, the kernel sets up a trap table at boot time, which has code for when a keyboard interrupt or disk interrupt is sent, etc. System calls must be made via a service number to increase security. Also, regaining control of the CPU by the OS is tricky if there was a process running on it. You can cooperate and trust the process will make system calls eventually (and then do your OS things) or take over. You can use a timer interrupt that will disrupt the machine every few milliseconds and the OS interrupt handler takes over. This timer can also be TURNED_OFF! OS can also decide to switch... which is called a context switch.

  1. To context switch, save a few registers, pop a few registers, ^-_-^.

  2. Remember about setting core affinity - if you want to measure context switching timings, make sure it isn't switching across threads.


  1. Process API:

Process states: * Running, Ready, Blocked (or zombie, to check that children exited succesfully by the parent) The Process List/task list will have a struct to keep track of all the running programs in the system. Also called a Process Control Block or process descriptor. (It's just a struct).

  1. ./ was a trip:

-intro (master)> ./ -l 3:0,5:100,5:100,5:100 -S SWITCH_ON_END -I IO_RUN_LATER -c -p -L 5
Time        PID: 0        PID: 1        PID: 2        PID: 3           CPU           IOs
  1         RUN:io         READY         READY         READY             1          
  2        WAITING         READY         READY         READY                           1
  3        WAITING         READY         READY         READY                           1
  4        WAITING         READY         READY         READY                           1
  5        WAITING         READY         READY         READY                           1
  6        WAITING         READY         READY         READY                           1
  7*   RUN:io_done         READY         READY         READY             1          
  8         RUN:io         READY         READY         READY             1          
  9        WAITING         READY         READY         READY                           1
 10        WAITING         READY         READY         READY                           1
 11        WAITING         READY         READY         READY                           1
 12        WAITING         READY         READY         READY                           1
 13        WAITING         READY         READY         READY                           1
 14*   RUN:io_done         READY         READY         READY             1          
 15         RUN:io         READY         READY         READY             1          
 16        WAITING         READY         READY         READY                           1
 17        WAITING         READY         READY         READY                           1
 18        WAITING         READY         READY         READY                           1
 19        WAITING         READY         READY         READY                           1
 20        WAITING         READY         READY         READY                           1
 21*   RUN:io_done         READY         READY         READY             1          
 22           DONE       RUN:cpu         READY         READY             1          
 23           DONE       RUN:cpu         READY         READY             1          
 24           DONE       RUN:cpu         READY         READY             1          
 25           DONE       RUN:cpu         READY         READY             1          
 26           DONE       RUN:cpu         READY         READY             1          
 27           DONE          DONE       RUN:cpu         READY             1          
 28           DONE          DONE       RUN:cpu         READY             1          
 29           DONE          DONE       RUN:cpu         READY             1          
 30           DONE          DONE       RUN:cpu         READY             1          
 31           DONE          DONE       RUN:cpu         READY             1          
 32           DONE          DONE          DONE       RUN:cpu             1          
 33           DONE          DONE          DONE       RUN:cpu             1          
 34           DONE          DONE          DONE       RUN:cpu             1          
 35           DONE          DONE          DONE       RUN:cpu             1          
 36           DONE          DONE          DONE       RUN:cpu             1          

Stats: Total Time 36
Stats: CPU Busy 21 (58.33%)
Stats: IO Busy  15 (41.67%)
  1. wait waits on a PID, fork makes a copy except for the PID, exec runs a different program than the calling program. There are several variatns of exec.

  2. Colorful man pages with: export MANPAGER="less -R --use-color -Dd+r -Du+b"

  3. If you want to use exec, you hand craft a vector for

char *myargs[3];
myargs[0] = strdup("wc");
myargs[1] = strdup("p3.c");
myargs[2] = NULL; // marks end of array
execvp(myargs[0], myargs);
printf("This never gets printed");

This literally transforms your program into the new one you are calling. Succesful calls to exec never return o.0.

  1. Huh, killall seems like a useful thing to know...

  2. List available man pages with man -f ls


person *myperson = (person *) malloc(sizeof(person));

then you've typecasted it.




  1. Found thise great code review checklists:

  1. CLANGD IS NOT INCLUDED IN A CLANG INSTALLATION. Just install the VSCode IDE thing for christ sake's

  2. Holy crap - modules in cpp20 can help cut down bloat size IMMENSELY: this is like 5 orders of magnitude for a "hello world" program.

clang++ -std=c++20 -stdlib=libc++ -E | wc -c # Here the -E makes clang only spit out the preprocessor stuff. 1956614


clang++ -std=c++20 -stdlib=libc++ -fmodules -fbuiltin-module-map -E | wc -c 239


  1. New PATCH 1.7! and contained this lil' nugget:

myreal((; re)::Complex) = re
myreal(2 + 3im) == 2


  1. Jean Yang kindly suggested Write you a Scheme in 48 hours as a stream with a timer, it sounds RAD!

  2. This Haskell setup video looks fantastic by using


  1. TODO: Make a BinaryBuilder.jl recipe for CReduce, get some fuzzing going in Julia.


  1. In LLVM speak,Modules > Functions > BasicBlock > Instruction, and everything inherits from the Value class.

  2. Useful snippet:

for (auto& B : F) {
  for (auto& I : B) {
    if (auto* op = dyn_cast<BinaryOperator>(&I)) {
      // Insert at the point where the instruction `op` appears.
      IRBuilder<> builder(op);

      // Make a multiply with the same operands as `op`.
      Value* lhs = op->getOperand(0);
      Value* rhs = op->getOperand(1);
      Value* mul = builder.CreateMul(lhs, rhs);

      // Everywhere the old instruction was used as an operand, use our
      // new multiply instruction instead.
      for (auto& U : op->uses()) { // NICE
        User* user = U.getUser();  // A User is anything with operands.
        user->setOperand(U.getOperandNo(), mul);

      // We modified the code.
      return true;


  1. When reading LLVM source code, I need to find the name of many things (like using your IDE for tooltip hovering/documentation). ctags can help with that.


  1. Phew, moving out was a hassle.


  1. Downloaded a code with CVS today.


  1. Fortran coarrays use tile_indices, this_image(), num_images() and are run with cafrun -n 4 ./test.


  1. FORTRAN learnigns:

integer function sum(a, b) result(res)
    integer, intent(in) :: a, b
    res = a + b
end function sum
integer elemental function sum(a,b)
    integer, intent(in) :: a, b
    integer, intent(out) :: res
    res = a + b
end function sum
subroutine add(a, b, res, debug)
    integer, intent(in) :: a, b
    integer, intent(out) :: res
    logical, intent(in), optional :: debug
    if (present(debug)) then
        if (debug) then
        ! ...
    end if
    ! ...
end subroutine add

! used with 
call add(3, 5, res, .true.) ! or call add(3, 5, res, debug=.true.)
program opts
    use iso_fortran_env
    implicit none
    print *, 'Compiler version: ', compiler_version()
    print *, 'Compiler options: ', compiler_options()
end opts
module mod_diff

end module mod_diff
integer :: r(5)
r = [1,2,3,4,5]
program testopenmp
  use omp_lib
  implicit none

  integer :: nthreads

  nthreads = -1
  !$ nthreads = omp_get_num_threads()
  print *, "nthreads = ", nthreads
end program

and remember to gfortran testopenmp.f90 -o openmp -fopenmp

integer :: a(5) = [1,2,3,4,5]
! and these
integer :: a(5)
a = [1,2,3,4,5]

are equivalent.

do i = 1, 100
    a(i) = i ! integer, allocatable :: a(:)
end do
integer, allocatable :: a(:)
a = [integer ::]
a = [a, 1] ! a = [1]
a = [a, 2] ! a = [1, 2]
a = [a, 2* a] ! a = [1, 2, 2, 4]

arrays are autodeallocated on scope drop.

! reversing an array
pure function reverse(x)
    real, intent(in) :: x(:)
    real :: reverse(size(x))
    reverse = x(size(x):1:-1)
end function reverse


  1. TODO Visualize the Julia repo with this tool


  1. Writing a cover letter... godspeed to me.


Link dump time!

  1. Linux perf guide.

  2. Go fix some DiffEq compile times yo

  3. Semver autodetection in Rust

  4. Plz someone help out Keno with Cxx.jl

  5. Amos Rust futures post


  1. Jon Sterling writes about a metalanguage for multi phase modularity here.

  2. Consider using TimeWarriorlinked here.

  3. Dr. Devon Price has an amazing article criticizing the biological understanding of mental health:.


  1. Parallel Julia priorites from the State of Julia 2021 talk:

Thread safety: DistributedOptimize scheduler
thread safety: package loadingParallel mark/sweep
Memory modelType inference of fetch(::Task)
Finalizer threadBetter for loop and reduce
Interactive threadsBLAS integration
GC state transitions in codegenTAPIR Integration
  1. Compiler priorities from State of Julia 2021:

Latency related:

System images and other build artifacts:

Array optimizations

GC performance work

Compiler extensibility

  1. ghostscript can be used for batch pdf processing.


  1. All the JuliaCon posters are uploaded! 🎉 I heard a lot of interesting proposals from people from NZ, photolithography people and many others... posters are fun! Life's lookin' good!


  1. Extract 20 seconds without re-encoding:

ffmpeg -ss 00:01:30.000 -i YOUR_VIDEO.mp4 -t 00:00:20.000 -c copy YOUR_EXTRACTED_VIDEO.mp4
  1. Tuning options in ffmpeg:

film – use for high quality movie content;
animation – good for cartoons;
grain – preserves the grain structure in old, grainy film material;stillimage – good for slideshow-like content;
fastdecode – allows faster decoding by disabling certain filters;
zerolatency – good for fast encoding and low-latency streaming;
psnr – only used for codec development;
ssim – only used for codec development;
ffmpeg -i -c:v h264 -crf 23 -tune film your_output.mp4
  1. You can use 2 pass encoding for targeting a specific output file size, but not care so much about output quality from frame to frame.

  2. For an output that is roughly 'visually lossless' but not technically and waaaay less file size, just use -crf 17 or 18.

  3. You can also constrain the maximum bitrate (useful for streaming!)

ffmpet -i input.mp4 -c:v h264 -crf 23 -maxrate 1M -bufsize 2M output.mp4
  1. Recommend adding a faststart flag to your video so that it begins playing faster (recommended by YouTube).

ffmpeg -i input.mp4 -c:v h264 -crf 23 -maxrate 1M -bufsize 2M -movflags +faststart output.mp4
  1. If you want to produce 1080p and above, h265 offers great savings in bitrates/file size (ntoe: needs to be built with --enable-gpl --enable-libx265).

ffmpeg -i input -c:v libx265 -crf 28 -c:a aac -b:a 128k output.mp4
  1. h266 video codec:

Can deal with 4k/8k and 360 degree video!

  1. VP8 videos: Supposed to be web standard.

  2. OF COURSE Google made vp9 in direct competition of h265, you need libvpx-vp9.

  3. OH LORD Youtube recommends it's own ffmpeg settings!!!

  4. AV1 video - SD and HD under bandwidth constrained networks.

  5. Netflix codedc is SVT-AV1 and they have blog posts explaining it, as well as github repos!

  6. AV1AN exists becuase AV1/VP9/VP8 are not easily multithreaded ... 😕

  7. RTMP is for "Real time Messaging Protocol" and is the de facto standard for all live videos in FB, Insta, YT, Twitch, Twitter, Periscope etc. Streaming pre recorded video to live can be done in at least 2 ways:

-f flv rtmp://[YOUR_STREAM_KEY]
#: this will instruct FFMPEG to output everything into the required FLV format to the YouTube RTMP server

for i in *.mov; do ffmpeg -i "$i" -c:v libx264 -profile:v high -level:v 4.1 -preset veryfast -b:v 3000k -maxrate 3000k -bufsize 6000k -pix_fmt yuv420p -r 25 -g 50 -keyint_min 50 -sc_threshold 0 -c:a aac -b:a 128k -ac 2 -ar 44100 "${i%.*}.mp4"; done

"The above example script will pre-process every .movfile contained in the directory, in line with the YouTube's requirements for streaming a Full-HD 1080p at 25FPS."


  1. tmux can be used to keep persistent sessions on ssh, so mosh is not necessarily needed.

The way to do this (Credit to Danny Sharp) is do the ssh inside a tmux session and then tmux ls to see which sessions you have made and then tmux attach-session -t 3 to connect to session 3. This is a smart way of checking in on long running compute jobs.

  1. From FFMPEG Zero to Hero:

BITRATE: Bitrate or data rate is the amount of data per
second in the encoded video file, usually expressed in kilobits per second (kbps)
or megabits per second (Mbps).  The bitrate measurement is also applied to audio files.
An Mp3 file, for example, can reach a maximum bitrate of 320 kilobit per second,
while a standard CD (non-compressed) audio track can have up to 1.411 kilobit per 
second. A typical compressed h264 video in Full-HD has a bitrate 
in the range of 3.000 - 6.000 kbps, while a 4k video can reach
a bitrate value up to 51.000 kbps.  A non-compressed video format,
such as the Apple ProRes format in 4K resolution, can reach a bitrate of 253.900 kbps and higher.
  1. FFMPEG can read and write to basically any format under the sun, and has been designed by the MPEG:

Moving Pictures Expert Group.


  1. To run code with the interpreter, use julia --compile=no.

  2. Buffy for JOSS submissions.

  3. Crafting Interpreters for speeding up the Debugger and such.

  4. Advance bash scripting guide

  5. Proceedings Bot

  6. Toby Driscoll online book


  1. Link dump:


  1. To clean up a video with ffmpeg, do:

ffmpeg -i -af "highpass=f=300, lowpass=f=3000, afftdn" -c:v copy

This applies a FFT filter, with a highpass and lowpass of 300Hz and 3000Hz

  1. This is an awesome thread on LLVM resources

And WOW is this super list thorough LLVM Program Analysis resources


  1. sortperm is sorta slow - up for grabs!

  2. Setup donation links to JuliaCon

  3. Submit to the procceedings...

  4. FFMPEG is HUGE ! Here's what I needed to concat 2 videos together:

ffmpeg -i "concat:input1.ts|input2.ts" -c copy output.ts

Now I need to apply that to every *.mov/mp4/mkv video in the folder and then I have a lot of processed videos. Perhaps I should also dump that info into a CSV file...


  1. Federico Simonetta asks:

Dummy question: if I have T=Vector{Int32}, I can get the inner type using eltype. How can I get the outer type? (i.e. Vector so that I can create a new Vector but using a different inner type?)

Which I think Erik Schnetter wanted since a [long time ago.] There's now a Base method for this:

Base.typename(T).wrapper # credit to Jakob Nissen

But name is being bikeshed currently.

If you want to use CustomType{Matrix{Float32}}, Rackauckas says that

Base.@pure __parameterless_type(T) = Base.typename(T).wrapper

can be used, instead of SciMLBase.parameterless_type(T).

Matt Bauman is convinced it's a footgun, and we should just stick to using similar(x, AnotherType) instead.

  1. Conor Hoekstra nerdsniped me into learning some APL - here's my attempt for printing 'Even' or 'Odd' depending on a summation

EvenOrOdd←{(1+2|(+/⍵))⌷ 'Even' 'Odd'}
      EvenOrOdd 1
      EvenOrOdd 1 1

There's oodles more to learn here and here.

  1. Right, the Chen Long courses exist. And the Barba CFD Python course. And the Leveque book... sigh.



Depends on what subgenres you like! Besides the Jordan Peele horror you mentioned, 
 I always recommend 
 A Girl Walks Home Alone At Night,
 Creep and Creep 2, 
 Blackcoat’s Daughter, 
 It Comes At Night, 
 REC (the Spanish original)...
  The Ritual and Midsomma




  1. Loop invariants have 3 steps:

while E:


  1. TLA+ Loop invariants here we go...


  1. Leiserson course is level 1, Design and analysis of algorithms is level 2, Jelani course is level 3.

  2. Nancy Lynch distributed algorithms course

  3. Ooooh Self adjusting binary search trees

  4. MITOCW: Matrix Methods in Data Analysis, Signal Processing and Machine Learning

  5. Doom config by Fausto Marques for julia... should read it sometime...


  1. Asesorias online de la fac...

  2. LLVM has options to investigate base language code coverage with llvm-profdata and llvm-cov tooling.

  3. Reading atomic habits - this blog works well as a braindump, but it would be a good idea to include reflections and reviews on proposed monthly and weekly goals on maths, physics, computing projects, physical activity and life.


  1. God I want to tkae the Algorithm Engineering 2021 course so bad... or at least translate it.

  2. Mosè posted about Reproducible build academic guidelines.

  3. RISC V course!


  1. Viendo el tutorial de Ploomber de Eduardo Blancas - Deberías cachear el pipeline de datos de tal manera que si afectas un nodo del DAG computacional, el resto no necesiten recalcularse. Technically same mechanism as cached parallel tests.

  2. Julia 1.7 has implicit multiplication of radicals! xSQ3y works! Also (; a, b) = x can destructure x.

  3. MPI Formal TLA+ spec! + formal lab link

  4. Practical Specification course!.

  5. Safety - something bad never happens. Liveness - something initiated/enabled eventually terminates.


  1. Julia macros for beginners: esc means "treat this variable like a variable the user has written themselves." AKA interpolating within the macro only gives you variables local to the macro's module, escaping treats it as a user variable.

julia> module m
           export fill
           macro fill(exp, sizes...)
               iterator_expressions = map(sizes) do s
                       quote 1:$(esc(s)) end

julia> Main.m.@fill(rand(3), 5)
5-element Vector{Vector{Float64}}:
 [0.7935931741613422, 0.009320195062872738, 0.586287521697819]
 [0.5090383286377023, 0.8500671589320301, 0.023782332100151793]
 [0.31575252460961667, 0.30058298960206287, 0.2873940760156002]
 [0.07225330666900165, 0.22506420288160234, 0.225626098738561]
 [0.5753508713492259, 0.37821541454348995, 0.3146472409806831]
  1. Dr. Takafumi Arakaki has some good recommendations on globals - mark them inside functions!

julia> global a = 1;

julia> good() = global a += 1;

julia> bad() = a += 1;

julia> good()

julia> bad()
ERROR: UndefVarError: a not defined
  1. Try to also avoid this idiom:

function consumer()
    id = threadid()
    report = 0
    println("I'm consumer $(threadid())")

Instead try doing

for id in 1:numProducers
    @spawn producer(id)

He also recommends that "while debugging, you'd probably wan tto show the error from producers and consumers like this"

@spawn try
catch err
    @error "Unexpected error from a producer" exception = (err, catch_backtrace())
  1. Neat trick - don't use while true loops in the beginning 😅 . Use for _ in 1:10_000 to check if the threads are even alive.


  1. I read Lamports Logical Clocks paper today. I learned a couple of things.

  1. Now reading Paxos Paper.

  1. CHOOSE is nondeterministic - if it chose 38 today, it will choose that again next week. You never need to write x' = CHOOSE i \in 1..9 : TRUE, just use x' \in 1..99. Use CHOOSE only when there's exactly 1 v in S satisfying formula P, like in the definition of Maximum(s)

Maximum(S) == IF S = {} THEN -1
              ELSE CHOOSE x \in S : \A m \in S : x \geq m
  1. The ASSUME statement is made for assumptions about the constants

  2. SUBSET Acceptor == PowerSetOf(Acceptor).

  3. EXCEPT can be chained!

/\ aState' = [aState EXCEPT ![m.ins][acc].mbal = m.bal,
                                   ![m.ins][acc].bal  = m.bal,
                                   ![m.ins][acc].val  = m.val]
  1. This is also legit:

Phase1b(acc) ==  
  \E m \in msgs : 
    /\ m.type = "phase1a"
    /\ aState[m.ins][acc].mbal < m.bal
    /\ aState' = [aState EXCEPT ![m.ins][acc].mbal = m.bal]
    /\ Send([type |-> "phase1b", 
             ins  |-> m.ins, 
             mbal |-> m.bal, 
             bal  |-> aState[m.ins][acc].bal, 
             val  |-> aState[m.ins][acc].val,
             acc  |-> acc])
    /\ UNCHANGED rmState
  1. Elements of a Symmetry Set may not appear in a CHOOSE.

  2. ASSUME must be a constant formula.

  3. Specs hold as undefined all values of all variables not used at all times. It's best not to think of specs as programs which describe the correct behaviour of the system. The describe a universe in which the system and its environment are behaving correctly.

  4. Steps that leave are variable values unchanged are called stuttering steps. Including stuttering steps helps us say what a system may do, but now we want to specify what a system must do.

  5. A finite sequence is another name for tuple.

  6. Alternating Bit protocol: Let's say you have users A and B. If A sends to B 4 strings, how can B detect if A sent repeated strings multiple times? There is no way to tell apart Fred, Mary, Mary, Ted, Ted, Ted, Ann from Fred, Mary, Ted, Ann. You could timestamp it, but let's not. It's easiest to just append a bit that flips after every message. Appending a bit can be done with

TypeOK == /\ Data \X {0, 1} \* where \X is the cartesian product
  1. To talk about may/must, we will talk about liveness and Safety properties.

  1. Now on to the full AB Protocol

  2. Strong Fairness of action A asserts of a behavior:

    • If A is ever repeatedly enabled, then an A step must eventually occur.

    • Equivalently: A cannot be repeatedly enabled forever without another A step occurring.

    • Weak fairness gives you the possibility of your enabling condition being flip-flopped forever. Strong fairness guarantees if you are enabled repeatedly, A must occurr.

  3. What good is liveness? What is the good in knowing that something eventually happens in 10^6 years? This is good if there's no hard real time requirements.

  4. Recursive declarations must be prepended with RECURSIVE

RemoveX(seq) == IF seq = << >>
                THEN << >>
                ELSE IF Head(seq) = "X"
                     THEN RemoveX(Tail(seq))
                     ELSE <<Head(seq)>> \o RemoveX(Tail(seq))
  1. The Temporal Substitution law: can't do the basic maths trick have to had the 🔲

THEOREM 🔲 (v = e) => (f = (f WITH v <- e))
  1. When in AB2, we add the possibility for messages to be corrupted. If that happens, we will need to compare messages to a potential "Bad" string, and TLC will yell at formulas like "Bad" = 0. Instead, we can call the constant Bad a model value.

  2. When trying to specify the liveness of the spec, it's good to try and attach metadata for what actually happened, but don't append TRUE/FALSE to your messages - separate another Sequence as <<TRUE,FALSE,TRUE...>> to keep track of the real and imaginary parts of the spec.

  3. Refinement mappings help make implementations easier.


  1. In TLA+, every value is a set: 42 is a set, "abc" is a set.

  2. This represents

TCTypeOK ==
    rmState \in [RM -> {"working", "prepared", "committeed", "aborted"}]
TCInit == rmState = [r \in RM |-> "working"] (* this means the array with index set RM such that every element rm of RM is mapped to "working"*)
  1. Terminology

index setdomain
  1. Remember notation for updating a record:

Prepare(r) == /\ rmState[r] = "working"
              /\ rmState' = [rmState EXCEPT ![r] = "prepared"]

Decide(r)  == \/ /\ rmState[r] = "prepared"
                 /\ canCommit
                 /\ rmState' = [rmState EXCEPT ![r] = "committed"]
              \/ /\ rmState[r] \in {"working", "prepared"}
                 /\ notCommitted
                 /\ rmState' = [rmState EXCEPT ![r] = "aborted"]
  1. Ah! Draw the state machine and then figure out the actions that transition to each state!

  2. If you see the Coverage of actions and some of the actions were never taken Count == 0, it usually means there's an error in the spec.

  3. End of line \* comment syntax

  4. This record is actually a function, whose domain is {"prof", "name"} such that f["prof"] = "Fred" and f["num"] = 42. === f["prof"]

[prof |-> "Fred", num |-> 42]
  1. Abbreviate [f EXCEPT !["prof"] = "Red" as [f EXCEPT !.prof = "Red"}]

  2. UNCHANGED <<rmState, tmSTate, msgs>> is an ordered triple. It's equivalent to

... /\ rmState' = rmState
    /\ tmState' = tmState
    /\ msgs' = msgs
  1. Conditions which have no primes' are calle enabling conditions, and in an Action Formula should go at the beginning, like so.

TMRcvPrepared(r) == /\ tmState = "init"
                    /\ [type |-> "Prepared", rm |-> r] \in msgs
  1. Update the CommunityModules.jar... or else get hit by a bug..

  2. Symmetry sets: if "r1"↔ "r3" in all states of behavior b allowed by TwoPhase produces a behaviour b\_{1,3} allowed by TwoPhase, TLC does not have to check b\_{1,3} if it has checked b. Becuase RM = {"r1", "r2", "r3"}, We say that RM is a symmetry set of TwoPhase. To exploit this, replace

RM <- {"r1", "r2", "r3"}


RM <- {r1, r2, r3}

select Set of model values/Symmetry Set just below it.

  1. So it turns out that TwoPhase Commit can break if the TM fails. If you try to "just" engineer it with a second TM, they can cannibalize messages if TM1 pauses and TM2 takes over and sends an abort signal.


  1. A behaviour of a system is a sequence of states. A state machine is described by all its possible initial states and a next state relation. A state is an assignment of values to variables. The part of the program that controls what action is executed next is called the control state.

  2. A new TLA+ spec...

------------------------------- MODULE simple -------------------------------
EXTENDS Integers

Init == i = 0 /\ pc = "start"

Pick == \/ /\ pc = "start"
           /\ i' \in 0..1000
           /\ pc' = "middle"
Add1 == \/ /\ pc = "middle"
           /\ i' = i + 1
           /\ pc' = "done"

Next == Pick \/ Add1

\* Modification History
\* Last modified Fri Jun 18 20:58:16 CDT 2021 by mrg
\* Created Fri Jun 18 20:50:35 CDT 2021 by mrg
  1. To produce the PDF, type Ctrl + Alt + P.

  2. DON'T use Tabs (config in Preferences), F3/F4 to jump back and forth, F5 to see all defs, F6 for all uses of word under cursor, F10 is jump to PlusCal unfolded def, Oooh boxed comments are neat with Ctrl+O + Ctrl+B and friends, don't shade PlusCal code, regen pdf on save, Ctrl+TAB to swap between tabs, Ctrl+Alt to swap between subtabs

  3. Hillel's super cool tricks for TLA+

  4. This formula FillSmall == small' = 3 is WRONG. It's true for some steps and false for others. It is NOT an assignment. The big must remain unchanged! If you don't you are coding, if you do keep it same, you are doing math. eg:

FillSmall == /\ small' = 3
             /\ big' = big
  1. Remember you can add TypeOK as an invariant and big # 4 too!

  2. big + small =< 5 , not big + small <= 5 🙁

  3. Equality is commutative! 0 = small === small' = 0

  4. Use a ' expression only in v' = ... and v' \in ...


  1. io_uring tutorial here, with a chatbot example here

  2. 6 ways to make async Rust easier

  3. Triage: filter(func) makes func a Fix1.

  4. Lazy iterators have uppercase names!

  5. GC is broken in multithreading - if thread 1 is allocating a bunch of garbage, and thread 2 isn't, then thread 1 can trigger a dozen collections, making thread 2 think its few objects are very old, and thus don't need to be collected.

  6. Lean4: return at the end will hurt type inference.

  7. fpcontract is a type of fastmath flag. If you use LLVMCall, you can use specific ones. Here's a specific issue for automatic FMA.

  8. Turns out folds are universal -

  9. PROJECT IDEA: Feynman Diagrams???


  1. Travis Downs recommends this x86 link dump - it's great! OMG it's way too much...

  2. git format-patch -1 --pretty=fuller 3a38e874d70b to format patches for the linux kernel.

  3. git send-email mypatch.patch to send patches, git format-patch to make it.

  4. cregit, bison, flex, cscope are useful tools for navigating kernel source code.

  5. git log -2 Makefile shows the last 2 commits that went into Makefile.

  6. git log -2 --author=Linus checks for the last 2 commits by Linus o.0

  7. You can comput in subtype expressions! Thanks to Dr. Bauman for this gem.

struct MyArrayWrapper{A} <: supertype(A)
  1. make core will maek the core tests in Julia.

  2. JULIA_LLVM_ARGS=-timepasses ./julia To time all passes! Cool Stuff I learned from Jameson Nash.

  3. cat Make.user to get

  4. cp -a v1.7/ v1.8/ to copy over all files

  5. Disabling DWARF with ./julia -g0 will make your code go slightly faster because you don't emit as much DWARF stuff - Probs worth looking into disabling it more.

  6. User vs System time: User land vs Kernel land timings

  7. Profiler tricks:

Profile.print(C = true, nosiefloor = 1, mincount = 10)
  1. e->Lunions = oldLunions; is copying by value (which means a stack of 100 int32s is being copied on all that)

  2. Charpov sent me homework1 and friends - MPI assignment is Homework 5.

  3. TLA+ Link dump


  1. Discovered upgrep, which is a very optimized grep built in Cpp. Of note are the lockless work stealing scheduler and SIMD debranchification approach. It has a very, very pretty interactive ugrep -Q 'foo' mode. The debranching algo is exposed in this talk.

  2. Rediscovered Calculus made easy and AoPS boards.

  3. Never a bad time to remember the CFDPython exists.

  4. Found the books More/Surprises in Theoretical Physics by Rudolf Peierls.

  5. Also found Fundamentals of Numerical Computing by Toby Driscoll and Exploring ODEs

  6. PROJECT IDEA: Scrape with TableScraper.jl.

  7. PROJECT IDEA: CourseTemplates.jl based on Computational Thinking from MIT which is very pretty.

  8. Remember the Intel OPtimization manuals come with attached example codes

  9. PROJECT IDEA: Port GW Open Data Workshop too.

  10. Read George's grad guide.

  11. Julius' post on Julia macros for beginners is great.

  12. PROJECT IDEA: REPL Based PlutoUI.jl. WITH VIM BINDINGS + TextUserInterfaces.jl maybe?. YES. YES!

  13. PROJECT IDEA: Open Data structures in Julia with the MIT course template.

  14. Look into DIANA and Julian ports of it (paper is here, code is here).

    • FeynCalc in Mathematica is an interesting contender: 3.4 seconds to calculate the Higgs decaying into a fermion-antifermion pair.

  15. Learned how to fix a sink today: Need a stillson wrench, a bucket and a metal coat hanger. Put the bucket under the sink's elbow. Twist off the bottom of the elbow. If there's no much when you take off the cap, it's likely there's no blockage at the elbow. Next, scrape the circumferences of the sink's drain with the wire hanger, letting off a bit of water to rinse the muck. Repeat until clean, don't forget to wrench up the bottom of the elbow again.

  16. PROJECT IDEA: LLVMPassAnalyzer.jl with Text User Interfaces.jl as the backend. Or maybe TerminalUserInterfaces.jl

  17. Lean: import Leanpkg; #eval Leanpkg.leanVersionString, commetns are with --, arrays #[1,2,3][1] == 1, functions don't need spaces so gcd 1 10 == 1, Lists are [1,2,3],

structure Array (a : Type u) where
    data : List a
  1. eval (fun x => x + 1) [1, 2, 3] and #eval (fun (x,y) => x + y) [(1,2), (3,4)] == [3,7]

  2. There's Lean for hackers, and you can run your file with lean --run leanpkg.lean.

  3. Functional Algorithms Verified! sounds awesome, but not in Lean4

  4. Logical Verification in Lean

  5. Temporal Logic slides and exams

  6. LTL Model checking course and book Principles of MOdel Checking - J P Katoen

  7. Lean 4 course by Seb. Ullrich is THE source and Lean for hackers looks like a good hello world post.


  1. MXCSR: Multimedia eXtension Control and Store Registers - can be accessed with vldmxcsr, vstmxcsr

  2. The amazing Jubilee shares another nugget:

So like... the problem with those is that access to the MXCSR bit field actually can break LLVM compilation assumptions. it's literally UB. To touch it. At all. Now, it so happens that LLVM may not break your code if you actually do it, and LLVM is slowly growing the capability to handle altering MXCSR in a principled manner, but anyone touching it is doing so at their own risk, aware that it's UB.

  1. When going form AVX to SSE instructions, there may be a performacne penalty due to keeping the upper 128 bits of YMM registers intact - use vzeroupper before that to avoid all perf penalties. Also, AVX allows unaligned accesses with a perf cost, but keeping alignment will increase perf.

  2. MASM calling convention: pass first 4 float args in xmm0:3.

  3. Leaf functions in assembly don't need a prolog or epilog, non-leaf functions must: save and restore volatile registers, initialize stack frame pointer, allocate local storage space on the stack, call other functions.

  4. In C++, you can align xmm values with

struct XmmVal {
    union {
        int8_t m_I8[16];
        int16_t m_I16[8];
        float m_F32[4];
        double m_F64[2];
void AvxPackedMathF64 {
    alignas(16) XmmVal a;
    alignas(16) XmmVal b;
    alignas(16) XmmVal c[8];
  1. To get those xmm's into vector registers:

; Load packed SPFP values
    vmovaps xmm0, xmmword ptr [rcx] ;xmm0 = a
    vmovaps xmm1, xmmword ptr [rdx] ;xmm1 = b

So, note you load the entire xmm register with xmmword ptr [foo].

  1. Super cool trick to check 16 byte alignment (no perf penalty)

test rcx, ofh ; jump if x not aligned to 16 byte boundary
jnz Done
  1. Macros avoid overehad of a function call.

  2. Want to transpose a matrix? Use a bunch of vunpcklps, vunpckhps, vmovlhps, vmovhlps.


  1. Assembly!

This mirrors this syscall in C:

size_t sys_write(unsigned int fd, const char* buf, size_t count);
  1. Little-endian - smallest byte as smallest address. Derp.

  2. data, bss, text - initialized consts/dadta, non initialized vars, code section in asm.

  3. registers: rax:rdx, bp sp si di, r8:r15

  4. There's several types of initialzied data db (declare bytes), dw (declare words), etc.

There's also RESB, RESW as reserved bytes, reserved words, etc. INCBIN is for external binary files, EQU for defining constants:

one equ 1

Exercise: try to translate the following C code into asm:

if (rax != 50) {
} else {


cmp rax, 50
    jne .exit
    jmp .right ; HOT DAMN FIRST TRY YO
  1. Only 6 args can be pass via registers, the rest are passed on the stack:

So if you have

int foo(int a1, int a2, int a3, int a4, int a5, int a6, int a7)
    return (a1 + a2 - a3 - a4 + a5 - a6) * a7;

The first six are pass in the registers, and the 7th arg you have to pop from the stack: push arg/ pop arg. In MASM, you get 4 registers for calling convention and the rest are in 8 byte incremetns from the RSP. ALSO: After you are finished being called, you have to restor registers rbp, rbx, r12:r15

  1. You can write nicer headers

section .data
		SYS_WRITE equ 1
		STD_IN    equ 1
		SYS_EXIT  equ 60
		EXIT_CODE equ 0
		NEW_LINE   db 0xa
		WRONG_ARGC db "Must be two command line argument", 0xa
  1. $, $$ return the position in memory of string where $ is defined, and position in memory of current section start, resp.

  2. Why the instruction mov rdi, $ + 15? You need to use the objdump util, and look at the line after calculateStrLength

objdump -D reverse

reverse:     file format elf64-x86-64

Disassembly of section .text:

00000000004000b0 <_start>:
  4000b0:	48 be 41 01 60 00 00 	movabs $0x600141,%rsi
  4000b7:	00 00 00
  4000ba:	48 31 c9             	xor    %rcx,%rcx
  4000bd:	fc                   	cld
  4000be:	48 bf cd 00 40 00 00 	movabs $0x4000cd,%rdi
  4000c5:	00 00 00
  4000c8:	e8 08 00 00 00       	callq  4000d5 <calculateStrLength>
  4000cd:	48 31 c0             	xor    %rax,%rax
  4000d0:	48 31 ff             	xor    %rdi,%rdi
  4000d3:	eb 0e                	jmp    4000e3 <reverseStr>
  1. To checkif a string is set:

test rax, rax               ; check if name is provided 
    jne .copy_name
  1. Assembly has macros! These are single line

%define argc rsp + 8
%define cliArg1 rsp + 24

These are multi line

%macro bootstrap 1          ; %macro name number_of_params
          push ebp
          mov ebp,esp
  1. Don't forget the .period when you call .function, AND in the function section titles:

    mov eax, 1

struc person
   name: resb 10
   age:  resb 1
; and then
section .data
    p: istruc person
      at name db "name"
      at age  db 25

section .text
    mov rax, [p +]
  1. Call C from assembly, assembly from C

  2. x86 has 8 registers for floats, they are 10 bytes each, labeled from ST0:ST7

extern printResult

section .data
		radius    dq  1.7
		result    dq  0

		SYS_EXIT  equ 60
		EXIT_CODE equ 0

global _start
section .text

		fld qword [radius]
		fld qword [radius]

		fstp qword [result]

		mov rax, 0
		movq xmm0, [result]
		call printResult

		mov rax, SYS_EXIT
		mov rdi, EXIT_CODE

You have data in radius and result. fld qword [radius] stores radius in ST0, and again in ST1. fmul then multiplies both and puts it in ST0. Load pi with fldpi, multiply, and store that result with fstp qword [result]. C calling convention: pass floats to system through xmm registers, so you have to declare how many you are using - do that with mov rax, 0, movq xmm0, [result], call printResult, then exit.


  2. shl must use register cl to make the shifts.

  3. sar shift arithmetic right because it carries over the bit, like in arithmetic, ha.

  4. cdq -> "convert dobule word to quadword": Dividend in EAX must be sign extended to 64bits.

  5. Do integer conversions with movsx, "move integer with sign extension" and movzxd "move unsigned integer with sign extension double word"

  6. @F is a forward jump, @B backwards jump


  1. Parallel Computing course by WestGrid Canada + HPC.

  2. vcpkg sounds like a decent package manager for Cpp.

  3. LLVM Tips and tricks:

    • Use Ninja and tons of flags to speedup compilation: don't build all backends, use the new pass manager, only target host architecture, optimized tablegen, release with debug info,

170.oh shit git seems neat!

  1. To see what is actually printed after macro replacements, use clang -E foo.c.

  2. LLVM Bugpoint does case test reduction

  3. You can unit test the optimizer o.0

; RUN: opt < %s -constprop -S | FileCheck %s
define i32 @test() {
  %A = add i32 4, 5
  ret i32 %A
  ; CHECK: @test()
  ; CHECK: ret i32 9
  1. Best Tutorial for x86 I could find, and free! Now I gotta write syscalls snippets for the bloat...


  1. Lord help me my Learn LLVM 12 book is here and I'm learning C++ to be an uber Julia hacker. Taking the C++ Beyond the Basics course by Kate Gregory I learned

vector nums {1,2,3,45};
auto isOdd = [](int candidates){candidates % 2 != 0;};
int odds = std::count_if(begin(nums), end(nums), isOdd);
// std algorithms have all the goodies that apply to iterators like
//any_of, all_of, etc
int i = 0;
std::generate_n(std::back_inserter(v), 5, [&]() { return i++; });
int total = 0
total = std::accumulate(begin(v), end(v), 0);
int count3 = std::count(begin(v), end(v), 3);
auto v4 = v;
auto endv4 = std::remove_if(begin(v4), end(v4), [](int elem) {return (elem == 3)}; );
v4.erase(endv4, end(v4)); // or even v4.erase(std::remove_if(...));
bool allpositive = std::all_of(begin(v4), end(v4), [](int elem) { return elem >= 0; });
try {
    auto x = make_unique<X>(Stuff);
    // risky stuff
for (auto i : v)
for (auto x : {10, 20, 30})
for (auto& x : v) //refers, doesn't modify
class Container {
    virtual double& operator[](int) = 0;//pure virtual function
    virtual int size() const = 0;//const member function (§4.2.1)
    virtual  ̃Container() {} //destructor (§4.2.2)};
class X {
        X(Sometype);                    //ordinar y constructor: create an object
        X();                            //default constructor
        X(const X&);                    //copy constr uctor
        X(X&&);                         //move constr uctor
        X& operator=(const X&);         //copy assignment: clean up target and copy
        X& operator=(X&&);              //move assignment: clean up target and move
        ̃X();                            //destr uctor: clean up
        //Y(const) //

pg 53 of Tour of Cpp really says talks about move semantics

template <typename T>
class Vector {
    T* elem;
    int sz;
    explicit Vector(int s);    //constructor, establish invariant, acquire resources
    ~Vector() {delete[] elem;} //destructor, release resources
    //copy+move ops
    T* operator[](int n);
    const T& operator[](int i) const;
    int size() const {return sz;}

This is also possible:

template <typename T, int N>
struct Buffer {
    using value_type = T;
    constexpr int size() { return N: }
  1. Rust tips: Finally found a decent SIMD tutorial for Rust! I learned that ISCP is a C SIMD dialect to get super optimal performance. Instead of their Hello world, we can try doing something like this:

pub fn dotp(x: &[f32], y: &[f32], z: &mut [f32]) {
    let n = 1024; // or let n = x.len();
    let (x, y, z) = (&x[..n], &y[..n], &mut z[..n]);
    for i in 0..n {
        z[i] = x[i].mul_add(y[i], z[i]);

that exploits the x.len() to pass that info to LLVM for more optims.


  1. Introduction to Undefined Behaviour and a blog post by John Regehr - time to grok some of this nonsense.

  1. @agustinc3301 kindly helped me setup Cloudflare analytics on my Franklin.jl blog. It's free and quick! You verify your account after signing up and then add the link to your Franklin footer in _layout/foot.html and page_foot.html (I think.). That did it! Now I can see redditors accessing the Julia To Rust post 🔎


  1. Jubilee recommends capturing mutation to smaller scopes in Rust instead of the C-ish idiom of mutation everywhere:

let mut i = 0;
    while i < N {
        let d2s = f64x2::from_array([
            (r[i] * r[i]).horizontal_sum(),
            (r[i + 1] * r[i + 1]).horizontal_sum(),
        let dmags = f64x2::splat(dt) / (d2s * d2s.sqrt());
        mag[i] = dmags[0];
        mag[i + 1] = dmags[1];
        i += 2;

Can be converted to

for i in (0..N).step_by(2) {
        let d2s = f64x2::from_array([
            (r[i] * r[i]).horizontal_sum(),
            (r[i + 1] * r[i + 1]).horizontal_sum(),
        let dmags = f64x2::splat(dt) / (d2s * d2s.sqrt());
        mag[i] = dmags[0];
        mag[i + 1] = dmags[1];
  1. To run cargo watch on a non-standard file, use cargo watch -c -x "run --examples dot_product". Credit to Lokathor.

  2. Finally got the code working for the! in the end, it wasn't so scary:

#![feature(array_chunks)] // gotta have this
fn dot(a: &[f32], b: &[f32]) -> f32 {
    a.array_chunks::<4>() // el paso de la muerte
    .map(|&a| f32x::from_array(a))
    .zip(b.array_chunks::<4>().map(|&b| f32x4::from_array(b))) // so aside form some ugly conversions all is peachy
    .map(|(a,b)| (a * b).horizontal_sum())


  1. Rust syntax for updating structs with ..other_struct is very neat.

  2. if let Some(word) = ... {}

  3. while let Some(Some(word)) = ... {}

  4. cargo watch -c is very useful for seeing how you're code is going! Credit to Lokathor for the -c flag.


  1. make -C debug julia builds are much faster to build because you are not optimizing anymore - hat tip to Jameson Nash for that.

  2. LLVM trap is what calls unreachable - tells the runtime that this should never happen. Basically checking that codegen didn't screw up.

  3. git add -u


  1. Finally got the hang of the Rust dbg! macro:

let a = 2;
let b = dbg!(a * 2) + 1;
//      ^-- prints: [src/] a * 2 = 4
assert_eq!(b, 5);

Very useful for the competitive problems debugging!


  1. Finally got around to the nucleotide in Rust exercism. My solution was a bit C-ish, this is neater: (Credits to azymohliad, but with no Err)

fn count(c:char, dna: &str) -> usize {
    dna.chars().filter(|&x| x == c).count()

fn nucleotide_counts(dna: &str) -> HashMap<char, usize> {
    "ACGT".chars().map(|c| (c, count(c, dna))).collect()

Another clever initialization trick by jtmueller:

let mut counts: HashMap<char, usize> = ['A', 'C', 'T', 'G'].iter().map(|n| (*n, 0)).collect();

Probs worth using HashMap::with_capacity(4) since I know there's only ACTG as keys.

  1. Rust: use enum::*;, and then you don't need to enum::foo all over your match arms!

  2. I learned about the function in the sublist exercise, link here

let slice = ['r', 'u', 's', 't'];
let mut iter =;
assert_eq!(, &['r', 'u']);
assert_eq!(, &['u', 's']);
assert_eq!(, &['s', 't']);
  1. Difference between show and print: print uses quotes around the string, show doesn't, and this

  2. Rust: map.entry(letter).or_insert(0)) += 1



$ nasm -g -f elf64 hello.asm
$ g++ hello.cpp hello.o
$ ./a.out
;               Ch02_01.asm

; extern "C" int IntegerAddSub_(int a, int b, int c, int d);

;        .code
;IntegerAddSub_ proc
	global IntegerAddSub_         
	section .text
; Calculate a + b + c - d
        mov eax,ecx                         ;eax = a
        add eax,edx                         ;eax = a + b
        add eax,r8d                         ;eax = a + b + c
        sub eax,r9d                         ;eax = a + b + c - d

        ret                                 ;return result to caller
;IntegerAddSub_ endp
;        end


  1. Made a 3D print of dispatch with my sister. It was an awesome birthday.

  2. Got DoctorDocstrings.jl Poster and Rubin.jl Lightning talk accepted to JuliaCon! Now to work on those asap...

  3. Got the Kusswurm Modern x86 Assembly Language Programming and Min-Yih Hsu LLVM Techniques books in the mail now...

  4. Should write down the Next steps for MMTK - a written down goal is usually an easier one.

  5. 🚀 💃 To setup emojis, we can insert with SPC i e, but the line editor gets a bit funky...?

  6. Found this incredibly useful Doom emacs tips, and this vim guide


  1. Finally remembered to setup mu. Let's see if I can finally do it...


  1. Vim tricks from Emacs doom! RTFM to change the font to Julia mono!

  1. Kevin Bonham is helping me figure out the Emacs tabbing situation:

Alright, I'm tired of never knowing how to work buffers or tabs or windows inside my doom emacs.
Who's got a good crash course?
My ideal goal is to:

1. Be able to open multiple buffers and move between them
2. Be able to set groups of tabs with different buffers
3. Be able to "restore" groups of tabs when starting up emacs.

*Kevin Bonham*
I've just been figuring this out myself...

1. SPC b b to switch buffers in the same window (assuming you've opened them before with SPC . or something.
    SPC w J (note the capital) will move the current buffer into a new window below (can also use H, K, or L) as last arg to do left, up, or right).
    Then do the same thing but lowercase to move focus around to different windows
2. SPC TAB has all of the tab-related things. SPC TAB n does new tab, SPC TAB r renames it, SPC TAB 1 to switch to tab 1 etc.
3. SPC p has all of the "project" related stuff. I haven't played a lot with these, but they seem to all be linked to a directory, though I think if you have outside files open, they will re-open with the project


  1. Wow-BOB-Wow has some nifty Rust tricks:

pub fn sum_of_multiples(limit: u32, factors &[u32]) -> u32 {
	(1..limit).filter(|i| factors.iter().any(|f| i % f == 0)).sum()
match x.cmp(n) {
    Ordering::Greater => Some(Classification::Abundant),


  1. 1.7 goodies! You can destructure structs with named tuples!

(; a, b) = x # destructures props `a` and `b` of `x`

Can also be used like:

struct A

foo((; x, y)::A) = x + y # ermahgerddd

@test can now be passed as an additional argument skip and broken:

@test isequal(complex(one(T)) / complex(T(Inf), T(-Inf)), complex(zero(T), zero(T))) broken=(T == Float64)
[ 1; 2 ;; 3 ; 4 ;; 5 ; 6 ;;; 7 ; 8 ;; 9 ; 10 ;; 11 ; 12]


  1. When making a PR to BinaryBuilder.jl, search the whole repo to make sure no one has tried building jemalloc before :upside-down: 🎉

  2. Julia doesn't ship binaries yet, but BOLT could be worth looking into.


  1. Micket in the Julia chat has a nice answer for:

"How to do this neater?"

d = Dict("a" => 2, "b" => 3)
Dict(zip(keys(d), map(x -> 2x, values(d))))
# Do this!
map!(x -> 2x, values(d))
# Or this!
Dict( k => 2v for (k, v) in d)
  1. aur/julia-bin is a good wrapper for Julia on Arch. Thanks Mosè!


  1. If you append a julia Markdown bloc with = you get line numbers on HackMD.

3 + 3


  1. Fortran learnings!

  2. Fortran people have nice parallelism concerns.

do concurrent(i = 1:N)
    i0 = max(i - 1, 1)
    i1 = min(i + 1, N)
    b(:, :, 1) = 0.5 * (a(:, :, i0) + a(:, i1)) ! array assignment
end do

Can already be sent to Tesla GPUs o.O

  1. In fortran, functions are pure, subroutines modify their arguments.

  2. To make a struct, it probably suffices that

type :: t_point
    real :: x
    real :: y
end type

And you access it with

type(t_point) :: mypoint
mypoint%x = 1.0
mypoint%y = 2.0
  1. You can declare fields in the struct as private, protected, allocatable[dimension], pointer, codimension, contiguous, volatile, asynchronous:

type :: t_example
    integer, private:: i = 0 ! hites it from use outside of the t_example scope. Default init is with i = 0
    integer, protected :: i ! allowed access, but not definition outside of the scope
    real, allocatable, dimension(:) :: x
end type
  1. You can containstype-bound procedures

module m_shapes
implicit none
public t_square

type :: t_square
    real :: side
        procedure :: area
end type

    real function area(self
    class(t_square), intent(in) :: self
    res = self%side**2
    end function
end module m_shapes
  1. Peter Deffebach kindly helped me golf a really cool, but simple task:

using CSV, Glob
fs = CSV.File.(readdir(glob"*.csv"))

Done! You've read all the files fs that are CSVs!

julia> using CSV, DataFrames, Glob;
julia> files = readdir(glob"*.csv");
julia> reduce(vcat,, DataFrame) for file in files)
  1. Jacob Zelko has kindly shared some tools for dev flow:

  2. vim FloatTerm instead of vim-slime, don't need to open a pane that way.

  3. :MarkDownPreview with iamcoo/markdown-preview.nvim.


  1. Tim Besard and Valentin Churavy kindly helped me out on the Julia users GPU call (available on the calendar).

They noted a couple of good starting considerations:

  1. Try and have a function that maps to every single element in the GPU.

  2. Implementing a simple moving average is a type of convolution - there's good tutorials on optimizing that here and here.


  1. git log -p -- path/to/file will show you the commits you did to a file. Amazing!


  1. To write the Unicode Character U+000A, (Hat tip to Mason Protter), try this:

Char(0x000A) |> clipbaord

Thanks to Dave MacMaho, we can also do


and get the Cat emoji :D

  1. Huh, forgot to add this nice pice of @ccall goodness from the primecount_jll stuff:

julia> myprimecount(x) = @ccall libprimecount.primecount_pi(x::Clonglong)::Clonglong
myprimecount (generic function with 1 method)

julia> @time myprimecount(1e8)
  0.001004 seconds

julia> @time myprimecount(1e14)
  0.149201 seconds
  1. We're dunking on the Fortran gang because they're 8x slower on a sin benchmark :D

I'm glad I pulled out Steven Johnsons flags to cross compile a C lib to use it with @ccall:

shell> ls
cordic.c  cordic.h  cordic.html

shell> gcc -fPIC -O3 -xc -shared -o cordic.c

shell> ls
cordic.c  cordic.h  cordic.html

I pulled that from their announcement of hte Julia broadcasting features and the annex notebook here.

And here is how to call it:

julia> function cordic_sine(a)

          cos = Ref{Float64}(0.0)
          sin = Ref{Float64}(0.0)

          # Ref: Excellent work by John Burkardt
          # void cossin_cordic ( double beta, int n, double *c, double *s )
          ccall((:cossin_cordic, "/home/mason/cordic/"), Cvoid, (Float64, Cint, Ref{Float64}, Ref{Float64}), a, 40, cos, sin)

          return sin[]

cordic_sine (generic function with 1 method)

Basically, don't forget it's the ABSOLUTE PATH!


  1. Simeon Schaub pulled some fancy destructuring:

x = [1, 2, 3]
x[3], x[1:2]... = x
@test x == [2, 3, 1]



Small lessons:

  1. Big wieldy codebase? Work on one small, small change at a time. Cross bridges as you come to them.

  2. Majority of strings don't need more than 128 bytes, so a single byte of addressing

  3. Jeff uses ack for grepping the codebase

  4. Before trying to compile, review your changes with a git diff

  5. When getting a segmentation fault after making your changes and running make, run a debug build to figure out what went wrong with make debug -j4

  6. gdb /usr/bin/julia-debug starts gdb, then cd base/; r --output-ji x compile.ji or something like that.

  7. If you change header files you have to rebuild everything

  8. Bonus: There's a docker image to start Julia Int32.

  9. Multithread the compiler.ji step: multithread the code generator, break up into more code units...

  10. set a breakpoint on jl_throw to see where gdb goes wrong. then r -J ../usr/lib/julia/corecompiler.ji --output-ji x sysimg.jl

  11. rr magic: rr record ../usr/bin/julia-debug -J ../usr/lib/julia/corecompiler.ji --output-ji x sysimg.jl, then rr replay. b jl_exceptionf and then rc to "reverse continue" so that you can step backwards from what happened.

  12. When an assertion fires, and you are in gdb, the location of the assertion in the source code is in frame 4, so, to jump to it you just start gdb and then f 4.(Usually just using d bt to look at the backtrace and figure out from there where to go.

  13. You can call lisp (to reindent your emacs!) within the gc.c file!

  14. Hah, I clicked the moment of triump!

  15. ../julia runtests.jl strings to run the string test suite.

  16. Remembered about ArgParse.jl. Noice:

s = ArgParseSettings()
@add_arg_table! s begin
        help = "an option with an argument"
    "--opt2", "-o"
        help = "another option with an argument"
        arg_type = Int
        default = 0
        help = "an option without argument, i.e. a flag"
        action = :store_true
        help = "a positional argument"
        required = true


  1. Don't forget to turn off cpuscaling when running your benchmarks! Hat tip to Camille Fournier for schooling a bunch of us on this one!

From this link: we can do:

grep -E '^model name|^cpu MHz' /proc/cpuinfo

To figure out if the number on the left is lower than the number on the right. That's costing speed! if you install cpupowerutils(Centos/Debian)/ cpufrequtils (ubuntu / Debian) you can do:

cpupower frequency-set -g performance


  1. Added a new recipe for simdjson. remember to add supported_platforms(; experimental = true) to try and run thigns on the new Mac M1 and julia_compat = 1.6 to get the cpuid feature detection.

As always, Mosè helped tons. He rocks.


  1. Como deshacer tu ultimo git commit

git reset --soft HEAD~1
git reset --hard HEAD~1
git commit --ammend -m "este es el mensaje correcto"
git add f.txt
git commit --ammend -m "mensaje del commit"
# Si esta pushed...
git revert 74a...


  1. launch=false config for CUDA.jl helps set peakflops. Current NVIDIA 860M sets clocks in about 5.6e11.

  2. MichaelHatherly's InteractiveErrors.jl is amazing. I should add it to a growing list of REPL tools.

  3. cd - jumps you back to the last dir. Also found command line libs in Rust:


  1. Finally reinstalled CUDA.jl stuff. Some good pointers:

julia> using CUDA
julia> function mykernel()
mykernel (generic function with 1 method)
julia> myconfig(kernel) = (@show kernel; (threads=1, blocks=1))
myconfig (generic function with 1 method)
julia> @cuda config=myconfig mykernel()
  1. Put up StagedFilters.jl on Discord. With LoopVectorization.jl, we get up to 300x performance increase on some systems vs SciPy. I should make a release as I go forward


  1. Ooops - turns out I didn't use a copy of main branch for the tutorials so someone has to update by hadn a bunch of stuff :((((

  2. BinaryBuilder.supported_platforms(exlclude = Sys.islinux) - where have you been all this time?


  1. Great day! Wrote the DataFrames.jl tutorials in Spanish, like 13 notebooks in a day. Vim skills paid off big time!


  1. Almost clinching the BB recipe for racket. This will help build Herbie! In BinaryBuilder.jl, Mosè recommends, instead of

cp racket/bin/* ${prefix}/
# try doing
cp -r racket/bin ${prefix}/.
  1. Possible TODO? Stefan posted on Discourse:

There’s an old issue to allow type annotations on global variables. This would be a great intro compiler project — not trivial by any means, but relatively straightforward. The right approach would need to be discussed with the compiler team, but I suspect the it would be to associate a type with each global binding and automatically insert a type check at each global assignment and teach the compiler that it can assume that the type of each global access has the associated type. An untyped global would then have type Any, so all globals would work the same way. Some subtleties for usability: you’ll want to at least allow redeclaring the same global with the same type so that code can be re-included interactively; you could also allow the type annotation to be made more restrictive since any code that’s already been generated with that assumption will still be correct; to be really fancy, one could add “back edges” from global binding types to methods that use those globals and increase the world age / invalidate those methods, which would allow arbitrary re-declaration of type globals at the cost of recompiling any methods that accessed the global.


  1. Submitted GSoC app. Godspeed. Go go Rubin.jl!

  2. In BinaryBuilder.jl, cd ${prefix}/ is where all compilation targets are placed.

Also, RTFM! Specifically platform hijinks.


  1. We got invited to give a conference talk at Alpine2021 because of a tweet I sent to Alpine's main dev, Ariadne Conill.

Now to coordinate a cool talk/proposal with Mosè and Elliot and show off cool Julia stuff.

  1. FINALLY got Lean4 working on VSCode. Still don't know how to use nix but oh well. Halfway through the manual, and this example was neat to grok:

def add1Times3FilterEven (xs : List Nat) :=
	-- this
	--   List.filter (. % 2 == 0) ( (. * 3) ( (. + 1) xs))
	-- becomes this
	--   xs |> (. + 1) |> (. * 3) |> List.filter (. % 2 == 0)
	-- becomes THIS!
	xs |>.map (. + 1) |>.map (. * 3) |>.filter (. % 2 == 0)

In the same note: x |> f in Lean is the same as f <| a, which in Haskell means f $ a. Damn, that's some crappy ascii in Haskell :/


  1. Spawning a run(...) can take 2x more allocations from one system to another!

julia> using primecount_jll

julia> @time run(`$(primecount()) 1e14`); # can be 2x allocations in other systems!
  0.150116 seconds (468 allocations: 33.891 KiB)
  1. Woke up to the primecount_jll post getting tons of love, awesome! Hat tip to Stefan Karpsinski and Carsten Bauer for alley-ooping this.

  2. Need to remember the @doc macro exists to document code not necessarily next to a function declaration - need to add a dispatch to DoctorDocstrings.jl for this case.

  3. Ah right, forgot the make -j${proc} flag for a parallel BBuilder recipe, thanks to Mosè for catching that again

  4. Mosè points out that it's not too hard to look at the warning logs emmitted from the PR - that's

how he was ble to spot that CompilerSupportLibraries was missing, and some other warnings needed to be addressed.

  1. How to easily create a function that updates its own internal state? Use a closure! Like this

julia> f(state=0) = ()->state+=1
f (generic function with 2 methods)

julia> foo = f()
#7 (generic function with 1 method)

julia> foo()

julia> foo()

julia> foo()

julia> foo.state

julia> foo.state.contents


  1. Chris Elrod with the amazing hint that @code_native has a syntax=:intel or syntax=:att flag!

  2. Nice idea during the vacation: need to get

  1. up Ultimate Plumber is absolutely amazing at ripgreppin' files and seeing results in real time. Someone rewrite it in Rust already!

  2. Hmmm - what about just simply checking if there is a With[...], and doing straight string replacement?

  3. Don't forget about using Traceur.jl!, just drop a @trace foo(3) and keep going.

My workflow goes like this:

  1. I made a cool tutorial on making a BinaryBuilder.jl recipe for primecount a bleeding edge

algorithm library for counting primes in in C/C++.


  1. Made public advances on Rubin.jl today. Turns out you can call (Within Mathematica)

FullForm[Hold[...]] and that will give you the S-expression for the whole thing.

Now to parse that into Julia full fledged.


  1. Apply a SymbolicUtils.Rewriters.If(cond, rw) to get the "facts" of our intrules.

  2. Somebody can export every single DiffEq method to Fortran with some cleverness and FortranTarget() shenanigans in Symbolics.jl hmmmmm

  3. @less @which @edit @functionloc all work the same!

  4. Finally got to forwarding a GitHub fork to a new changes! Here's how:

git fetch upstream
git checkout master
git rebase upstream/master
git push -f origin master

Kindly taken from here.


  1. Instead of Base.OneTo(n), use axes(A, i) (Thanks Mason!), like so:

julia> A = [rand() for i in 1:1000, j in 1:1000];julia> function do_add4!(A)
           n = sizeof(A)[1]
           for j = Base.OneTo(n)
               for i = Base.OneTo(n)
                   @inbounds A[i,j] += 1.0

Chris Elrod mentions that unless the Base.OneTo isn't being fed to an inlined function, it doesn't work for much.

  1. Mason also recommends oneunit instead of one as it works with arbitrary number types. BORKED though, disregard.

  2. This also works:

julia> using LoopVectorization
julia> A = # 1000 x 1000 rand float32s
julia> @avxt A .* 1f0 # multithreaded and AVX512 on platforms that support it
  1. I should start contributing more to LoopVectorization.jl...


  1. Derp - remember, it's match(regex, string).captures[index]

74. FileTrees needed a path(file) |> string instead of a File.

  1. This whole thing parses and writes to a JSON3 array within 10 seconds. That rules!

  2. To write files into the MyPkg.jl directory when activated Sukera suggests

joinpath(@__DIR__, "my_new_file.json")


  1. ArtifactUtils.jl rules! just add_artifact! and you're almost good to go.

  2. Need to work with a gajillion files in a folder and map the same transform to them lazily? Use FileTrees.jl for all your multithreaded directed needs!

  3. Hmmm some of the Rubi rules are ... commented? Hope I don't end up writing a full Mathematica to Julia transpiler...


So yeah, it's been a while. Back on the saddle again.

  1. Meta.show_sexpr is super cool.

  2. This works!

for c in IOBuffer(mymultilinestring)
  1. Project Euler is coming along nicely. I should start on Rubi and put those freaking AdventOfCodeParsing skills to the test...


  1. Alex Arslan coming in again with the hot tips: If you want to parse a string into an expression (I need it to call the last REPL history line with @edit)

you can use Meta.parse("3^2") == :(3 ^ 2).

  1. Whooops. Shipped DoctorDocstrings.jl today. Best way to figure out if you have a bug is to ship it to production. Problem is that the jldoctest expects the output to be displayed just after

the REPL input, so I need to paste the code there. I think I can handle it... display is the function to print to the REPL, btw.


  1. Boy oh Boy. I started on DoctorDocstrings.jl. It's gonna be amazing.


  1. Retaking Matt Bauman's Parallel workshop from JuliaCon 2019

There's 3 interesting distinctions for @sync and @async:

@time for i in 1:10 # takes about 10s
@time for i in 1:10 # about 0s
    @async sleep(1)
@time @sync for i in 1:10 # about 1s
    @async sleep(1)

You can wait for a task to block until it finishes or fetch to initizlize it now.

@distributed (+) for r in [(0:9999) .+ offset for offset in 0:10_000:r[end]-1]
  1. Got pretty well punked by a Python gotcha

julia> IdDict(true => "yes", 1 => "no", 1.0 => "maybe")
IdDict{Any,String} with 3 entries:
  true => "yes"
  1.0  => "maybe"
  1    => "no"


julia> Dict(true => "yes", 1 => "no", 1.0 => "maybe")
Dict{Real, String} with 1 entry:
  1.0 => "maybe"

Fortunately, Stefan was able to convince some of use in the Julia Slack that this is a desirable behavior - you should replace the keys of a dict when you do this, otherwise you will be very very unhappy. Here's the relevant implementations in the decompose function in Base.

Quoting Stefan from the Slack:

in 0.3 we didn’t hash equal keys the same, we considered the type, but it was really bad
worst problem was that the type of a dict changed the behavior
if you had a Dict{Any,String} and you used 1 and 1.0 as keys, they would end up in different slots; if you had a Dict{Float64,String} and you used 1 and 1.0 as keys, they would both end up in the 1.0 slot
the only ways to avoid that  badness were:
1. don’t auto-convert keys, which would be really annoying and fussy
2. figure out a good way to value-based key hashing efficiently
two major challenges:
1. make it fast for common types like ints and floats and reasonably fast for things like bigints and rationals
2. make it extensible so that people implementing their own numeric types can do so correctly
yes, package authors definitely extend 'Base.decompose' to have proper hashing.

NICE - turned the confusion into a PR

  1. Very nice solution to the wordcount exercise: with a matchall regex and a foreach.

function wordcount(sentence::AbstractString)
    words = matchall(r"[a-z]+'[a-z]+|[a-z0-9]+", lowercase(sentence))
    counts = Dict{AbstractString, Int}()
    foreach(w -> counts[w] = get(counts, w, 0) + 1, words)


  1. Exercism: Circular Buffer. A few informal interfaces define the ability of Julia to give you a lot of methods for free!

  1. Omicron666 from Discord helps out with the syntax for nested for loops/iterations:


  1. parse(Int, "01010101", base=2) to get a binary number directly is really nifty.

  2. Remember to use the lo, hi = extrema(xs) function! Credit for a really elegant solution to JLLing.

  3. Some really good learning about writing Iterators from Eric Davies from Invenia

function iterate(it::TakeNth, state...)
    xs_iter = nothing

    for i = 1:it.interval
        xs_iter = @ifsomething iterate(it.xs, state...)
        state = Base.tail(xs_iter)

    return xs_iter
  1. To dump a TLA file into a dot file, use tlc -dump dot file.tla. Then read it with

  1. CodeCosts.jl looks REALLLLLY cool for a [JuliaTooling] video soon...

julia> using CodeCosts

julia> f(x::T) where T = convert(T, max(x * 10.0, x / 3))
f (generic function with 1 method)

julia> @code_costs f(1.0f0)
   1 1 ─ %1  = Base.fpext(Base.Float64, x)::Float64
   4 │   %2  = Base.mul_float(%1, 10.0)::Float64
  20 │   %3  = Base.div_float(x, 3.0f0)::Float32
   1 │   %4  = Base.fpext(Base.Float64, %3)::Float64
   2 │   %5  = Base.lt_float(%2, %4)::Bool
   1 │   %6  = Base.bitcast(Base.Int64, %4)::Int64
   1 │   %7  = Base.slt_int(%6, 0)::Bool
   1 │   %8  = Base.bitcast(Base.Int64, %2)::Int64
   1 │   %9  = Base.slt_int(%8, 0)::Bool
   0 │   %10 = Base.not_int(%7)::Bool
   1 │   %11 = Base.and_int(%9, %10)::Bool
   1 │   %12 = Base.or_int(%5, %11)::Bool
   2 │   %13 = Base.ne_float(%2, %2)::Bool
   1 │   %14 = Base.Math.ifelse(%13, %2, %4)::Float64
   2 │   %15 = Base.ne_float(%4, %4)::Bool
   1 │   %16 = Base.Math.ifelse(%15, %4, %2)::Float64
   1 │   %17 = Base.Math.ifelse(%12, %14, %16)::Float64
   1 │   %18 = Base.fptrunc(Base.Float32, %17)::Float32
   0 └──       return %18
, CodeCostsSummary(
     zero:  2|
    cheap: 12| 111111111111
   middle: 10| 4===2=2=2=
expensive: 20| 20==================
    total: 42| 100 (default threshold)
  1. DP by errichto:

  1. Dynamic prog 2 by errichto:

  1. TLA challenge for AoC2020!


  1. Advent of Code 7 kicked my butt. HOWEVER! We rocked the parsing with some cool regexes.

Again, Pablo Zubieta coming in with the fire code:

function fish(d)
    # if you only pop and append to the end of vectors, all is good
    queue = [k for (k, v) in d if haskey(v, "shiny gold")]
    found = Set(queue)
    while !isempty(queue)
        bag = pop!(queue)
        new = (k for (k, v) in d if haskey(v, bag))
        union!(found, new) # This is better than a push!
        append!(queue, new)
    return length(found)
# "nop +0"
# "acc +3"
# "jmp -99" expected inputs
function parse_input_line(line)
    m = match(r"^(\w{3}) ([-+]\d+)$", line
    return (op = m[1], val = parse(Int, m[2]))

From this we consider the following:

  1. Consider having a function that parses a line at a time and passes a named tuple to the solver.

  2. Don't be silly - if you already have code that finds the solution to something in part1... use it in part2. -_-.


  1. Advent of Code just keeps on rocking!

  2. Exericisms review: checking if something is an isogram (no repeated letters):

isisogram(s) = allunique(i for i in lowercase(s) if isletter(i))
  1. When defining your new types, make sure to use promote_rule appropriately. Exercism:Complex Numbers:

a lot of hacky logic.

To customize human-readable text output for objects of type T, define
  show(io::IO, ::MIME"text/plain", ::T) instead. Checking the :compact IOContext
  property of io in such methods is recommended, since some containers show their
  elements by calling this method with :compact => true.

Now onto CustomSet:

iterate(s::CustomSet) = iterate(s.dict)
iterate(s::CustomSet, el) = iterate(s.dict, el)
  1. Iterators galore! We had massive help from Sascha and Fliksel:

julia> function Base.iterate(iter::Fibo, state = (0, (1,1))) # The 0 here will represent the "counter"
       if state[1] > iter.n
           return nothing
       f1, f2 = state[2]
       return f1+f2, (state[1]+1, (f1+f2, f1))
  1. Note about iterators:

function Base.iterate(iter::Fibo, state = ...)
				        #  ^
					#  |
	counter = state[1] # <- this has to match with newstate
	if counter > iter.n
	    return nothing

	# Clever calculations here
	newitem = foo(...)
	newstate = (bar(...), ...)
	# NOTE: the tuples must match up!
	# typeof(newstate) == typeof(state)
	return newitem, newstate



  1. Pablo Zubieta just absolutely shreked his Advent of Code Day04 problem: here's the learnings.

const input = split(String(read("input")), r"\n\n")

const fields1 = (r"byr", r"iyr", r"eyr", r"hgt", r"hcl", r"ecl", r"pid")
const fields2 = (

# Part 1
count(p -> all(t -> contains(p, t), fields1), input)

# Part 2
count(p -> all(t -> contains(p, t), fields2), input)
  1. Instead of

if !haskey(d, str)
    d[str] = 1
    haskey(d, str)
    d[str] += 1

You can try

d[str] = get(d, s, 0) + 1
  1. Revisiting Exercisms is a good way to hone skills. Instead of

a, b, c = dict[c[1]], dict[c[2]] dict[c[3]]
# vs
a, b, c = (dict[c[i]] for i in 1:3)
  1. Remember to check for type instabilities in the code with @code_warntype.

  2. Stacking generators within generators is tricky, but joshua-whittemore has a trick (Exercism-ETL)

function transform(input::Dict)
         lowercase(letter) => value
         for (value, letters) in input
         for letter in letters


  1. Beast of a solution with great help from Colin:

function solutions(str)
    sol1, sol2 = 0, 0
    for line in readlines(str)
        lo, hi, (char,), pass = match(r"^(\d+)-(\d+) (\w): (.+)$", line).captures
        lo, hi = parse.(Int, (lo, hi))
        sol1 += lo <= count(==(char), pass) <= hi
        sol2 += (pass[lo] == char) ⊻ (pass[hi] == char)
    sol1, sol2

The match(r"...", line).captures immediately splits and gets the appropriate strings, and (char,) is a tuple decomposition of a container with a single element, (similar to (a,b) = [3 4]).

  1. Regex has many smart functions

match(needle, haystack)
~~matchall(needle, haystack)~~
eachmatch(needle, haystack)
ismatch(needle, haystack)
  1. If I have str = "Roll On The Floor" and I want to match on each first character to get the acronym, I can use getproperty(m, :match) for that:

r = eachmatch(r"\b[a-zA-Z]", str)
join(getproperty(r[i], :match) for i in 1:length(r))
  1. Count is really nifty:

julia> xs = "#..##."

julia> count("#", xs)

These "curried" operators can be found with rg Fix[12], or help?> Fix1

!!! You can implement this for your own methods with Base.Fix2{typeof(func)}: contains(needle) = Base.Fix2(contains, needle)

  1. When dealing with parsing strings by hand, split can sometimes give useless empty strings that muck up the analysis later on. Use the kw keepempty=false to get rid of those spurious results! For an example, check the AdventOfCodeDay04 code.


  1. Advent of code day 01: cool tricks:

  2. Advent of code day 02: Cool tricks:


  1. Credit to @Suker: REPL interactivity can be drastically helped (and enhanced with Revise.jl) if you have the following:

  1. Reading the SciML dev docs:

abstract type AnalyticAlgorithm <: DiffEqBase.AbstractAnalyticAlgorithm
struct analytic{Simple} <: AnalyticAlgorithm{Simple} end
analytic(; simple = true) = analytic{simple}()


  1. Chris de Graaf suggested instead of using const A = [1], try using a Ref:

# access a ref with []
A = Ref(0)
A[] = 1
A[] == 1 # true

Takes a bit more nanoseconds to access than a 1 sized array but is sized ().

  1. Execution matters more than hoarding ideas. Decent Talk by John Cormack. Enjoy the insight high, then get down in the mud and try to bust your own idea.


  1. Al final empecé el manual en español. Parece que Laura Ventosa va a ser buena mancuerna para este proyecto. Qué chido. La traduccion del manual esta en este link.

wc src/ src/manual/ src/manual/
  109   986  7546 src/
  100   731  5084 src/manual/
  138   932  6102 src/manual/
  347  2649 18732 total

CONTEO: 2640

  1. Copy pasting to the system clipboard in Vim is easier with select the text -> "+y. Also t will go to just before a character F will search a char backwards, and } will go to the end of a paragraph.

  2. It seems the Savitzky-Golay filter is very - VERY - interesting for a lot of computing people. Really need to get into parallelizing it and figuring out the GPU part.

  1. Started on Pochoir.jl. Godspeed.

  2. Oh god. SymbolicUtils.jl can revive IntegralTransforms.jl.


  1. Found an absolutely amazing post about learning Z3 as if it were Lisp syntactically.

Should definitely look into this further. I think some Z3 and TLA+ are more than enough formal methods for a while... There's even an online editor that seems useful for prototyping


  1. Counting neighbours / minesweeping? Ran into this problem on the Exercsim earlier today:

sum(arr[i][j] .== "*") #where j = 1:3

is a no-no. First, we have to remember to compare Chars to Chars, since

"*" == '*' # false
'*' == '*' # true

A correct approach looks like:

sum(arr[i][j] == '*' for j in idxs)

by use of some spiffy generator syntax.

  1. Maybe time for someone to write a fast neighbours(arr, i, j) function in a package and PR it to LinAlg? Credit to Sascha Mann. Use views to make it fast.

Kick it up a notch: make it N-Dimensional, and performant!

  1. You can't do a = "abc"; a[2] = '3';, or '3' != Char(3), because STRINGS ARE IMMUTABLE!

  2. Vyu has an amazing solution for summing up neighbours in a Matrix:

function sumAdjacent(array, xy::CartesianIndex{2})
    x, y = xy.I
    lenX, lenY = size(array)
    v = view(
        max(1, x - 1):min(lenX, x + 1),
        max(1 ,y - 1):min(lenY, y + 1)
  1. bovine3dom has a solution for a hypercube minefield:

# This function works for hypercube minefields too, which is pretty cool.
# If you decide to construct your own hypercube minefield, bear in mind that
# the curse of dimensionality means that mines become useless as the number of
# dimensions increases to even moderate numbers.
# (A more useful metric for 'danger from mines' is the percentage of neighbouring
# cells which contain mines).
function flag_mines(matrix::Array)
    flagged = zeros(Int,size(matrix))
    @inbounds for inds in Tuple.(CartesianIndices(matrix))
        flagged[inds...] = matrix[inds...] == 1 ? -1 : sum(window(matrix,inds,ones(Int,length(size(matrix)))))
  1. The cleanest minefield answer might be OTDE...

annotate(minefield) = [
            w[c] == '*' ? '*' :
            count(get(get(minefield, y, ""), x, "") == '*'
            for x in (c - 1):(c + 1)
                for y in (r - 1):(r + 1)
                    if x != c || y != r)
        for c in 1:length(w)),
    '0' => ' ')
    for (r, w) in enumerate(minefield)


  1. DID NOT KNOW you could iterate a dictionary if you didn't care about order:

samples = Dict(
	"I" => 1,
	"II" => 2,
	"V" => 5,
for sample in samples
	@test to_roman(sample[1]) == sample[2]


  1. Invaluable git trick: if you committed some changes locally, but someone else pushed to master, use the auto-rebase autostash trick:

git config --global pull.rebase true
git config --global rebase.atuoStash true

so that you don't need to do git pull --rebase --autostash and can just git pull.


  1. Try and order starter kit / computer parts from

  2. Before you spend a day trying to scrape / download files, make sure the author did not already kindly include a zipped version of the files :clown_face:

  3. I think I found a possible thesis project - SymbolicUtils.jl as a backend for SymbolicTensors.jl. I should message the author and set something up.

  4. Ran into Downloaded the Mathematica notebooks, found a way to parse and dump them into text with PDFIO.jl.

  5. Remembered how to setup an artifact with ArtifactUtils.jl. That thing is useful.

  6. Found a killer command from SOverflow on how to recursively copy all files in a tree of folders that match an extension into a target directory:

  1. Polytomous recommended this site Taguette for highlighting documents and its open source. Super cool! Should send to Ponzi.


  1. If you want to make your startup super fast, use PackageCompiler.jl:

julia> using PackageCompiler
julia> create_sysimage([:Revise, :OhMyREPL, :BenchmarkTools], replace_default = true)

Super charge that combo with the ~/.julia/config/startup.jl:

julia> try
           using Revise
       catch e


  1. Trump is likely gonna lose the election - crazy times. Been working a bit on scaffolding for LightGraphsIO.jl. Solid integration with Parsers.jl will mean a lot of speed coming up for the LightGraphs.jl ecosystem.

  2. In order to not get punked by the output of

julia> print.(sq(i) for i in 1:10)
14916253649648110010-element Vector{Nothing}:

@pabloferz suggested the foreach, which returns a nothing, and thus doesn't print.

julia> foreach(x -> println(x^2), 1:3:7)


  1. Today I finally got around to rewriting GraphsIO.jl. It suffered from a few ailments:

I adopted the Blue Style guidelines because they came in with PkgTemplates.jl and screw it, why not try and follow them. Here's what I got done today:

Tomorrow I should start something fun with the Parsers.jl library for maximum speedups. Wish me luck!


  1. Closures! Defining a function within a function is a type of closure. They take variables from one scope above them. @masonprotter and @fredrikekre helped me figure out why having this is desirable:

julia> function f(x, y, z)
           data = compute(x, y, z)

           g() = data^2 # closure over data
           g() # call g here maybe?
           # ...
           g() # maybe again here?

Mason says:"Almost all usages of closures can be replaced with 'top level' functions that take extra arguments (one for each captured field), but it's syntactically less pleasing and can end up causing you to have a bunch of function names in your namespace you don't want." Of course there's a Discourse post on it.

  1. Wow! Function composition and piping lets you do some amazing stuff with \circ<TAB> and friends!

julia> (sqrt ∘ +)(3, 6)
julia> map(first ∘ reverse ∘ uppercase, split("you can compose functions like this")
6-element Array{Char,1}:
 'U': ASCII/Unicode U+0055 (category Lu: Letter, uppercase)
 'N': ASCII/Unicode U+004E (category Lu: Letter, uppercase)
 'E': ASCII/Unicode U+0045 (category Lu: Letter, uppercase)
julia> 1:10 |> sum |> sqrt
julia> (sqrt ∘ sum)(1:10)
julia> [ "a", "list", "of", "strings"] .|> [uppercase, reverse, titlecase, length]
4-element Array{Any,1}:
julia> (^2, sqrt, inv).([2,4,4])
[4,2, .25]
  1. Rust allows for defining anonymous functions!

fn raindrops(n: u32) -> String {
	let is_factor = |f| x % f == 0;
  1. Rust match is very powerful... try and setup the anonymous functions in a tuple after the match and then filter by (each, available, case) => action.

pub fn raindrops(num: i64) -> String {
    let mut raindrop = String::new();

    match (num % 3, num % 5, num % 7) {
        (0, 0, 0) => raindrop.push_str("PlingPlangPlong"),
        (0, 0, _) => raindrop.push_str("PlingPlang"),
        (0, _, 0) => raindrop.push_str("PlingPlong"),
        (_, 0, 0) => raindrop.push_str("PlangPlong"),
        (0, _, _) => raindrop.push_str("Pling"),
        (_, 0, _) => raindrop.push_str("Plang"),
        (_, _, 0) => raindrop.push_str("Plong"),
        (_, _, _) => raindrop = num.to_string()

    return raindrop
  1. This was a good use of match

pub fn square(s: u32) -> u64 {
    match s {
        1...64 => 1u64.wrapping_shl(s-1),
// This also works
//      1u64 << (s - 1)
        _ => panic!("Square must be between 1 and 64"),

pub fn total() -> u64 {
// Lol thanks philip98
// u64::max_value

Credit to Wow-BOB-Wow.


Today I got my website setup!


  1. Today I restart this diary but going the other way...fuck Markdown auto formatting.

  2. Some attributes are unsafe o.0.

  3. Your error types should implement the std::error:Error trait, Display/Debug

  4. Type-erased errors often compose nicely.

  5. If your error is Box<dyn Error + Send + Sync 'static> then you can Downcast it: you can take an err of one type and cast it to a more specific type when calling: you can use Error::downcast_ref on an std::io::Error to get a std::io::ErrorKind::WouldBlock, but downcast_ref requires its arg to be 'static.

  6. You can only obtain ! (the Never type) by infinte looping or panicking or very special occasions, and the compiler can actually optimize your code based on that, since it knows that branch never returns. If you write a func that returns Result<T, !>, you can't return an Err.

  7. ? does unwrap or early return.

  8. "Implement From, use Into in bounds." Since there is a blanket impl for getting an Into from anything that uses From.

  9. An early return here would be bad because it may skip the cleanup:

fn do_the_thing() -> Result<(), Error> {
    let thing = Thing::setup()?
    // .. code that uses thing and ?
// vs
fn do_the_thing() -> Result<(), Error> {
    let thing = Thing::setup()?
    let r = try {
    // .. code that uses thing and ?
  1. Just because it has ! at the func name doesn't mean it's a declarative macro, like macro_rules! and format_args! - just means that some source code will be replaced/changed at compile time.

  2. Declarative macros always generate valid Rust as output.

  3. :ident, :ty, :tt are known as fragment types.

  4. Macro variable identifiers existing in their own namespace => no name clashes => hygienic. Doesn't happen for Types, Modules and Functions within the call site (so that you can define them inside the macro and use them outside).

  5. Avoid ::std paths so that macros can be used on no_std crates.

  6. You can escape/share identifiers with $foo:ident!

  7. Macros must respect import order - even in so mod foo; mod bar; will let macros from foo be used in bar, and not vice versa.

  8. In procedural macros you can affect how the parsed code is generated, and aren't required to be hygienic.

  1. TokenStream implements Display, which is handy for debugging!

  2. To propagate user errors like u31 as a type, consider the compiler_error! macro.

  3. Async interfaces are mthods that return a Poll, as defined here:

enum Poll<T> {
  1. Polling is standardized via the Future trait:

trait Future {
    type Output;
    fn poll(&mut self) -> Poll<Self::Output>;

types that implement this trait are called futures (or promises in other langs).

  1. Don't poll futures after they have return a Poll:Ready, or they panic. If it's safe to do, it's called a fused future.

  2. Receiver and Iterator look very similar, in some sense - they might be fused in the future! (async iterators are called streams).

  3. Generators are chunks of code with some extra compiler generated bits that enable it to stop/yield its execution midway and resume later from the yieldpoint. Not yet in stable Rust but used internally.

  4. Generators need to store a bunch of internal state to be able to resume - if your app spends too much time in memcpy, perhaps its the generators. Rust checks that references across these internal states obey the ownership system.

  5. What happens when code isnide an async block takes a ref to a local var? The point is that the polling can give you self-referential data which holds both the data and the refs to that data, but the polling has moved it! To solve this conundrum, you use Pin, a wrapper type that prevents the underlying type from being (safely) moved and Unpin is a marker trait that the implementing type can be removed safely from a Pin.

// What you get from using Pin to implement Future
trait Future {
    type Output;
    fn poll(self: Pin<&mut self>) -> Poll<Self::Output>;

This means that "once you have the value behind a Pin, that value will never move again."

  1. Notice the implementation of Pin:

struct Pin<P> {pointer: P}
impl<P> Pin<P> where P: Deref {
    pub unsafe fn new_unchecked(pointer: P) -> Self;
impl<'a, T> Pin<&'a mut T> {
    pub unsafe fn get_unchecked_mut(self) -> &'a mut T;
impl<P> Deref for Pin<P> where P: Deref {
    type Target = P::Target;
    fn deref(&self) -> &Self::Target;
  1. Git saves files more like this:

V1    V2 V3 V4 V5
File A   A1 A1 A2 A2
File B   B  B  B1 B2
File C   C1 C2 C2 C3

and vcs does it more on a "delta based" version:

V1   V2 V3 V4 V5
Fila A  Δ1 -> Δ2
File B  -> -> Δ1 Δ2
File C  -> Δ1 -> Δ3

and 99% of stuff can be done locally - you don't need a central server to answer you.

  1. Because Git checksums all file stores and is referred to by the checksum, you can't just swap files without detection.

  2. Git has 3 stages (IMPORTANT):

  1. Basic configs, in ascending priority level:

- [path]/etc/gitconfig - applied to all usrs on system and their repos. - ~/.gitconfig or ~/.config/git/config - applied to you as user - .git/config for single repo

  1. Set main as the default branch name:

git config --global init.defaultBranch main
  1. git help <verb> is a canonical way to get help, git add -h is an abbreviated way to get help/show flags.

  2. If anyone has any clone of your repo, they have the entire history of it, and can restore it if needed.

  3. Untracked files are files that weren't in the last snapshot.

  4. Once you stage it, it gets committed.

  5. Use git status -s (or --short) to get a nice summary of where you are.

  6. .gitignore can respect glob patters and ignores # lines

# ignroes all .a files

#but do track lib.a

#ignore all files in any dir named build

ignore all .pdf files in the doc/ dir and its subdirs
  1. git diff --staged and git diff --cached are synonyms.

  2. git difftool --tool=vimdiff looks cool.

  3. Can declare inline commit message with git commit -m, and git commit -am will skip the need to stage the file and then committing.

  4. git rm -f README requires extra args to prevent misuse. To remove a file from staging area, do git rm --cached README.

  5. git mv README can save you some commands.

  6. git log --stat is neat, git log --compact-summary is neat,

  7. git log --pretty-format: %h %s --graph is super neat, add it as a command.

  8. Limit log out put with -2 but also with --since and --until: git log --since=2.weeks. Combine with --author="John Smit" and you have a rat!

  9. git log -S function name is known as the pickaxe option: Takes a string and only shows the commits that altered the count of the string.

  10. git log -- path/to/file gives you history

  11. git log --no-merges can help reduce noise!

  12. Committed to early? try git commit --amend literally overwrites the previous commit with a new one. Only do it for local changes, and not those that have been pushed.

  13. UNSTAGE A FILE:git reset HEAD <FILE> to unstage a file

  14. UNMODIFY A MODIFIED FILE: git checkout -- <FILE>. (Dangerous - any local chanes are gone.)

  15. The previous 2 can be done with git restore:

git restore --staged <FILE> # unstages a file
git restore <FILE>          # unmodifies a file
  1. git fetch <remote> goes out and copies all the data from that remote project.

  2. Fast forward if possible, else create a merge commit: git config --global pull.rebase "false" vs you want to rebase while pulling: git config --global pull.rebase "true".

  3. git push <remote> <branch>.

  4. git remote show origin shows you all the branches you have made to the repo and their current status (up to date, fast-forwardble, local out of date)

  5. git remote set-url remote-name new-url

  6. List tags: git tag, and git tag -l "v1.8.5*" will glob accordingly

  7. Annotated tags have a bunch of metadata and can be signed and verified - make one with git tag -a v1.4 -m "My version 1.4", and then you can do git show v1.4

  8. Git tags can be added after the fact: just do git log --pretty=oneline and then git tag -a v1.2 asdfbd.

  9. Git doesn't push tags by default, you need to git push origin <tagname>, or git push origin --tags. To delete a tag locally use git tag -d <tagname> and remotely do git push origin --delete <tagname>.

  10. Setup aliases with git config --global checkout

  11. git log --oneline --decorate --all --graph is cooool and git config --global 'log --oneline --decorate --graph' is very neat for a git gg.


  1. A commit in Github is

pointing to a tree which is

and each blob contains

Each commit pointing to its tree/snapshot but the parent commit is pointing to another commit's hash.

  1. A git branch is a movable pointer to one of these commits.

  2. To know what branch you're currently on, git keeps a special pointer called HEAD.

  3. If you want to know to which branch the pointers are pointing to, use --decorate

  4. Some commits from a diff branch may be hidden - use git log <branch> or git log --all to show them all.

  5. Switching branches changes files in your working directory.

  6. git log --oneline --decorate --graph --all goes from bottom to top.

  7. git checkout -b <newbranchname> and git switch -c <new-branch> are identical. git switch testing-branch also works.

  8. When there's no divergent work to merge together, it's called a fast-forward.

  9. Merge commits have 3 parents - can you have N parents?

  10. git checkout master -> git merge iss53

  11. git mergetool 👀 is setup with git config --global merge.tool nvimdiff.


  1. Rested.


  1. Just don't rename branches that are not local to you. CI can also break from a master rename, but if you must, use bit branch --move master main the git push origin --delete master.

  2. Weggli is a semantic search tool for C/C++

  3. The point of Pin is to have target types that contain references to themselves and give the methods a guarantee a that the target type hasn't moved (and that the internal self references remain valid).

  4. Unpin is an auto-trait (if all your struct fields are Unpin, your struct is also Unpin). Which means you kinda have to opt out of Unpin.

  5. pub unsafe fn foo(...) {} is considered a mistake because it doesn't help you reduce the footgun radius lol. The first means I swear X, Y, Z is upheld in this code, and unsafe {...} means that all the unsafe contracts within the block are contained/upheld.

  6. Big things to do in unsafe blocks: deal with raw pointer types like *const T and *mut T.

  7. Types of unsafe:

  1. std::hint::unreachable_unchecked is a common use of unsafe.

  2. You can do std::ptr::{read,write}::{unaligned,volatile} to use odd pointers - they don't meet Rust's assumptions of alignment or size.

  3. Send/Sync means that a type is safe to send / share across threads, respectively.

  4. It is commone to forget to add bounds to generic parameters for unsafe impls of Send and Sync: unsafe impl<T: Send> Send for MyUnsafeType<T> {}.

  5. unsafe is for memory unsafety, not per se for business logic.

  6. There's 3 big types of UNDEFINED BEHAVIOR manifestations:

  1. We need Better Language Specs by Ralf Jung - a Rust PL researcher.

  2. Validity: rules for what values a given type can inhabit

  1. Niche optimization: Since a reference can never be all zeros, an Option<&T> can use all zeros to represent None and avoid the extra byte and allocation. Also applies to Option<Option<bool>>

  2. MaybeUninit memory is very useful in network buffers/hot loops: No point requiring a [0; 4096] if you're going to overwrite those values with 0 if you're going to overwrite them anyways with other values.

  3. If you are calling user code, you should assume it panics and handle accordingly.

  4. The drop check:

let mut x = true;
let foo = Foo(&mut x);
let x = false;

If Foo implements Drop, then it may use a ref to x, and thus should not compile. If it doesn't implement Drop, all is good. BUT!

fn barify<'a>(_: &'a mut i32) -> Bar<Foo<'a>>{..}
let mut x = true;
let foo = Foo(&mut x);
let x = false;

If Foo implements Drop but Bar does not, this code shouldn't compile. BUT! If the ref Bar holds is indirect, like PhantomData<Foo<'a>>, or &'static Foo<'a>, then the drop is ok, because Foo::drop is never actually invoked, and the ref to x is never accessed. This whole logic is the drop check, and we really need it for dangling generic parameters like unsafe impl<#[may_dangle] T> Drop for ....

  1. "Since we do call T::drop, which may itself acces, say a reference to said x, Luckily, the fix is simple: we add a PhantomData<T> to tell the drop check that even though the Box<T> doesn't hold any T, and won't access T on drop, it does still own a T and will drop one when the Box is dropped.".

  2. Read the Rustonomicon.

  3. Miri is the "mid-level intermediate representation interpreter" - you can use it to catch a lot of Rust specific bugs. Use it as a test suite extender.

  4. cargo-expand expands crate macros.

  5. cargo-hack is useful to check for all combos of features.

  6. cargo-llvm-lines tells you which Rust lines give you which LLVMIR.

  7. cargo-udeps tells you about unused dependencies.

  8. Rust libs:

  1. rustup +nightly miri means that it will run MIRI and then revert back to previous settings. cargo +1.53.0 check will run your code with Rust 1.53.0 and then revert back to default.

  2. cargo tree --invert rand will tell you all the places where your crate depends on rand so that you can excise it as a dep.

  3. cargo timings test is now stable 🎉

  4. rustc -Ztime-passes is for all the compilation passes!

  5. cargo -Zprint-type-sizes is a good combo with the variant_size_differences lint, which shows enum types where the variants have very different sizes.

  6. write!(&mut s, "{}+1={}", x, x + 1); works to write into the String s!

  7. iter::once is useful to append to iterators with Iterator::chain and for avoiding allocations.

  8. BufReader/BufWriter batch many small read/writes into one large buffer and can have good perf perks.

  9. If you feel like you need both String/&str, consider a Cow<'a, str> (never take it as a func arg, but do offer it as a return type.)

  10. Instant::elapsed is clean!

  11. Clone::clone_from can save some allocations!

  12. Remote-tracking branches in git get moved whenever you do any network comms, to stay up to date with the remote repo (kinda like bookmarks).

  13. git push origin serverfix:awesomebranch to push local serverfix to the awesomebranch on the remote.

  14. Set credentials with git config --global credential.helper cache.

  15. A tracking branch/upstream branch are local branches that have a direct relationship to a remote branch.

  16. git checkout -b <branch> <remote>/<branch> can be done with git checkout --track origin/serverfix, which can be done with git checkout serverfix if unique.

  17. git branch -v and git branch -vv tell you if your branch is ahead, behind, or both. Remember to do git fetch -all; git branch -vv.

  18. git fetch fetches all the changes but doesn't modify working directory - git pull does change working directory.

  19. 2 ways to integrate changes from one branch to another:

What differs here is the history! Not the contents!

  1. Do not rebase commits that exist outside your repo and tha tpeople may have based work on!

  2. Read about Distributed Git and Public project over Email


  1. Revisited the leap year exercise in Rust. Instead of this crappy 1-liner

pub fn is_leap_year(year: u64) -> bool {
    (year % 100 != 0 || year % 400 == 0) && year % 4 == 0

You can use a neat match:

pub fn is_leap_year(year: u64) -> bool {
    match (year % 400, year % 100, year % 4) {
    (0, _, _) => true,
    (_, 0, _) => false,
    (_, _, 0) => true,
    _ => false,
  1. I forgot to do array[low] < key || array[hi] < key in a binary search algorithm. I will try to do it tomorrow recursively.


  1. Rust: Instead of doing this:

for i in 0..v.len() {
// try
(0..v.len()).foreach(|_| w.push('-'));
  1. A move in a thread will try to move a variable into a thread's own stack. This may work for a bit, but if you want other threads to reference that same variable, the Rust compiler must known that that thread outlives all the others (so that the reference is always valid.) A way to get around that is to use a Rc, which is allocated on the heap and deallocated when no more threads are referencing it.

  2. Unexpectedly useful list of "safer" C++ tooling in the last slides of the Stanford CS110L slides.


  1. Major unborking of my nvim was done by running :UpdateRemotePlugins.

  2. OK, it turns out that some of my ` in the BQN article were erroring the site, which means the blogs after FromJuliaToBQN weren't showing up... inchresting! The solution was to use double ticks and spaces in between the code snippets. Hat tip to Eris from the APL/BQN Discord. Triple ticks require a newline, doulbe ticks don't.