Daniel Ethridge wlib

Towards a More Useful Model of Distributed System State

How I Think About Programs

I like to model all programs as state machines with pure functions within them. These individual state machines compose into larger ones where sometimes it’s easier to visualize as a hierarchy and other times as a distributed network of actors. One system that applies this model is Erlang’s OTP, but this model is very general and comes up just about everywhere.

An issue with obsessing over generalization is the “turing tarpit” — that every computation can be modelled on a turing machine’s tape or using lambda calculus or some other simple system. The key to abstraction is to purposefully attempt to model things with the least powerful/expressive language reasonably possible. If you can solve a problem correctly with a si

	create schema if not exists omdb;

	-- Record types have a 1:1 table to store each record in.
	create table if not exists omdb.types (
	id text primary key,
	-- Table of all (checkpoint) snapshots of records for this type.
	snapshots text unique not null,
	-- Fully materialized table of latest records for this type.
	latest text unique not null,
	created_at timestamptz not null default now()

	const ordersUrl = "https://www.amazon.com/your-orders/orders"

	const wait = (ms = 1_000) =>
	new Promise(resolve => {
	setTimeout(() =>{
	resolve()
	}, ms)
	})

	const fetchDocument = async url => {

	const basicLatin = String.fromCharCode(...range(32, 127))

	const makeRandomPassword = ({
	length = 32,
	characters = basicLatin
	}: {
	/** Max 256 */
	length?: number,
	characters?: string \| ReadonlyArray<string>
	} = {}) => {

	const sourceUrl = "https://m3u8-0.c-spanvideo.org/clip/clip.5081597.576.tsc.m3u8"

	const source = await fetch(sourceUrl)
	.then(res => res.ok ? res.text() : undefined)
	if (!source)
	throw new Error("it's over")

	const tsBlobs = await Promise.all(
	source
	.split("\n")

	function * primes(max = 1_000) {
	const isComposite = []
	for (let i = 2; i <= max; i++) if (!isComposite[i]) {
	yield i
	for (let j = i**2; j <= max; j += i)
	isComposite[j] = true
	}
	}

	const { pipe } = await import("https://unpkg.com/[email protected]/src/util/index.mjs")
	const { listen, map, filter, forEach, tap } = await import("https://unpkg.com/[email protected]/src/util/iterable/async.mjs")

	const makePuzzle = (n = 4) => {
	const solvedPuzzle =
	[...Array(n)]
	.map((_, rowI) =>
	[...Array(n)].map((_, colI) => rowI * n + colI + 1)
	)
	solvedPuzzle[n - 1][n - 1] = null

	MIT License

	Copyright (c) 2021 Daniel Ethridge

	Permission is hereby granted, free of charge, to any person obtaining a copy
	of this software and associated documentation files (the "Software"), to deal
	in the Software without restriction, including without limitation the rights
	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	copies of the Software, and to permit persons to whom the Software is
	furnished to do so, subject to the following conditions:

	const https = require("https")

	const pageHTMLHandler = html => {
	const videoURL = html.match(/https:\/\/vidstreaming\.io\/load\.php\?id=.*?SUB/)[0]
	require("child_process").exec(`open "${videoURL}"`)
	}

	const requestHandler = HTMLHandler => response => {
	let html = ""
	response.on("data", chunk => html += chunk)