Michael Usachenko themichaelusa

Note: This is an old post from back when I was trying to make sense of why inets are so fast for evaluating some λ-terms. It has some silly bits, I learned a lot since and could probably write a better article today, but I think this can still be insightful for these getting started, so I'll leave it here.

Yesterday, I reported the bizarre observation that certain functions can behave as if they had negative complexity. If you haven’t checked that article yet, it isn’t necessary, but you should, as it may blow your mind. In short, the λ-term f(bits) = copy(comp(inc,n,bits)), when given to optimal λ-calculus evaluator, is asymptotically faster than g(bits) = comp(inc,n,bits); i.e.,copy (a O(1) operation for a fixed size) behaves as if it had a O(1/n) complexity, causing the program to run faster by doing more things (!?).

That’s not the only bizarre complexity result I had when

Fast Discrete Program Search 2

I am investigating how to use Bend (a parallel language) to accelerate Symbolic AI; in special, Discrete Program Search. Basically, think of it as an alternative to LLMs, GPTs, NNs, that is also capable of generating code, but by entirely different means. This kind of approach was never scaled with mass compute before - it wasn't possible! - but Bend changes this. So, my idea was to do it, and see where it goes.

Now, while I was implementing some candidate algorithms on Bend, I realized that, rather than mass parallelism, I could use an entirely different mechanism to speed things up: SUP Nodes. Basically, it is a feature that Bend inherited from its underlying model ("Interaction Combinators") that, in simple terms, allows us to combine multiple functions into a single superposed one, and apply them all to an argument "at the same time". In short, it allows us to call N functions at a fraction of the expected cost. Or, in simple terms: why parallelize when we can share?

A

Parallel Python within the same process or hacking around the cursed GIL with a hand-rolled library loader

From its obscure beginnings in Amsterdam, the Python programming language has become a fundamental building block of our digital society. It is used literally everywhere and by everyone for a mind-boggingly wide variety of tasks.

Python is also the lingua franca of Data Science, tying together tools for data loading, wrangling, analysis and AI. There is a massive ecosystem of contributed Python packages, which - for example - allows reading every obscure data format under the sun. This makes Python and its ecosystem extremely valuable for analytical data management systems: Users are likely somewhat familiar with Python due to its immense popularity and the ecosystem provides solutions for most data problems. As a result, Python is being integrated into SQL systems, typically through so-called User-Defined Functions (UDFs). For example, [Apach

A curated list of command-line utilities written in Rust

Note: I have moved this list to a proper repository. I'll leave this gist up, but it won't be updated. To submit an idea, open a PR on the repo.

Note that I have not tried all of these personally, and cannot and do not vouch for all of the tools listed here. In most cases, the descriptions here are copied directly from their code repos. Some may have been abandoned. Investigate before installing/using.

The ones I use regularly include: bat, dust, fd, fend, hyperfine, miniserve, ripgrep, just, cargo-audit and cargo-wipe.

atuin: "Magical shell history"
bandwhich: Terminal bandwidth utilization tool

Unexpected Uses for the Galois Field Affine Transformation Instruction

Intel added the Galois Field instruction set (GFNI) extensions to their Sunny Cove and Tremont cores. What’s particularly interesting is that GFNI is the only new SIMD extension that came with SSE and VEX/AVX encodings (in addition to EVEX/AVX512), to allow it to be supported on all future Intel cores, including those which don’t support AVX512 (such as the Atom line, as well as Celeron/Pentium branded “big” cores).

I suspect GFNI was aimed at accelerating SM4 encryption, however, one of the instructions can be used for many other purposes. The extension includes three instructions, but of particular interest here is the Affine Transformation (GF2P8AFFINEQB), aka bit-matrix multiply, instruction.

There have been various articles which discuss out-of-band

	from manim import *
	import numpy as np

	class DualRingHeatTransferAnimation(Scene):
	def construct(self):
	# Configuration
	num_blocks = 20
	num_around = 39
	block_size = 0.4
	outer_radius = 3.3

	/*
	Not thoroughly tested. DuckDB version used: 1.0.0
	Won't work on NULLs, so input should be coalesced first.
	I make no guarantees that this function will produce output equivalent to Postgres' INITCAP function.

	Examples:
	select INITCAP('do androids dream of electronic sheep?') => 'Do Androids Dream Of Electronic Sheep?'
	select INITCAP('dJ D-wayne megens') => 'Dj D-Wayne Megens'
	select INITCAP('Sa''ar 5-class corvette') => 'Sa'Ar 5-Class Corvette
	select INITCAP(NULL) => SQL Error: Parameter Not Allowed Error: Cannot perform list_reduce on an empty input list

	// THOUGHTS
	//
	// Consider FP: ∃f ∀a ∀b (f (mul a b) b) == b
	//
	// FP can be proven with a pair:
	//
	// - F: (a b: Nat) -> Nat
	// - P: (a b: Nat) -> (F (mul a b) b) == b
	//
	// In the proof P, we pattern-match on 'a' and 'b'. Note that EVERY equality can

	FROM python:3.10-slim-bookworm

	# Set the working directory
	WORKDIR /home

	# Install system dependencies and Crucial Python3 packages
	RUN apt-get update && apt-get install -y curl gcc g++ wget && \
	curl https://sh.rustup.rs -sSf \| bash -s -- -y && \
	echo 'source $HOME/.cargo/env' >> $HOME/.bashrc && \
	pip3 install Cython setuptools