/mordor

Blockchain is not only crappy technology but a bad vision for the future. Its failure to achieve adoption to date is because systems built on trust, norms, and institutions inherently function better than the type of no-need-for-trusted-parties systems blockchain envisions. That’s permanent: no matter how much blockchain improves it is still headed in the wrong direction.

Software should be optimized such that the sequential code path is the most common path, with less-frequently taken code paths placed out of line. Software should also assume that backward branches will be predicted taken and forward branches as not taken, at least the first time they are encountered. Dynamic predictors should quickly learn any predictable branch behavior.

The final boss isn’t the ender dragon, it’s growing up :(

Nicht weinen, weil sie vorüber!
Lächeln, weil sie gewesen!

Would I feel nostalgic about my past if it weren't any good? I have plenty of reasons to feel happy.

We didn't realise we were making memories, we just knew we were having fun.

§ rodata (
¶ SRC
	"日本\n";
¶ BLANKS
	' \t\n\v\r';
¶ SYMBOLS
	'().[]{}§¶';
¶ EEOF
	"unexpected EOF";
¶ EBADRUNE
	"unexpected rune";
¶ LUT [
	ʜ01010101;
	ʜ01010101;
	ʜ01010101;
	ʜ01010101;
	ʜ00000000;
	ʜ00000000;
	ʜ02020202;
	ʜ00040303
];
¶ ULN
«…»
);

§ text (
¶ entry [
	la    a₀ SRC;
	call  utfsz;
¶ halt;
	wfi;
	j     halt
];

¶ lex [
«Load length and pointer from lexer»
	mv    s₀ a₀;
	ld    s₁ a₀;
	l     s₂ (a₀+4);
	add   s₁ s₂ s₁;
¶ start;
	mv    s₃ s₂;
¶ loop;
	beq   s₂ s₁ eof;
«Load next rune and UTF sequence length into s₄ and s₅»
	mv    a₀ s₂;
	call  utfparse;
	mv    s₄ a₀;
	mv    s₅ a₁;
	add   s₂ s₂ s₅;
«Is s₄ a blank?»
	la    a₁ BLANKS;
	li    a₂ BLANKS.size;
	call  hasint;
«Ignore blank»
	bge   a₀ x₀ start;
«Is s₄ a symbol?»
	mv    a₀ s₄;
	la    a₁ SYMBOLS;
	ld    a₂ SYMBOLS.size;
	call  hasint;
«Yield symbol»
	bge   a₀ x₀ yield;
	mv    a₀ s₄;
	call  isnamerune;
«Process name»
	bnez  name;
«Reject invalid rune»
	la    t₀ EBADRUNE;
	li    t₁ EBADRUNE.size;
	s     t₁ (s₀+4+XLEN);
	s     t₀ (s₀+4+XLEN+4);
«Rollback s₂ to previous position»
	sub   s₂ s₂ s₅;
	j     end;
¶ eof;
	la    t₀ EEOF;
	li    t₁ EEOF.size;
	s     t₁ (s₀+4+XLEN);
	s     t₀ (s₀+4+XLEN+4);
	j     end;
¶ name;
	beq   s₂ s₁ yield;
«Load next rune and UTF sequence length into s₄ and s₅»
	mv    a₀ s₂;
	call  utfparse;
	mv    s₄ a₀;
	mv    s₅ a₁;
	add   s₂ s₂ s₅;
	call  isnamerune;
	bnez  a₀ name;
«Rollback s₂ to previous position»
	sub   s₂ s₂ s₅;
¶ yield;
	sub   a₀ s₃ s₂;
	mv    a₁ s₃;
	s     x₀ (s₀+4+XLEN);
¶ end;
«Update lexer length and pointer»
	sub   t₀ s₁ s₂;
	sd    s₁ s₀;
	s     s₂ (s₀+4);
	ret
];

¶ isnamerune [
	mv    t₀ a₀;
«Is a₀ an underscore?»
	addi  t₁ t₀ (-'_');
	seqz  a₀ t₀;
«Is a₀ an ASCII number?»
	addi  t₁ t₀ (-'0');
	sltiu t₁ t₁ 10;
	or    a₀ a₀ t₁;
«Is a₀ an ASCII letter?»
	ori   t₁ t₀ ʜ20;
	addi  t₁ t₁ (-'a');
	sltiu t₁ t₁ 26;
	or    a₀ a₀ t₁;
	bnez  a₀ end;
«TODO: check whether it's an Unicode letter/number»
¶ end;
	ret
];

¶ hasint [
«Fail if the list is empty»
	beqz  a₂ no;
	li    t₀ 0;
¶ loop;
«Fetch current element and compare it against a₀»
	lw    t₁ a₁;
	beq   t₁ yes;
«Point to the next element»
	addi  a₁ 4;
	addi  t₀ 1;
«Try again if there are more elements to check»
	blt   t₀ a₂ loop;
¶ no;
	li    a₀ (-1);
	ret;
¶ yes;
	mv    a₀ t₀;
	ret
];

¶ runesize [
«Test a₀ against each upper bound»
	li    t₂ ʜ7F;
	slt   t₀ t₂ a₀;
	li    t₂ ʜ7FF;
	slt   t₁ t₂ a₀;
	li    t₂ ʜFFF;
	slt   a₀ t₂ a₀;
«Sum results into a₀»
	add   a₀ a₀ t₁;
	add   a₀ a₀ t₀;
	addi  a₀ a₀ 1;
	ret
];

¶ utfsize [
«Load first byte from UTF string into a₀»
	lbu   a₀ a₀;
«Lookup UTF sequence length into a₀»
	la    t₀ LUT;
	srli  a₀ a₀ 3;
	add   a₀ a₀ t₀;
	lbu   a₀ a₀;
	ret
];

¶ utfparse [
«Load first byte from UTF string into t₀»
	lbu   t₀ a₀;
«Lookup UTF sequence length into t₁»
	la    t₁ LUT;
	srli  t₂ t₀ 3;
	add   t₁ t₁ t₂;
	lbu   t₁ t₁;
«Return sequence length as a₁»
	mv    a₁ t₁;
«Save byte data into t₀»
	li    t₂ ʜ7F;
	srl   t₂ t₂ t₁;
	and   t₀ t₀ t₂;
	addi  t₁ t₁ (-1);
«Exit if the sequence was one byte long»
	beqz  t₁ end;
¶ loop;
«Load next byte from sequence into t₂»
	addi  a₀ a₀ 1;
	lbu   t₂ a₀;
«Incorporate byte data into t₀»
	andi  t₂ t₂ ʜ3F;
	slli  t₀ t₀ 6;
	or    t₀ t₀ t₂;
	addi  t₁ t₁ (-1);
«Continue if there are more bytes in the sequence»
	bnez  t₁ loop;
¶ end;
	mv    a₀ t₀;
	ret
]
)

H(r, g, b, a) = f3(r) ⊻ f5(g) ⊻ f7(b) ⊻ f11(a)
        f3(x) = (x<<1) + x
        f5(x) = (x<<2) + x
        f7(x) = (x<<3) - x
       f11(x) = (x<<3) + (x<<1) + x

X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*

Run. It is the most important martial art, after all.

jmi2k

does that mean that your calculations would be 0x wrong with no brain?

mkf

Yes.

The most dangerous thought that you can have as a creative person is to think that you know what you’re doing. Because once you think you know what you’re doing, you stop looking around for other ways of doing things and you stop being able to see other ways of doing things, you become blind.

5 Most Fundamental Mathematical Ideas by Amavect.

受 + 心 = 愛.

where we're going we don't need terminals

A tutorial implementation of a dependently typed lambda calculus (local copy).

Computing hardware makes fundamental use of self-reference in flip-flops, the basic units of digital memory, which convert potentially paradoxical logical self-relations into memory by expanding their terms over time.

Lambda calculus vending machine.

Syntax and Semantics of Quantitative Type Theory (local copy).

UGT is convention initially established in #mipslinux on irc.openprojects.net (now irc.freenode.net) but slowly taking over the world. It states that it is always morning when person comes into a channel, and it is always late night when person leaves. Local time of any member of channel is irrelevant. Resistance is futile. Your ass will be laminated. (geoman is exception to this rule - his ass will be fried instead).

The idea behind establishing this convention was to eliminate noise generated almost every time someone comes in and greets using some form of day-time based greeting, and then channel members on the other side of the globe start pointing out that it's different time of the day for them. Now, instead of spending time figuring out what time of day is it for every member of the channel, we spend time explaining newcomers benefits of UGT.

Add = circuit {
	a:  bit
	b:  bit
	cᵢ: bit

	sum: bit
	cₒ:  bit

	sum = a ⊻ b ⊻ cᵢ
	cₒ  = (a ∧ b) ∨ (a ∧ cᵢ) ∨ (b ∧ cᵢ)
}

The digital world and the real one are merging, closer and closer to being the same one. I spend most of my awake time inside a Discord voice channel and talking in 9gridchan. Isn't that comparable to a telepathic link between all of us talking there? Permanent digital communication in an isolated real world.

whiteboardfs -s board
chmod 666 /srv/board
chmod 666 /srv/boot
aux/listen1 tcp!*!2020 exportfs -S /srv/board

mutual survival goal optimizing rational solution to the galactic prisoners dilwemma

perm = ᴏ755
fd   = open "/dev/mordor" ʙ100
p    = ʜBAD

I want a presentation layer that takes raw text and turns it into another representation. It would keep the underlying text untouched.

Jupyter notebooks are the perfect coding environment.

Blender has the best user interface I've ever seen.

Piracy is morally acceptable.

One thing that we have learned is that piracy is not a pricing issue. It’s a service issue. The easiest way to stop piracy is not by putting antipiracy technology to work. It’s by giving those people a service that’s better than what they’re receiving from the pirates.

I have some nostalgia for early 2000s teen culture, but I don't know why. I was too young then to have any kind of bond with it, but I do nonetheless.