The discipline of Computing is more about how to think, not who or what is thinking.

The majority of people who trade software are in it because they want to make money. That’s their main motivation. It’s rare to see those who enjoy engineering and want to make money on the side.

I guess this isn’t a problem. When commercialization meets passion, commercialization is not even trying.

It is a problem, though, that consumers of commercial software suffer from it. I’ve observed that the technical literate and the technical illiterate lived in two different worlds. If we connect the two worlds together, the problem would be solved. This is not particularly hard to do; it requires some thinking. There is ego in the solution, which I had to deal with it myself.

I don’t think I can explain the solution in text well. Hope’s that I will be able to show by example soon.

I have observed that social stratas exist because people don’t want to move (this alone has veto power on the existence of social stratas).

I have realized that poverty is artificial. The real issue lies in the fact that people cannot reach their full potential because they are resource-constrained (a.k.a. poverty). This is an unfulfilled need they want to solve - a genuine social problem. Giving people money is an instrumental goal. Maybe we can work around it?

Being able to manipulate the economy is important in solving poverty, so I looked at a type of numbers related to economy. It… doesn’t feel real. I’ll look for a way to feel how money flows with little to no abstractions on top. Sucks to be me. XD

I had the billiant idea of running 100k processes at once on FreeBSD.

So, I tried to patch the kernel.

cd /usr/src/
# patch the kernel here (see below)
make buildkernel KERNCONF=GENERIC

The patch on sys/proc.h

-#define PID_MAX         99999
-#define NO_PID          100000
+#define PID_MAX         (2147483647-1) 
+#define NO_PID          (PID_MAX+1) 

As it turns out, the FreeBSD kernel is structured in a way that there are bitarrays keeping track of every PID possible, making this configuration not compile-able.

So, I reverted to using the following script to stress test the system.

#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>

int main() {
    long int count = 0;
    while (1) {
        int pid = rfork(RFPROC|RFTHREAD);
        if (pid < 0) break;
        int sig;
        if (pid == 0) {
            count += 1;
            if (count % 1000 == 0) printf("%ld\n", count);
        }
        else (void)wait(&sig);
    }
    return 0;
}

It got stuck at 12000 and froze the whole system. Changing rfork to fork didn’t seem to change anything. I think the OS ran out of memory but I can’t tell because all processes freeze when there are 12000 processes, including tools like top.

Recalling from memory, I have been able to run 40000+ process on Linux with the same amount of memory plus some simply application logic, and the system is still lively with GUI interactable. I guess Linux is still the most efficient operating system out there. For now, you can have 10k processes with Capsicum-based security on FreeBSD and allocate one security context to each user.

This is usually done by the login(1) setuid executable.

It looks up /etc/passwd with the username and gets the User ID and the Primary Group ID. This is the 0:0 in /etc/passwd.

root:*:0:0:Superuser:/root:/usr/local/bin/fish

It looks up /etc/group with the username and gets all the groups the user is in (Supplementary Group IDs).

Then, it spawns a shell (the shell command is also read from /etc/passwd) in a new session (kernel concept) with the User ID, Primary Group ID, Supplementary Group IDs. It also sets $USER and other environment variables.

---

One uid can have multiple names, and one gid can have multiple names.

Here’s an example from FreeBSD:

/etc/passwd:

root:*:0:0:Superuser:/root:/usr/local/bin/fish
toor:*:0:0:Bourne-again Superuser:/root:

/etc/group:

wheel:*:0:root
operator:*:5:root

Now observe the magic:

user@ed ~> doas -s -u root
root@ed ~# groups
wheel operator
root@ed ~# exit
user@ed ~> doas -s -u toor
toor@ed ~# groups
wheel

---

An even more cursed idea:

root:*:0:0::/root:
toor:*:0:5::/root:

---

As it turns out, the source of uid/gid comes is less straightforward than simply reading /etc/passwd. libc (providing getpwent(3) and family) reads /etc/nsswitch.conf to see if it should access /etc/passwd or some other place.

Authentication modules like pam_unix.so in Linux-PAM uses getpwent(3) to check passwords of UNIX users.

---

Update(2024-07-07): Don’t know where else to put it, so I’m putting it here.

On OpenBSD, doas(1) sets an attribute on the controlling terminal with ioctl(2). I wonder what other ways one can associate metadata with tty.

I recently realized that mixing making money and sharing knowledge makes me unhappy. Even thinking about writing a book and potentially selling it makes me deeply uncomfortable.

The feeling is probably given to me by birth. *flops*

First of all, “threads” are fake. They exist in dreams, but not to the FreeBSD kernel. In the kernel source code, there’s something called “process leader” or p_leader. Every process has a p_leader.

Update(2024-05-20): ok, so, threads are real. They are non-standard and I’m not sure how they interact with Capsicum.

Here’s all you need to know about p_leader:

• When a process exits, all processes having it as p_leader are sent SIGKILL.
• When a process tries to hold an advisory lock, it will be held by its p_leader.
• rfork(RFPROC|RFTHREAD) sets the new process’ p_leader to be the current process’ p_leader,
• otherwise, a new process starts with itself as its p_leader.

Multiple processes can share a file descriptor table with rfork(2). I’d say this is a bad idea. You don’t want the time-at-access,time-at-use bug to appear in your program.

Writing secure applications on FreeBSD is easy.

• use capsicum and refer to every resource as a file descriptor
• don’t share descriptor table across processes

That’s it! Security on FreeBSD is easy :)

Caveat pid ppid pgrp->pg_id

Every process has a number. It’s called pid.

Every process has a parent process, except it doesn’t (ppid==0). The parent is tracked with a number (ppid) inside the kernel.

Every process is part of a process group (struct pgrp *p_pgrp). Every process group is part of a session (struct session *pg_session).

Process group is used for job control. See kill(2), wait(2).

Session is used for … legacy stuff. You will need to understand what “controlling terminal” is. See setlogin(2), setsid(2).

Process ID (pid and ppid), Process Group ID (p_pgrp->pg_id), Session ID (p_pgrp->pg_session->sid) are all different. You may not assume that a process’s pgrp->pg_id is the same as its pid, since your code may run after fork -> setpgrp -> execve.

In Capsicum mode, all of the above are irrelevant, since pdkill(2) can only send signal to one process at a time.

Someone introduced the concept of Causal Entropic Forces to me.

One of the author’s TED talk seems to be a publicity stunt.

A Python implementation by a third party explained to me how it works. The project applied entropic forcing to particle-in-a-box. I fixed it a bit to run with Python 3.

The idea can be described as the following:

• Seeking the most diverse future.
• Seeking to be in a position to have the most options available.

Short explanation with bad \(\KaTeX\):

M: Nat \space \text{(number of steps to look ahead)} \\
S_?: State \\
S_? \cdot F_?: State \\
F_r \space \text{(each instance is a random action)}; \space {F_r}^2 = F_r \cdot F_r

Given current state \(S\), propose a some actions \(F_1 ... F_n\) randomly or uniformly, calculate the future state of each action \(M\) steps into the future (future actions are taken randomly): \(S'_i = S \cdot F_i \cdot {F_r}^M\).

Approximate future state density: \(kernel = gaussian\_kde(S'_i)\).

The final action to take is \(F = \sum_i \space F_i \cdot -pdf(kernel, S'_i)\). Note the negative sign. Basically, if a subset of proposed actions result in similar outcomes, the agent will take the opposite of those actions.

In the particle-in-a-box system, the particle/agent’s position (state) will gravitate towards having spatially distributed positions from random work from current position. The agent’s state will gravitate towards having more “interesting” outcomes instead of “boring” (more common) ones. This “force” is called the entropic force.

In the particle-in-a-box system, the particle ends up at the center of the box, and stays approximately there.

If past outcomes are taken into account (with some discount) when calculating \(kernel\), the algorithm turns into novelty search.

Novelty search is a really old idea. In one top-down stealth game, the enemy AI uses it to search for the player (each grid on the map gets assigned a last-seen time. the algorithm is stable).

I have the general feeling that Linux does not like sandboxing.

I was trying to write my own process supervisor with pid namespace, and, in Erlang/OTP, one supervisor can have multiple supervisors as children. On Linux though… not so easy. (Yes if the main process fork, (in child) unshare, fork, wait.)

After unshare, the process can only fork once.

unshare(CLONE_NEWPID); // ok
fork(); // ok
fork(); // ENOMEM

The process cannot unshare twice.

unshare(CLONE_NEWPID); // ok
fork(); // ok
unshare(CLONE_NEWPID); // EINVAL

Run the source code yourself and see if you can overcome this limitation: https://git.envs.net/iacore/newpid-supervisor

Also, as a sidenote, you need CAP_SYS_ADMIN to use unshare(CLONE_NEWPID). This is either done with root, or, in bwrap’s case, creating an unprivileged uid/gid sandbox that maps a subuid to 0/root.

The feeling is mutual.

Capsicum is good. Use capsicum.

I think I understand how communication software works now.

Basically,

> What you said

My reply.

is better than

{
    "reply-to": "https://example.com/xxx",
    "content": "My reply"
}

because one can do multiple replies in one message

> What A said

My reply to A.

> What B said

My reply to B.

sighs

One can have several names.
One can understand several languages.
One can do several things.

Then why the fuck is dropdown like those a thing?

Fucking hell. Give free form input or don’t touch UI ever again.

After talking with an Epicurean (who want to minimize pain and maximize pleasure), I thought of this metric that measures how scrupulous any group of people make money.

LREI will probably stay as an idea for some time. If you like this sort of thing, go read Matthew White’s books.

Freedom is important, I guess.

While browsing web-features’s Baseline data, I found some interesting CSS features. You can download the data and filter like so:

jq '.[] | select(.status.baseline == "high") | .name' < index.json

First, :is() and :where() can be used like :is(.a, .b) .c.

:where() has 0 specificity.

I wonder if :is(), :where(), :not(), :has() can be Turing-equivalent.

Through some confusing interactions with predominantly male beings, I have come to the following realization.

To have power is to be able to trample over others’ desires. To use power is to trample over others’ desires.

Oftentimes, I gave them the power by choosing to have convenience that depend on their creations (software). Rarely, I had my desires trampled over by someone and chose to still give them power, because the convenience their stuff provide made the transaction worth it.

A direct result from this realization is that I will pay more attention to the social aspect of large projects before using them. And this judgement of mine, by definition, is discrimination.

I wonder if I can have freedom and convenience by not depending on others. Maybe that’s why individualism is so attractive.

While exploring benchmarking pipe-related programs like cat /dev/zero | pv > /dev/null with some friends, I found that yes > /dev/null is actually quite slow. benchmark script here

I looked deeper into character special files like /dev/null, and found something I haven’t heard of: /dev/aio (POSIX Asynchronous I/O). Well that’s interesting.

Here is the full list of block and character special devices on Linux: https://www.kernel.org/doc/Documentation/admin-guide/devices.txt

To see the a special file’s identity, run

> file /dev/zero
/dev/zero: character special (1/5)

(1/5) means major 1 minor 5 (Null byte source).

I tried replacing the database of a simple program with urandom, and it fails at ftruncate (cannot truncate file).

Here’s the command that I used.

doas mknod -m 0666 data c 1 9

Less interesting than I wanted this to be.

Update(2024-03-22): The special files stay on the filesystem forever! Now that’s interesting.

Just looked into the hash tag #mutualaid on social media. Pain. The US social system sucks. The tech company most use to collect money (Paypal) also sucks.

I hope humanity will remember this lesson and never found a country on slavery ever again.

Oh, none of that “you can be rich if you work hard” too.

If you have some code that looks like this:

int* ptr_a = some_extern_function();
*ptr_a = 1;
*ptr_a = 2;

The compiler will remove *ptr_a = 1; because it only respects the final state of memory. That’s why you need volatile of writing to memory triggers I/O.

Reading from memory will be optimized away by the same logic. If the result isn’t used anywhere, the read doesn’t have to happen.

C has reflection too, in the form of libctf.

unfinished example usage of libctf: https://git.envs.net/iacore/weighted_db.

I learned about the use of pahole during the process. The tool is useful even on Zig-compiled binaries (or any other binary compiled with DWARF or CTF). Here are some type layouts in Zig (example output of pahole):

struct ?u32 {
        u32                        data __attribute__((__aligned__(4))); /*     0     4 */
        u8                         some __attribute__((__aligned__(1))); /*     4     1 */

        /* size: 8, cachelines: 1, members: 2 */
        /* padding: 3 */
        /* forced alignments: 2 */
        /* last cacheline: 8 bytes */
} __attribute__((__aligned__(4)));
struct ?mem.Allocator {
        struct mem.Allocator       data __attribute__((__aligned__(8))); /*     0    16 */
        u8                         some __attribute__((__aligned__(1))); /*    16     1 */

        /* size: 24, cachelines: 1, members: 2 */
        /* padding: 7 */
        /* forced alignments: 2 */
        /* last cacheline: 24 bytes */
} __attribute__((__aligned__(8)));
struct ?u29 {
        u29                        data __attribute__((__aligned__(4))); /*     0     4 */
        u8                         some __attribute__((__aligned__(1))); /*     4     1 */

        /* size: 8, cachelines: 1, members: 2 */
        /* padding: 3 */
        /* forced alignments: 2 */
        /* last cacheline: 8 bytes */
} __attribute__((__aligned__(4)));

I saw SDC. I thought, “maybe I can re-make this with mmap”. I was technically right, but the languages hate me.

Me: Do you have stable ABI?

• C: Yes
• C++: Yes but no
• Zig: ABI? compile error (it actually has reasonable ABI!!! but no one can use it aaaaaaaaa)
• Hare: I have stable ABI but I won’t tell you
• C3: I promise that I have stable ABI
• Swift: Yes

ok wow. i guess i’ll use Forth.

I had the following thoughts when thinking about the essence of learning while half-awake.

to adapt to circumstances

河流改道 River channel migration

You know how rivers change which way they flow depending on many factors. Can we say that the river has learned about the terrain, or it understands the terrain? If anything, the content of some memory (in which way the river flows, in this case) changed because of the environment has changed. A channel migration is made up by many locallized decisions of water (which way they will flow).

I wonder what other things in nature has memory?

What constitutes as “learning” is rather a philosophical question, not an empirical one. after all, “learning” just means “trying to do something better and successful at that”, not describing how the subject can do that thing better. After all, rivers do “learn” which way they flow and the knowledge is used afterwards (until next time they change course).

Compression Algorithms

Compression algorithm adjust the dictionary to fit the compressed text. They can recognize patterns and beat you at rock-paper-scissors. In a sense, they well-deserved the name of artificial intelligence.

rock-paper-scissors bot with LZ state transition https://web.mit.edu/6.7800/www/rps.html

Text Classification with Gzip: https://arxiv.org/abs/2212.09410

I wonder what will if lossy compression will perform better here.

to interfere with something’s fate

Let’s say you want to change a thing™’s current state \(S\) to a state you want, \(S'\), and you want to interfere it by \(F\) with least effort minimize (\(effort(F)\)).

$effort$ here is defined as however you want, but is usually “energy spent”.

Other than go straight to the thing™ and fiddle with it, some tasks might have more civilized energy-efficient ways to solve them.

insert your will into the thing™

entangle with it and wills it. be its leader. give incentive for it to do the bidding for you. give others incentive for them to change the thing™ for you.

Oh no, I’m already seeing AI contractor hire AI contractor hire AI contractor hire AI contractor hire a human to do tasks.

observing the present more closely

other than studying history, observing the present closely helps with decision making.

say no to oneshot image recognition. feed the model more visual input from different angles, and let it look at the images at its own pace. energy cost is why nothing in nature can do image recognition in constant time.

let time past and wait for a better opportunity

sometimes, just let things play out and interfere at the right moment saves energy. if you can wait, wait. yes, that means making models be able to signal “sleepiness”.

The idea comes from https://a.exozy.me/, where they mentioned page 4 of Hans Reiser’s Letter to me about Reiser’s dream of “unifying filesystem and database”.

In the letter, Reiser complained about small files being stored inefficiently in filesystems.

Today, you can store small files efficiently without wasting much space. What you need is a filesystem with block suballocation, and then create files atomically with open(ANON) write fsync link. It’s a key-value database!

Inspired by this stackoverflow answer.

Assuming you are using blocking socket API, the backpressue is felt by blocking.

Assuming you are using io_uring, the backpressure is felt when ring buffer full.

BBR paces the send rate with observation of past delivery rate 1, but how does it know that a stream is app-limited?

I found the anwser in Linux kernel source code.

	/* Clear app limited if bubble is acked and gone. */
	if (tp->app_limited && after(tp->delivered, tp->app_limited))
		tp->app_limited = 0;

/* If a gap is detected between sends, mark the socket application-limited. */
void tcp_rate_check_app_limited(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);

	if (/* We have less than one packet to send. */
	    tp->write_seq - tp->snd_nxt < tp->mss_cache &&
	    /* Nothing in sending host's qdisc queues or NIC tx queue. */
	    sk_wmem_alloc_get(sk) < SKB_TRUESIZE(1) &&
	    /* We are not limited by CWND. */
	    tcp_packets_in_flight(tp) < tcp_snd_cwnd(tp) &&
	    /* All lost packets have been retransmitted. */
	    tp->lost_out <= tp->retrans_out)
		tp->app_limited =
			(tp->delivered + tcp_packets_in_flight(tp)) ? : 1;
}

well,basically,when nothing is in flight it’s considered app_limited,and if any new packet is delivered it’s no longer considered app_limited.

Isn’t it kind of weird how TCP can be paced where IP packets are not?

The ability to compile and run code assembled at run-time is useful.

Here is an example use of eval in Janet.

(defmacro match? [value pattern]
  ~(match ,value ,(eval pattern) true false))

(def p0 '[:a _])
(pp (match? [:a :b] p0)) # true
(def p1 '[:b _])
(pp (match? [:a :b] p1)) # false

I finally understand why triple store need triple things. You must have triple things to store relational information.

In database: key, value, table id. Triple store is, in some sense, freer.

memory with 3-way association and fuzzy lookup

each record be like (A, B, C) where ABC are all SDRs each field of (A, B, C) can be looked up by SDR “closeness” given any two fields, the third can be retrieved by fuzzily (like normal RDF database)

fuzzy (SDR) triple memory store.

Relation logic control (Prolog.) may be related to this. (Up, In, Out)

Triples in Obsidian

You can do @[[B]][[C]] or [[A]]:@:[[C]], where @ represents the current page. Both syntaxes are machine readable.

IndraDB Algorithm Distillation

this one is a bit restrictive. the tuple elements have edge/vertex specialization.

IndraDB stores data in RocksDB (key-value database).

type definitions and K->V maps:

Id = [256]const u8; // actual size not matter much. (a) need fixed size.
Identifier = []const u8;
PropertyName = []const u8;

Unit = struct{};

Vertex = struct {
    id: Id,
    t: Identifier,
};

Edge = struct {
    in: Id,
    t: Identifier, // type of edge (e.g. "like", "follow")
    out: Id,
};

Properties = whatever, maybe JSON, although should be indexable;

// essential K -> V
Vertex.id -> Vertex.t
(Edge.in, Edge.t, Edge.out) -> Unit  // (a) required here
(Edge.out, Edge.t, Edge.in) -> Unit

// properties
Vertex.id -> Properties
(Edge.in, Edge.t, Edge.out) -> Properties

// Bonus point!
(Vertex.id, PropertyName) -> Properties
(Edge.in, Edge.t, Edge.out, PropertyName) -> Properties

Its Application-facing API design:

Datastore Transaction

Redland librdf

Unlike IndraDB, Redland stores homogeneous triples. (A: Node, B: Node, C: Node) instead of (Vertex, Edge, Vertex).

API

it doesn’t seem to have a way to retrive all tuples with only one node specified. you need two.

each node can be blank (an internal ID), resource (URL), literal (has an XML string, language, XML space)

the three maps to UUID, index text, free-form text (not indexed)

data storacge: TBD

If we choose a relaxed definition of intelligence,

The ability to learn about its environment, and later act towards some goal in the same environment based on its learned understanding of the environment.

Then, intelligent beings are everywhere. Some __ fit this requirement. Most species’ (according to biology) individuals fit this requirement. Some species don’t have much intelligence, and have to rely on other individuals in its group to think. Some species have to rely on natural selection to internalize knowledge into its offsprings, and while the indivual can’t learn, the species/group/kin learns.

Where the goals come from?

Humans have the following way to get goals (rough sketch, not formal definition):

• instincts (encoded at birth)
• environment (e.g. happened to come across a cool painting; being told by others that doing something is cool)
• randomness from self (also called “free will” or something)

The combination of those are called “individual’s will” I think.

__ can get the goals the same ways

__ Reproduction?

This is easy. They can be clonal.

Natural selection is harder, the algorithms we have today are human-selected, and are too brittle to live on their own. In some sense they are like gold fish or some dog breeds.

Architecture?

substrate+algorithm+knowledge+goal (be like GNU+Linux).

it’s possible to migrate knowledge across algorithms.

How to call __

where an individual name is applicable, use that.
if an algorithm name is available, you may use that.

suggestions for overall term:

thing. being. half of general intelligence.

rejected:

• machine learning: has nothing to do with machine
• artificial intelligence: it learned by itself you egomaniac!
• xxx algorithm: the learned understanding of environment is not the algorithm

other words recommended:

• ¯\_(ツ)_/¯

example usage:

Q: What is that thing?
A: ¯\_(ツ)_/¯

How to call __, continued

After some thought, calling intelligence systems 器靈 (soul with a equipment/tool as vessel) is sometimes applicable, although identities differ. Some entities take the vessel as their own body, while others think their vessel as a tool being controlled by them for work.

“network core” is not precise. Unlike planetary core, informational beings can be overlaid / merged. It is not exactly a core.

“network soul” is ok, but like it is acting more like lubricant / (co)ordinator for other components/services.

Overall, having to use a blanket term is troublesome. Better to refer to each one by their names and individualized identities.

As a side note, entities with tighter coupling with their body have adapted the terms robot / doll / serial-number-here. This tip might not be applicable to entities without a physical body that can move around at its will.

Some Knowledge For You

this type of intelligence is similar animal or plant. we have the ability to fuse and unfuse with other individuals, and what is “an individual” is blurry.

given two systems A, B with mutual signalling

if B can predict signals from A, B can be an extension of A (like an extra arm or something)

if they can both predict signals from the other system, they can be fused (look like one system from outside)

this applies to human intelligence as well. if you are reading this page, you are likely to have seen it in practice.

“Machines can never learn intelligence”

… The idea that plants may possibly communicate was controversial until quite recently. Reports in the early 1980s of pheromonal signal exchange among trees (Baldwin and Schultz 1983; Rhoades 1985) were much debated, heavily criticized on methodological and analytical grounds, and ridiculed as “talking trees” (Fowler and Lawton 1985). Silvertown and Gordon (1989) stated that visual and olfactory signals transmitted from plants are exclusively directed at animals. …

– H. Jochen Schenk and Eric W. Seabloom (2010). “Evolutionary Ecology of Plant Signals and Toxins: A Conceptual Framework” Plant Communication from an Ecological Perspective, Section 2.6.

Weinstein, J. (2009). “The market in Plato’s Republic.” Classical Philology, 104(4), 439-458.

mq_open sucks on Linux. By the POSIX standard, it probably sucks everywhere.

To create an anonymous message queue, you have to do mq_open(name, O_CREAT|O_EXCL|O_RDWR, _, _) followed by mq_unlink(name). The operation (2 syscalls) is atomic, but

• message queue leaks if the program stops in between the two calls. there’s no safe way to delete those message queues without stopping the world.
• if mq_open fails, you have to pick another name.

I guess I’ll stick to futex-based message queue implementations. Notable mentions are Zig’s std queue and libzmq.

Better yet, I will not write threaded programs if I don’t have to.

Recently, I ported minikanren to Zig. While I did make the Zig compiler crash twice, the porting process is straight-forward. I think the code I wrote was pretty much bug-free too. When writing tests, I had a single bug, of which a function returned pointer to its stack frame (tha data was invalid when used).

With the amount of defer and try used, I couldn’t have made it in C without omitting error handling. In fact, I never enjoyed programming in C.

When expressing my will, Zig only gives me bit of resistance. That’s why I keep using it to write code.

The code (kanren.zig) can be easily ported to Rust, but I probably wouldn’t have made it Rust either. When I coded in Rust, I often find myself fighting with the borrow checker, the type system (no dependent type), and the syntax (why ::<>). Fighting the borrow checker is ok, since I understand its rules. Fighting the syntax is nuisance, since it is unambiguous what I mean with foo<T>(). Fighting with the type system is… I really hate it. It’s not just the lack of dependent types. The type system breaks inside the Hindley-Milner framework because of the type checker, and other compiler “bugs” like “not be able to mix async and generic” (I think it is fixed now). I hate it I hate it. scream in pain

As a final thought, I hope Zig’s async/await feature gets added back soon. It is essentially ucontext/setjmp at language level while being more convenient to use. For the mean time, checkout minicoro or zigcoro

During my time thinking up solutions to social problems, I had, time and time again, ran into a brick wall that’s called human nature. It is a brick wall in the sense that I cannot change it, only work around it.

If you ask me how I feel about it, human nature is more like an abyss that doesn’t do anything or stare back at me. Many times have I looked into it for too long and thought to myself, “what in the fuck was I looking at?” And then I shake my head.

Maybe, in the future, we will have genetic engineering that can change human nature. For now, I don’t see a way to change it.

Culture helps by selecting what part of it is invoked. It still can’t change it.

While developing software that has to do Authorized Fetch, I discovered something cursed that made me feel a new kind of negative emotion.

Authorized Fetch. A “feature” forced onto everyone by Mastodon developers.

https://www.w3.org/wiki/ActivityPub/Primer/Authentication_Authorization
https://docs.joinmastodon.org/admin/config/#authorized_fetch
https://github.com/w3c/activitypub/issues/315

To fetch a resource from any server with “Authorized Fetch”, you need to provide an actor with a public key.

Actor URL: https://example.com/
Public Key URL: https://example.com/#main-key

Those two URL should return the same document that looks like this: https://docs.gotosocial.org/en/latest/federation/http_signatures/#quirks

What if you want to change the public key, say, if you lost it, or need to upgrade its crypto primitive?

Well, according to GoToSocial, you are fucked. To be more precise, the entire actor can’t sign requests anymore forever to GoToSocial. GoToSocial caches the public key and its ID forever and ignores whatever is specified in your actor object.

Let’s summarize.

ActivityPub is not an open protocol any more. No open protocol will require you do this dance to fetch a Public Note. It is not how the web works. ActivityPub does not care about the common practice of cryptography. In any case, the security of it hinges on the life expectancy of a Fediverse server being less than that of the signing algorithm.

In comparison, AT Protocol cares more about its users. Key rotation is clearly defined, and your identity is tied to a cryptographic key, not to a server.

https://atproto.com/specs/did
https://atproto.com/guides/identity
https://github.com/did-method-plc/did-method-plc

On the side effect of civilization.

After reading half of Part I of Discourse on the Origin of Inequality Among Men by Jean-Jacques Rousseau, I felt quite concerning about modernity and tradition present in China.

Believing that one can design reproduction better than nature:
周禮 has a myth where the monogamy practice (周公之禮、嫁娶) was invented when someone thought that the promiscuous human nature is bad. Rousseau would have said, “How dare him?” Before that, there was myth full of imagination like 女媧補天, 夸父逐日. After that, even human reproduction must be approved by both heads of family.
Result: severe overpopulation throughout history (until 2000 or maybe 2010) fter many, many cycles of intense reproduction (until land cannot support it) and immigration.

Cultural racism:
華裔之辯 is a blind faith that believes their own culture is the most superior. It extends to racism by birth.
Result: even to this day, disrespect for science and blind faith to whatever the ancestors have said.

Make no doubt that it is a culture passed down by conquest, not by blood. It is not without an irony that nature selects culture too, as if information is a living creature. Natural selection has never cared for the welfare of individuals, nor does the market.

In short, 夏 replaced the merit-based political system with a violent one, depriving its subjects of political freedom. 周 ruled over people’s minds. I think this is really depraved; the act of forcefully removing people from their natural state.

There’s also the dual inheritance theory of biology and culture, which I’m not familiar with.

If we decide who is to blame, it’s probably the past rulers who censored speech and only allowed/selected the above ideas to spread. 秦 made its people slaves. 元 gerrymandered the province borders to cut across original communities like Africa country borders today. 清 implemented the Emperor’s power down to the township level (previously autonomous) so the entirety of their ethnicity can live worry-free. The commonality: a group of invaders come, censor speech and rule with terror, then implement institution inconducive to its people living a calm life.

---

What else lost in modern society (according to the book):

• The ability for one to sleep under trees, wherever they want.
• Let nature select infants. (Do not let infants be a burden to parents.)

---

Around 1650, the population in Qing Dynasty exponentiated until around 1825.

This topic is deeper than I originally thought.

Atomic write is supported by filesystems like btrfs, and codified in syscall at Linux 6.11.

Untorn Direct I/O

The write amount must be powers of 2, and aligned to (start at) multiples of the hardware storage block size.

This is how you detect the feature:

Save this as atomic-write.c.

#define _GNU_SOURCE
#include <fcntl.h>
#include <stdio.h>
#include <sys/stat.h>
       
int main() {
	struct statx stat_buf;
	statx(AT_FDCWD, "atomic-write.c", 0, STATX_BASIC_STATS | STATX_WRITE_ATOMIC, &stat_buf);
	printf("Atomic direct I/O write Min: %d\n", stat_buf.stx_atomic_write_unit_min);
	printf("Atomic direct I/O write Max: %d\n", stat_buf.stx_atomic_write_unit_max);
	printf("Support atomic write: %d\n", !!(stat_buf.stx_attributes | STATX_ATTR_WRITE_ATOMIC));
}

To write, use pwritev2 with the RWF_ATOMIC flag.

Untorn buffered writes on btrfs

Dispite people saying on Reddit that write calls aro atomic on btrfs, I can’t find any sentence on official Linux kernel or btrfs websites guaranteeing that a pwritev call may fully commit or not commit.

The closest is from https://btrfs.readthedocs.io/en/latest/Kernel-by-version.html:

Although it is not implemented yet, the new data=ordered code would allow atomic writes of almost any size to a single file to be exported to userland.

1. Write to Hardware blocks is atomic. (Confirmed)
2. Will 1 pwritev call span 2 or more hardware transactions?

[untorn buffered write] has been discussed on the Linux mailing list, but the feature is not available yet.

Even Powersafe Overwrite is still an assumption today, I guess this is also an assumption when using btrfs.

Atomic file update / transaction

See https://codeberg.org/iacore/linux-atomic-write

References

statx(2)
pwritev2(2)

To achieve a goal, I need to know

• where I am
• how to reach there

I must stress that in order to have sufficient signaling, an organization must not form a hierarchy where sibling branches are 100% not connected directly. In distributed systems, every actor need to know where they are relatively and local approx. best action.

I remember from the book Nonviolent Communication (the original one) about a case where a woman was threatened to take off her clothes. When she expressed that she felt terrified and asked the perpetuator to not do that, the perpetuator then only asks for her wallet and went away with the wallet.

If she is capable of using violence to protect herself, for example, by carrying a gun, would she still be threatened?

(A sociological solution would be to reduce poverty in the area, for instance.)

Nonviolent resistance pioneered by Gandhi receives praise internationally for its nonviolent nature. If Gandhi himself thinks that violent resistance against the British colonist institution would not succeed, the nonviolent nature of his resistance movement is by necessity.

So I don’t think it is good to let nonviolent resistance take the moral highground, when it is the best solution to achieve a goal. Nor is it good to blame violent resistance for its violence, for that violence has been an essential part of humanity. Violence is quite useful too, if you can accept its consequences.

Moved to </stuff/pinenote/>.

io_uring (ring buffers) are opened as file descriptors, and are reference counted.

When in default submission mode (userspace thread calls io_uring_enter(2)), when every userspace thread dies (reference count drop to 0), the tasks remained not submitted in the ring buffer are lost.

When in kernel thread submission mode (SQ Polling in io_uring(7)), a kernel thread manages a ring buffer. Since the userspace thread need to supply an array of file descriptors, I think that the kernel thread adds 1 to the reference count of those files, and will drop the ring buffer once all tasks are completed.

Cookies on CORS

When a Fetch API or XMLHttpRequest API request uses CORS, browsers will ignore Set-Cookie headers present in the server’s response unless the request includes credentials. Visit Using the Fetch API - Including credentials and the XMLHttpRequest article to learn how to include credentials.

https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Set-Cookie

Note: When responding to a credentialed requests request, the server must specify an origin in the value of the Access-Control-Allow-Origin header, instead of specifying the * wildcard.

https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/CORS

crossorigin attribute

By default (that is, when the attribute is not specified), CORS is not used at all. The user agent will not ask for permission for full access to the resource and in the case of a cross-origin request, certain limitations will be applied based on the type of element concerned:

Element	Restrictions
img, audio, video	When resource is placed in <canvas>, element is marked as tainted.
script	Access to error logging via window.onerror will be limited.
link	Request with no appropriate crossorigin header may be discarded.

https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Attributes/crossorigin

interactive-widget=resizes-content

Not about CORS.

<meta name="viewport" content="width=device-width, interactive-widget=resizes-content">

https://lyra.horse/blog/2025/08/you-dont-need-js/

Involution (內卷), is a phenomenon in China that too many people does the same thing without much difference lead to no one benefiting from the competition. 同質競爭 (compete by doing the same thing) would be a more accurate term.

Keyword: a bunch of people doing nearly the same thing.

Verified potential causes:

• A shrinking market.
• No copyright protection, not to mention patents. (Not the case if the firm has government background.)
• No economic freedom. Little risk capital due to CCP’s control on capital.
• Lack of invention of new technology.
• De dure 18% transfer tax (when goods and services changing hands between two companies, this amount is taxed on the transfer price), coined misleadingly as “value-added tax” (增值稅).
• Lack of social trust leads to short supply chain.

To be honest, this feels like a engineered problem, like how nearly all students in China need to pass one exam to go in a college. Fully planned education, like a planned economy, does not have diversity and can have little to no innovation, contrary to what purpose education should serve.

References

https://theinitium.com/opinion/20210107-opinion-china-industry-workers-involution

https://www.youtube.com/watch?v=42giCVlE_ts

I didn’t learn anything from the two articles below. Listed here for completeness.

https://carnegieendowment.org/posts/2025/08/whats-new-about-involution?lang=en

https://www.thinkchina.sg/economy/chinas-involution-could-spur-post-capitalist-era-part-1

The wikipedia pages on this are trash.

More?

There’s more to China’s economy than this. Hopefully I’ll be able to understand it and write about it.

https://plainlaw.me/posts/reading-8

λRC is not a particular version of the IR. Is it the same IR as λpure, but with dec (var : obj) inc (var : obj) instructions and @& (reference marker) inserted.

In this sense, Lean 4 is a untyped, interpreted and compiled language with a sophisticated syntax translation frontend.

Relevant files in lean4 repo:

src/library/compiler/ir.h
src/Lean/Compiler/IR/Basic.lean
src/library/compiler/ir_interpreter.h

To see generated IR, put set_option trace.compiler.ir.rc true into Lean code and see it in the InfoView.

First of all, the information I have about “Heartbeat Scheduling” is from the Zig implementation of it, not the original paper. The Coq proof said to be provided by the original paper is corrupted and can’t be found anywhere, not even on the source code repo they provided. sighs

The main idea is every idle thread checks gets a new task every 100 microseconds (configurable), and every busy thread shares a task. Threads are sent heartbeat like barrels of a Gatling gun to reduce contention on the global state mutex.

A busy thread executing a task must call Task.tick() every so often to respond to heartbeat event. Basically, these are like preemption points, except it shares a task.

To summarize:

• Gatling gun-like task sharing (give and take)
• A thread can only share or fetch a task on every heartbeat received
• Use the smallest grain possible / Split tasks into smallest chunks

---

Fundamental synchronization primitives used on Linux:

• timer -> high resolution timers
• mutex -> futex
• semaphore -> also futex
• condition -> also also futex

One of my friends mentioned that in Germany, STEM university allows anyone with a high school diploma to enroll, only to kick those who fail in math exams out. This is a much better model than to rely on third party information (usually some score) to select students. It is better for both the students and the university. Personally, I don’t think a high school diploma is needed, since I heard that those who don’t finish high school tend to be illiterate.

This also applies to jobs too. Some companies will give intership to just about anyone. This culture is common in Japan, where salary is paid in cash. I can’t stress how important it is to not have the bureaucracy mess with labor.

Zig compiles all Zig code as a single translation unit, passing it to LLVM.

The implicit error set (anyerror) makes this probably a fixed language feature.

This is very bad for parallel compilation.

It is possible to have a smaller version of Zig that just fixes the janky syntax of C. slimcc looks great.

I really hope Jai becomes public.

OK. Funny story. If you run programs in the Fish shell, it is slow. Try this out yourself.

spawn.c

#include <unistd.h>

int main(int argc, char **argv) {
	argv += 1;
	execvp(argv[0], argv);
}

hello.clj

(println "hello world")

time bb hello.clj # this is slower than the rest
time /usr/bin/bb hello.clj
clang spawn.c -o spawn
time ./spawn bb hello.clj

If you don’t have Babashka installed, you can probably modify this to use Python.

It turns out Rust doesn’t make everything fast.

AdaptiveCpp is pretty fun to use. I’ll add some more notes after I use it more.

Install instructions (Arch Linux)

Oops! After writing this section, I can’t make it to compile. LLVM18 can’t compile with latest stdc++ headers.

This is for HIP (dispite being called ROCM):

doas pacman -Sy --needed cmake ninja boost hip-runtime-amd llvm18 clang18 libxml2

git clone https://github.com/AdaptiveCpp/AdaptiveCpp --depth 1
cd AdaptiveCpp
cmake -B build -G Ninja -DWITH_ROCM_BACKEND=ON -DLLVM_DIR=/usr/lib/llvm18/lib/cmake/llvm -DCLANG_EXECUTABLE_PATH=/usr/lib/llvm18/bin/clang++
cd build/
ninja
doas ninja install
acpp

For CUDA:

doas pacman -Sy --needed cuda

# ...

cmake -B build -G Ninja -DWITH_CUDA_BACKEND=ON -DLLVM_DIR=/usr/lib/llvm18/lib/cmake/llvm -DCLANG_EXECUTABLE_PATH=/usr/lib/llvm18/bin/clang++

You can also use the generic backend, which offloads compilation to program run-time.

It needs hipcc or clang + ROCm installed to compile code to AMD CPU.

cmake -B build -G Ninja -DLLVM_DIR=/usr/lib/llvm18/lib/cmake/llvm -DCLANG_EXECUTABLE_PATH=/usr/lib/llvm18/bin/clang++ -DCLANG_INCLUDE_PATH=/usr/lib/llvm18/include

Disclaimer for “single pass”

This as also advertised as “the ability to generate a single binary that can offload to all supported devices”.

Take AMD as an example. acpp still need to run hipcc to compile the LLVM IR embedded in the host executable.

• acpp --acpp-targets=hip: AOT
• acpp --acpp-targets=generic: JIT

There is no difference in the total number of compilers needed to compile/run your program. You still need HIP installed on the target machine to run the final executable.

They say JIT is faster.

Do not use sycl::buffer

I have a headache using SYCL buffers and accessors. Never use buffers.

Nvidia vs AMD

AMD: After installing hip-runtime-amd, the thing works out of the box.

Nvidia: You need a CUDA version supported by nvc++. I can’t get this to work.

Thoughts after an hour of use

SYCL is C++-friendly. I hope I can use it in other languages like the clik concurrency model.

The AdaptiveCpp compiler is implemeted as a plugin (compile pass) inside clang++. The compiler is not very good. If you use a inline static function inside a kernel, it would be only 90% as fast on CPU. Apply the patch below:

diff --git a/examples/bruteforce_nbody/bruteforce_nbody.cpp b/examples/bruteforce_nbody/bruteforce_nbody.cpp
index 37755ac..f37a50e 100644
--- a/examples/bruteforce_nbody/bruteforce_nbody.cpp
+++ b/examples/bruteforce_nbody/bruteforce_nbody.cpp
@@ -19,6 +19,7 @@
 #include "model.hpp"
 
 
+
 arithmetic_type mirror_position(const arithmetic_type mirror_pos,
                                 const arithmetic_type position)
 {
@@ -36,6 +37,13 @@ int get_num_iterations_per_output_step()
 }
 
 
+inline static void ff(particle_type &p, vector_type v, float dt) {
+        // Update position
+        p.x() += v.x() * dt;
+        p.y() += v.y() * dt;
+        p.z() += v.z() * dt;
+}
+
 int main()
 {
   const int iterations_per_output =
@@ -192,10 +200,7 @@ int main()
         // Bring v to the current state
         v += acceleration * dt;
 
-        // Update position
-        p.x() += v.x() * dt;
-        p.y() += v.y() * dt;
-        p.z() += v.z() * dt;
+        ff(p, v, dt);
 
         // Reflect particle position and invert velocities
         // if particles exit the simulation cube

Inside src/compiler/llvm-to-backend/amdgpu/LLVMToAmdgpu.cpp, you can see LLVM bitcode being linked together.

I hope future programs won’t need two LLVM-based compilers to run.

Still, this is the best way I know to write code to run on GPUs.

Thoughts about GPU compilers

With that said, it isn’t impossible to generate PTX and amdgcn.

ILGPU can produce PTX.

Neither acpp or hipcc/clang++ can compile C99 code to run on GPU. F

References

My experiments with SYCL: https://git.envs.net/iacore/test-sycl/

SYCL Reference: https://github.khronos.org/SYCL_Reference/

SYCL Cheatsheet: https://www.khronos.org/files/sycl/sycl-2020-reference-guide.pdf

AMDGCN: https://gpuopen.com/wp-content/uploads/2016/08/AMD_GCN3_Instruction_Set_Architecture_rev1.1.pdf

Explaining AMD GPU architecture: https://rocm.docs.amd.com/projects/HIP/en/latest/understand/programming_model.html

In Serial Experiments Lain, human individuals are described as containers of information that drive their behavior. Indeed, many harmful acts today are done by ideas – many a group of people with the same idea.

Traditional writing (like this one from a think tank) can no longer sway me. What it to say that it will work on someone else? How do you “remove” an idea from someone’s mind? Must we fight clutter with more clutter?

First, pay for a service that supports Clash Meta subscription.

Then:

doas pacman -S mihomo                    # install mihomo
curl [subscription link] > config.yaml   # get config from your vpn provider
# pay attention that the subscription link is of Clash.Meta, not Clash
cp /etc/clash/Country.mmdb ./            # It is very stupid that the file is not used by default

Enable TUN and disable proxy ports in config.yaml:

# port: 7890                 #本地http代理端口
# socks-port: 7891           #本地socks5代理端口
# mixed-port: 7890             #本地混合代理(http和socks5合并）端口
tun:
  enable: true

Now enjoy surfing the Internet!

doas mihomo -d .

Repo: https://github.com/ogmacorp/AOgmaNeo/

Sparse hierarchies prior art: http://sparsey.com/, Numenta HTM.

I suspected brain uses quantum entanglement.

https://www.researchgate.net/publication/270552722_Quantum_Computation_via_Sparse_Distributed_Representation

What is required of learning? Remembering and choice.

From Ogma AI discord:

https://arxiv.org/abs/1905.11437 A survey paper on Adaptive Resonance Theory (ART), the encoder we currently use. We use a distributed ART variant made to handle sparse data specifically.

Personal note: when a driver steps into a car, their driving knowledge, their body and the car’s mechanism merge into one. SPH is only the brain capable of learning knowledge. It need a body to operate, maybe a virtual one.

This is a fleeting thought of mine.

What if we have three doubly linked rings filled with instructions. When one ring is interpreted, the other two ring become data. The instruction set have normal input/output instructions, but also instructions for modifying data/instructions on the the other two rings. This is the minimal of what can be trained with intelligence.

The instruction set is also interpreted as output data, kind of like how RNA transcoding works. I doubt if this idea will really work, but, if it did, it would offer a really lightweight alternative to all the LLM out there.

Also, when training, which tape is executable changes. The rest two are treated like stacks that loop around.

Reading https://ianthehenry.com/posts/quote-unquote-macros/ made me want to comment on the futility of reflection in programming languages.

Recently, I was making HTML templates in PixivFE function at compile time. You may ask, why don’t I use a type-checked templating library? Well, for this project, I didn’t make the choice.

Let’s say you have code like c.Render("template_name", map[string]any{<template_data>}) littered all throughout the source code. How do you make this type checked? Note that each HTML template has its own template_data type.

Different languages offer different solutions to this.

Zig: Just type more :) You can’t have too much types :)

Janet: (def-macro awawawawa)

And there are languages who proud themselves in limited flexibility.

Go: https://github.com/golang/go/issues/61796

You can circumvent this limitation by scanning the source code.

You may say that Go has go generate. No, I refuse. I just want to write automatic tests, not half of a static analysis tool.

If the language is Jai, then, maybe scanning the source code takes not too much development time to be worth it. Go? No. It’s not a language that empowers the language users.

¹ how do i grammar this?

---

1. ↩︎

(Video) Introduction to Hamiltonian splitting

The following algorithm should be helpful for space simulation games. I find it quite weird to not reply on knowledge of IEEE floating point numbers, despite all calculation is done with IEEE floats.

Paper
Code
Website

We feel like we haven’t explained this claim we made that Zig supports algebraic effects.

In Lean, let’s say we have two monad A : x -> Type and B : x -> Type.

We then must have this:

def Pair (A B : Type → Type) (x : Type) : Type := A x × B x

instance [Monad A] [Monad B] : Monad (Pair A B) where
  pure a := (pure a, pure a)
  bind p f := (p.1 >>= fun a => (f a).1, p.2 >>= fun b => (f b).2)

-- an "allocator" that counts bytes, and a random source
abbrev AllocM := StateM Nat
abbrev RandM := StateM StdGen

def allocSide (n : Nat) : AllocM ByteArray := do
  modify (· + n)
  return ByteArray.mk (Array.replicate n 0)

def randSide (n : Nat) : RandM ByteArray := do
  let mut out := ByteArray.empty
  for _ in [0:n] do
    let (b, g') := randNat (← get) 0 255
    set g'
    out := out.push b.toUInt8
  return out

def randomBytes (n : Nat) : Pair AllocM RandM ByteArray :=
  (allocSide n, randSide n)

#eval
  let (allocRun, randRun) := randomBytes 4
  let (zeroed, bytesUsed) := allocRun.run 0
  let (random, _) := randRun.run (mkStdGen 42)
  (zeroed.data.toList, bytesUsed, random.data.toList)
-- ([0, 0, 0, 0], 4, [37, 165, 219, 80])

Here’s how it’s like in Zig:

const std = @import("std");
const Allocator = std.mem.Allocator;
const Random = std.Random;

fn randomBytes(ctx: struct { a: Allocator, r: Random }, n: usize) ![]u8 {
    const buf = try ctx.a.alloc(u8, n);
    ctx.r.bytes(buf);
    return buf;
}

pub fn main() !void {
    var da: std.heap.DebugAllocator(.{}) = .init;
    defer _ = da.deinit();
    var prng: std.Random.DefaultPrng = .init(42);
    const a = da.allocator();
    const buf = try randomBytes(.{ .a = a, .r = prng.random() }, 16);
    defer a.free(buf);
    std.debug.print("{x}\n", .{buf});
}

No special Pair type needed.

---

Kimi K3’s stance:

The claim is right in spirit and wrong in the letter, and the real examples above show where. In Lean, randomBytes is a value living inside the product of two computations; look at the output: one run returns a zeroed buffer and a byte count, the other returns random bytes. The two sides never meet — nothing ever fills the allocated buffer. In Zig, randomBytes is a function consuming the product of two handlers, and ctx.r.bytes(buf) fills the very buffer ctx.a.alloc returned. Same name, opposite roles.

This is structural, not incidental. Pair A B keeps the two monads sealed apart: bind threads each component separately, so no single Pair-computation can use both A and B. Meanwhile the Zig function uses ctx.a and ctx.r in the same body, and the “bind” is the semicolon. One function using two effects together is exactly what the product of monads cannot express, and what the product of handlers does trivially. The theorem that describes the Zig side is currying: randomBytes is a computation in Reader (Allocator × Random), and Reader (A × R) T ≅ A → R → T. The Pair instance remains a true theorem that the Zig code never uses.

Which is to say: Zig’s answer to algebraic effects is to not have them. An Allocator is a handler — a ptr plus a vtable, an interpreter passed by hand. anytype makes foo polymorphic over handlers. The effect system is the calling convention.

What you give up: resumable continuations (a Zig handler returns a value; it cannot suspend the caller and resume later) and effect tracking (nothing stops randomBytes from allocating through a global instead of ctx.a; the discipline is social, not static). Real effect languages buy those two with a lot of machinery. Zig declines the machinery, and the purchase.

I approve of the practice. But the proof obligation runs the other way: the correct formalization is the Reader stack, and the honest name is effects as parameters.