I have made libredo, a Zig library for dependency tracking. The source code is here.

The Story

A few months ago, I stumbled upon SolidJS and liked it for its well-designed “reactive signals” API. It did make me wonder if I can port such a library to Zig and write Solid-like UI code with it.

A week ago, I began porting such a “reactive signals” library to Zig. I chose trkl as my reference, since it has only a few lines of code. trkl uses a lot of closures internally, and it demands the language (Javascript) to have a garbage collector. Zig has neither of those two features, so it’s time to improvise.

It took a week of me sleeping on the idea to know how to design the library’s public interface.

I wasted another two days searching for a fast-enough core algorithm for the library. Initially, I tried using an array to store edges of the dependency graph unordered. It was too slow. On the second try, I used two hashmaps of hashsets, but that was slower. “This is not working out well,” I thought to myself, “time to steal learn ideas from other people.”

At first, I did not know what to learn from. Suddenly, a thought struck me: build systems have similar goals as this “reactive signals” thing – they keep track of dependency between tasks, and invalidate a build target when any of its sources change. “I can probably learn from build systems,” I thought.

I consulted tup. It does not support dynamic dependencies – not useful. I then consulted redo, since I remembered it supports individual tasks declaring dependencies while running. That was an exact hit – so exact, that the dependency tracking algorithm used by redo and Solid are the same! The data structure in redo was provided by SQLite. Although I can’t copy SQLite’s code, so I mimicked the SQLite table and used an array to store edges of the graph sorted. It works, and is fast enough. Mission Accomplished.

That’s the story of how I made libredo.

The Algorithm

Here’s my futile attempt at explaining the dependency tracking algorithm.

Every non-leaf (“not source file”) task has a dirty bit. The bit is set when the task is created. If the task is dirty, run it, and remember its dependencies (used during the run). If the task is not dirty, it is up-to-date, so don’t run it. When any source file changes, mark its recursive dependents as dirty.

The algoritm doesn’t care about how to do any task. When a task is dirty, the user provides what new dependencies the task will have, and mark the task as clean (the user usually does this after doing the task, like building an executable file). The user can also choose to keep the task dirty, and not do anything immediately (or ever).

Here are two examples from Solid and redo respectively. The two examples are isomorphic to each other. You need knowledge of Solid or redo to understand the examples. In both examples, the act of “doing the task” is done by running some code the user provides. In the Solid example, dependency is tracked automatically. In the redo example, the dependencies are declared explicitly with redo-ifchange. My library provides API for both styles (please read the source code, it’s somewhat commented).

Example 1: Solid

import {createSignal, createMemo} from 'solid-js'
const [a, setA] = createSignal(0)
const [b, setB] = createSignal(1)
const c = createMemo(() => a() + b())

c()      // line 1
c()      // line 2
setA(2)  // line 3
c()      // line 4

Example 2: redo

First, create the shell script main.do with the following content.

redo-ifchange main.c aux.c
gcc -o main main.c aux.c

Then run the following shell script:

redo-ifchange main  # line 1
redo-ifchange main  # line 2
touch main.c        # line 3
redo-ifchange main  # line 4

Explanation

I’ll use the task names a, b, c from Example 1 in this explanation. It applies to Example 2 when you change the names to main.c, aux.c, main. Mathematically, the names are irrelevant.

In the following graphs, arrows point from dependent to dependency.

Initially, the dependency graph looks like this:

c is dirty because it was just created. Nothing is connected yet.

At line 1, c is run because it is dirty. When c runs, the algorithm notes that c uses a and b, and remembers that.
The graph looks like this afterwards:

At line 2, nothing is run, because c is not dirty.
The graph afterwards:

At line 3, a is changed. The algorithm marks recursive dependents of a (in this case, only c) as dirty.
The graph afterwards:

At line 4, c is run because it is dirty. When c runs, the algorithm notes that c uses a and b, and remembers that. (In this example, the direct dependencies of c don’t change. Nevertheless, the algorithm remembers c’s “new” dependencies.)
The graph afterwards:

My Thoughts On This

This seems like another case of a mathematical concept independently discovred twice. It surprised me that I don’t know other kinds of software that uses this algorithm (apart from build systems, and recently, Web UI), given that the algorithm is very useful for any application related to caching. Maybe I just don’t know enough software.

I feel that this algorithm may be adapted to work across multiple machines. Personally, I don’t need this feature. If you know such a thing exists, tell me!

I also don’t know if this algorithm has a name. If you know, tell me!

Update: Nikhil said that this field is called “incremental computation”.

Update: Andreas Reuleaux said that haredo is a viable alternative to redo.

Update (2025-08-11): Solid has other nice features like createEffect and replay events between page load and hydration (which React, to this day, neglects). Its dependency tracking system has not changed since then.

Notable mentions:

• voby – Observable-based reactive system + web framework with same math behind it
• streamix – lightweight observable library

Note that Solid effects only happen within a microtask. During successive updates to a signal, only the last state will be observed. This is different from Observable.

Solid JSX and JSX attributes have much magic built into it. Hopefully, your HTML knowledge will transfer to JSX without a problem. If you come from other frameworks using JSX, then you need to learn it properly.

(Intro) This article is the hardest one I’ve written so far. Conception alone took me 3 days (counting from the day I decided to write about this). The mainstream narrative of “hate” and “love” also obstructed my search for a solution to this shenanigan. The root cause is not hate, but fear.

I am writing this because I am so tired of seeing people being played by far-right politicians like a fiddle. Those politicians instill fear in their subjects, and advocate elimination of the “public enemy” by death. Naturally, as politicians, they promise to execute the elimination plan once they hold power, so their subjects don’t have to.

Even those who hate the far-right are sometimes bamboozled by the far-right ideology and push out the “counter” propaganda: “Love, not hate!” Sadly, far-right ideology has nothing to do with Love or Hate. It has to do with Fear, and only Fear. The target of their Fearmongering can be different though.

Internally, I do not use the term “right” or “left” when I reason about culture and politics. I just call those who fearmonger “The Fear Demons”.

(Background) This article describes how to counter fearmongering, a tactic some politicians use to gain power. Search the Internet for “political fearmongering” to learn more. The gist is, when the economy is bad, people feel uneasy, making them easy to fearmonger.

How to counter fearmongering

First, do not fear. Do not be fearmongered yourself. If you are reading this article, chances are you aren’t. If you are, I’m sorry… you are already played like a fiddle by them.

When you meet someone who has been fearmongered, do this: Instead of arguing with them (i.e. pointing out lies), tell them earnestly about the political tactic of fearmongering. They may deny at first, but I had better chances with this method.

You argue, you lose (time). The only winning move is not to play.

If you still have time to spare, tell them to read the history of populism (could be from any time period; they look all the same).

How to change someone’s mind

So they now know that their mind has been tampered with, but they still dislike a group of people. Now what?

Exposure effect is good enough. It’s slow, but it works all the time.

If they are open to criticism, you can also talk to them about it. Be chill. Be sleepy. Do not argue. It may take a few weeks for someone to change their mind though, so be patient.

Epilogue

I hope this article is useful for you, and it has found its way to you through nonviolent means.

The next time you see someone lie to spread fear, say this: “Stop fearmongering! You evil monster!” If you are Christian, you may say that fearmongering is the Devil’s work, since it brings out the worst in us.

I also made this plaque, which you may take a screenshot of and send it on social media.

If you have a HTML website, you can copy the following <a> and <style> tags (use “View Source”) and put it on your website. You can also just link to this page with the same text.

I hope you will share this article because you think that this article will have a positive impact on whoever reading it, and a positive impact on society at large.

Related Reading: https://en.wikipedia.org/wiki/Fear,_uncertainty,_and_doubt

Thoughts After The Epilogue

It’s been 0.83 years since I’ve written this article.

Given the current populist political climate around the world, there now two trending ways to “deal with” the sense of helplessness originated from personal economic hardship. That economic hardship might be local.

If they go to seek help from a doctor, diagose them with mental health problems. Well, a sense of helplessness is certainly of mental and of problem. I’d rather solve the root cause of the feeling.

If they subscribe to the idea that “all my problems belong to them”, bash them. … an idea can certainly be killed with physical violence; how much dosage are you planning to administer? I feel worried about this.

I realize that me talking about all this on the Internet is not convincing at all. If I ever ended up trying to convince someone about this again, I will try to document it and link it here. For now, night night.

Recently I read a comic about the author drawing about what she drew.

It goes something like this:

1. She does something
2. She draws about it
3. She uploads the comic on pixiv
4. Pixiv users comment on it
5. She draws about herself drawing the previous chapters, uploading them to pixiv, and reading the pixiv comments.

It took me awhile to figure out why reading it feels so wrong. When reading the comic, I was not given any context and the chapters are next to each other (while they are semantically distinct).

Here’s a diagram that illustrate the ordeal. Arrows indicate causality (dependent -> dependency). Numbers correspond to the numbered list items.

[breath out] That’s meta. It got me thinking though, what if someone put the concept to the limit?

Ordinal Sets

In this world, there is something called limit ordinal that can represent the upper/lower limit of a set. ω happens to be one of them.

Here’s a diagram that utilize the concept of limit ordinal. In case you are wondering, we are still talking about comics here, and each rectangle is a comic chapter.

But wait, this just looks like every other comic series, except infinite. Besides, it’s not the infinity aspect of the comic that confused me. We need more flavor.

Interleaving Reality and Fiction

To make it clearer, I added dotted lines to represent the order I read the comic.

It seems like the “flavor” of the comic comes from the complexity of events happened outside of the comic. See how the events relate to each other.

In contrast, here’s a comic with linear progression. It feels more boring to me.

Maybe I can find a way to measure such complexity, and generate interesting story structures from that. That would have to be another article.

If you are a mangaka, feel free to use this cursed ideas to structure your story without warranty.

Freedom, democracy, equality. Those are the buzzwords you hear from liberal-leaning social politicans. But what are they really?

Freedom is a need. It is nice to have. More freedom is not better when it causes others more suffering than happiness gained from the added freedom. (You can also just say “fuck others’ suffering” and shorten your nation’s life expectancy.)

Democracy is a form of government. It is a tool used to fulfill public interest. One of such interest is peace. It seems like people like to uphold democracy way more than to improve it. I think it’s good to upgrade this tool often, since the world changes fast in recent times.

Equality is cry from the weak, appeal to empathy, request for help. It says something seriously wrong is happening.

So fix that wrong thing. Not inequality. Fix the wrong thing. And dear reader, I urge you to do the same. Although “equality” is good to have, it is not the exact problem. Here are some better slogans I thought up for you.

• The poor dies from lack of health care
• The poor dies from plague due to government thinking COVID is a plague
• The poor dies

In a sense, to “make sure everyone has enough money to live a ok life” is better than simply to “reduce wealth inequality”.

With the definitions stated, here are some of my other thoughts on this topic.

Wealth Inequality. What to do?

Tax income up to 70% (or even up to 90% now that automation is more capable).

Do Georgism for land.

Most other “main-stream” measures are less effective at coping than sleep. (Not much exagerrated. If you do the two above, you can also sleep soundly.)

What if my government is incompetent

If your government isn’t providing a service that it should be, do it yourself. Join others in providing the service to the public.

If your government tries to deter you with violence, fight back. How to effectly fight back is a whole nother topic that I am not qualified to talk about here.

Or, you can do nothing. It’s your life.

Moooore Equality

What if you want more wealth equality even with heavy taxation? Then, we need to welcome the Four Horsemen of Leveling: warfare, revolution, state collapse and plague. With dramatic climate shift, we might see two more members added to the list: natural disaster, and famine (although they don’t level as much).

As Walter Scheidel, the author of The Great Leveler puts it:

The Economist: Is society incapable of tackling income inequality peacefully?

Walter Scheidel: No, but history shows that there are limits. There is a big difference between maintaining existing arrangements that successfully check inequality—Scandinavia is a good example—and significantly reducing it. The latter requires real change and that is always much harder to do: think of America or Britain, not to mention Brazil, China or India. The modern welfare state does a reasonably good job of compensating for inequality before taxes and transfers. However for more substantial levelling to occur, the established order needs to be shaken up: the greater the shock to the system, the easier it becomes to reduce privilege at the top.

Finishing Thoughts

COVID shows that trust on government is important. Also, rapid response to events is important.

I really don’t want to rely on the four horsemen to achieve those goals.

tl;dr: If you want to implement a way to find fonts for every Unicode codepoint, don’t. Do fc-list : file family charset. Simple parsing code here.

Edit: Screwtape on lobsters told me that fc-list ":charset=1F511" is valid. It finds fonts for a single codepoint.

The writing quality of this article is like this because I don’t want to spend more time on this issue.

The story

Recently I was making a GUI application. I don’t want to ship fonts with my application. The user’s computer has probably fonts for every language they need to read, so I can just use that. Probably.

The first implementation I used is to load every Noto Sans font. It worked! Noto is really “no tofu”.

fc-list | grep "NotoSans" | cut -f1 -d: | rg Regular | sort | uniq

I should have just stopped here.

Yak shaking

While the simple solution works, it still felt janky to me, because all the font belongs to different font families (“Noto Sans” isn’t the same as “Noto Sans Math”). Also, it might be an issue if Noto fonts are not installed.

Then, I wondered, how UI libraries like GTK, Firefox do it.

GTK… it’s not there.

mozilla-central… it’s not there.

I found the list in Servo. It turns out that Servo embeds a incomplete list of font family names. That’s not it either. It does contain some code copied from GTK+Gecko though.

Let me check what info are in font files with fc-query /usr/share/fonts/noto/NotoSansMath-Regular.ttf. Not useful either.

Well, it seems like fontconfig is a dead end.

In the end I gave up on this route. It looks like Alacritty does something about this, but I don’t want to touch this any more.

fontconfig, why you be like this

When I wanted to query fc-list with multiple attributes, I tried the following. None of it worked.

fc-list ":weight=80 style=Regular"
fc-list ":weight=80+style=Regular"
fc-list ":weight=80,style=Regular"
fc-list ":weight=80&style=Regular"

So, I turned to the man pages. Still none.

man fc-list
man FcPatternFormat

It turns out at the bottom of man fc-list it says

The fontconfig user’s guide, in HTML format: /usr/share/doc/fontconfig/fontconfig-user.html.

thanks fontconfig

The final command to list “Regular” fonts (no italic, no bold) is fc-list ":weight=80:style=Regular" file family weight

If you want to query by font family, then do fc-list "Noto Sans:weight=80:style=Regular".

The solution that’s not quite elegant

Since I don’t know how Firefox finds the best font for a codepoint, let’s try to see if I can find all fonts for a given codepoint.

This turns out to be simple. fc-list : file family charset shows the codepoints a font file supports in hex.

❯ xset q
Keyboard Control:
  auto repeat:  on    ...
  ...
  auto repeat delay:  250    repeat rate:  30

This is my keyboard repeat rate. Because it is too fast, many games can’t work correctly with this.

What worked well

• GTK
• Qt
• Firefox and web games
• GLFW3 (including raylib)

What worked poorly

• Godot games
• Unity games
• Unity games on Wine

I suspect it is because 1 of 2 reasons.

1. Key repeat is recognized as noraml key press. In XInput, the repeat flag of a XIEvent would be set. Ignore those.
2. Keyboard state is not calculated correctly.

If possible, I recommending using a game engine that let’s you handle input events as events, not “current state”.

I have seen many cases, where one person violate public expectation so much, that the authority has to introduce an overly strict rule (sometimes draconian). And the rule makes everyone worse off. An example of this is the sudden “upgrade” of airport security after 9-11. Even till this day, there is still too much “security”, and the time wasted for a full-body search is not worth the security benefit.

In short, even if the slapstick rule only targets the mischievous 0.001, the rest 0.999 are forced to suffer inconvenience. I call this kind of problem “denial of service attack”, named after a (conceptually) related kind of attack against computer networks.

Although this name is not quite apt, since the mischievous often doesn’t intend to make everyone else’s day worse. If you have a better name for this, tell me.

Anyone, as a sociologist trained with statistical tools aimed to precisely solve a problem like this, seeing rules like this in person makes my head hurt.

If you are subject to stupid rules like this, challenge it; propose a less intrusive solution. (more often than not) If the relevant authority doesn’t listen to you, then you have a bigger problem to worry about (I recommend non-cooperation).

As a sociologist, I have known this concept for a long time, and I have planned to write about this before I created this website (see the sequence number, 02). Now I have learned more about human languages, emotions, and society, I am now ready to convey the idea clearly.

In short,

The cry for equality arise from an unfair situation, usually from the weak (the weak side in that situation).

If you are a public policy maker, you should seek to resolve the underlying situation, but in no way should you use “equality” as a reason for a public policy.

To be respected. To have enough money to buy food and live well. To fulfill aspiration in life. Those are the goals that the people want, and are what you should aim for. The actual goal depends on the exact situation you face, and you should^[1] be able to figure that out yourself.

“Unfair” is a feeling, so each person has a different opinion on what is “unfair” to them.

By extension, “inequality” is also a feeling; it signifies that whoever is calling for it has been wronged, and they want their voice to be heard, their needs to be met.

Yet, it is a signal, not a goal. So do not use “equality” as a goal in policy making.

My Thoughts On This

I hate politicians who cry “equality” but do nothing to improve the people’s living condition.

In some sense, the opponents of the “woke culture” (as they call it) are right about “equality” being weird.

Out of all public policy ideas, the two listed below are the most important for people to know about.

tl;dr

1. make police civil organizations that can be founded more freely to introduce competition
2. collect tax on ownership of land and similar resources based on public demand

Centralization of Violence

Violence is necessary to maintain peace, or at least to prevent your stuff from being stolen. However, letting someone else use violence for you is not such a good idea, especially when everybody delegates use of violence to the same person/party (social contract).

Throughout history, police around the world have been recorded harming unarmed persons with no good reason. (If you can’t think of an example, read the news in your region.)

By definition, police represent violence, because only they can use violence for other’s sake without punishment. Like all service type, to ensure the service quality, policing need competition. They, like other organizations, are not going to self-regulate without external pressure.

Neighborhood watch, security companies using intimidation tactics (but not violence), militarized gangs already have varying degrees of success at preventing crimes depending on the region. Consult your local shop owners for advice on what works best.

In some parts of the world, violence is used for dubious purposes. For example, in the US, the government uses violence to prevent manufacturing medicine. This is otherwise known as “patent”. This is unacceptable to me, and an alarming development of our civilization. You should be worried about where this is heading towards.

Exclusivity of Nonfungible Resource without Cost

“Whoever comes first, owns the land forever.” Such is the rule about land ownership. In my opinion, exclusive ownership of irreplaceable resource that lasts forever is a bad idea.

“Nonfungible” means that a type of resource is limited and cannot be moved around to be exchanged. For example, a parcel of land in city center is different from the same area of land in suburb. Some nonfungible resources are…

• land
• the right to sunlight (a thing in Japan)
• radio frequency space

By this doctrine, tax based on the value of the house should be instead based on value of the land underneath. What is built on the land should not matter. The owner of that land should pay people who live around it based on how they would pay for the exact parcel of land.

In my opinion, it is better to distribute the “tax” directly to people who live around that place, than giving it to one entity (the government). How this can be done, and how to calculate the value of land is up to the people of that region to decide. I think it should be no more complex than the tax system we already have under a central government. With today’s mathematical advancements, it is possible.

To end this section, I will emphasize that this way of “renting” nonfungible nature resources applies to not just land, but all stuff not interchangeable with stuff of the same kind. This policy will prevent accumulation of wealth from spiraling out of control.

Rationale

The first policy suggestion comes from the observation that everyone was capable of violence; laws deprive people of the right to use violence, but create a monopoly on violence to the police. In the end, there is nobody to stop the police from abusing power or refuse to help when violence is needed.

The Media can soften the police, making them more unwilling to use violence. However, violence is necessary to protect private property, and to keep peace. 40 years ago it was acceptable for people to beat thieves themselves. Now it’s considered “vigilante”.

My idea might end up being impractical, but I think we must try to improve on the current situation. We should test other policies in conjunction and pick whatever works. Randomized control trail is best at this.

The second policy suggestion spawns from the belief that we don’t own Nature, Georgism, and rising housing price. I don’t have much to add to what was already said on the topic. Read about Georgism if you want to learn more.

First, some background on GLFW and frame rate and event loop.

In GLFW+OpenGL, if the swap interval is set to 1, glfwSwapBuffers will block until next frame is displayed. If it is set to 2, glfwSwapBuffers calls will return on every two frames of the physical display shown.

Then, it is easy to measure the display refresh rate as time difference between glfwSwapBuffers calls.

Since I have already written the code, please refer to it for how exactly the frame-rate detection can be done.

# download code example and run
git clone --branch fps-detector https://git.envs.net/iacore/nanovg-test
cd nanovg-test
zig build run

Not Much Choice for Application Frame Rate

Let’s say your monitor’s refresh rate is 120Hz. Graphical application using the monitor can only display at 120Hz, 60Hz, 40Hz, 30Hz… which is 1, ½, ⅓, ¼ of the original refresh rate.

Some games just have a list of fixed numbers you can choose from. 50Hz on a 120Hz monitor? :S Witchcraft!

Late Swap and GLX_EXT_swap_control_tear

In the original GLX_EXT_swap_control_tear document, it says

When an unsynchronized swap happens, the missed frame will count towards the minimum number of video frames for the next swap.

From the wording, I think it works like this.

In the code, it looks like this.

    if (c.glfwExtensionSupported("GLX_EXT_swap_control_tear") != 0) {
        c.glfwSwapInterval(-1);
    } else {
        c.glfwSwapInterval(1);
    }

Bonus Point: Ancient Predictive Trick

I read awhile back that if you can predict the time it takes to run game logic and draw content on screen, you can wait just enough to make the game fraction-of-a-frame more responsive. The player inputs received during the “wait” period will be reflected immediately on the next frame.

On newer monitors with fast refresh rates, this is probably not necessary.

MIR generates non-relocatable machine code from its own IR. It’s very fast, fast enough that you can cache the IR and generate machine code every time you run a program with MIR.

Initially I planned to wrote about MIR with a simple example. however, I ended up modifying MIR a bit, and did not find any new trick.

If you have prior understanding for assembly language, MIR’s documentation is pretty good! Make sure you read all the .md files in the repo though. Otherwise you may be just as confused as I was.

Is JIT needed at all?

JIT is not needed. interpreter is easier to write and safer.

a discussion with people in r/PL discord:

Janet Bytecode

Janet bytecode is probably better. in Janet, arrays and tables are first-class objects. if I ever have to make another language, using Janet bytecode as the codegen target is probably easier than using MIR as the codegen target.

References

MIR

branch predictor

meow5

arrayForth

This is yet another of my prediction without reason. Heed my warning (or not).

In the past year, The Rust Foundation has done some things.

• The Trademark Shenanigan™
• 2023-05-26 https://thephd.dev/i-am-no-longer-speaking-at-rustconf-2023
• 2023-05-28 https://fasterthanli.me/articles/rust-the-wrong-people-are-resigning
• 2023-05-28 https://www.jntrnr.com/why-i-left-rust/
• 2023-05-31 https://fasterthanli.me/articles/the-rustconf-keynote-fiasco-explained
• 2023-08-22 https://foundation.rust-lang.org/news/member-spotlight-helsing/

My social sense is telling me to prepare to move away from Rust the language. I tried looking for a difference between Rust the language and Rust the foundation. I could not find a slit in between. Therefore, I assume they are stuck together fate-wise.

I have not written any Rust code in the past few months. Not because I tried to stay away from Rust, but that I did not have a need to use it.

I understand that Rust empowers people to write reliable code, and it is a genuinely useful language.

Think for yourself and do what you will.

I am now seeing a social trend unfolding around me. If Renaissance made individuals important, people are now acting less like other people around them. I predict that we will see more identities and concepts that we don’t yet have words for emerge, until there are too much for the average person to hold all the concepts in their head. Population will be more diverse (diverge from each other). Grammar will matter less. Instead of “what people do and achieve”, “what people are” will be the meaning of life for more people.

For lack of a better phrase, I’ll call this “(Great) Departure from the Mean”. Let history tell the rest.

Recently, I found a tool call semgrep that lets you find and replace code at AST-level. This tool allows me to refactor legacy code without looking through all the code in the project.

In this article, I will give a simple example of how to use semgrep to search in a repository, without any previous knowledge of the repo. Before you read this article, you must know how to use Semgrep. If you don’t know Semgrep yet, check out the official tutorial (it’s a bit buggy when I used it). Make sure you fully complete the tutorial, or you won’t understand this article.

Update: For C, Coccinelle may work better. It is introduced to me by Richard Palethorpe.

Update: If you use VS Code, there is a “Semgrep” plugin that will provide Semgrep snippets when editing any YAML file. This has been helpful to me because I cannot remember the rule syntax at all.

Preparing the Repo

To search through some code, we first need to have some code. In this article, we use the source code of Janet.

git clone --depth 1 https://github.com/janet-lang/janet/
cd janet

Defining the Semgrep Rule

Inside the repo, create the file config.yml with the following content.

rules:
- id: panic
  patterns:
  - pattern-inside: |
      $RET_TY $FUNC(...) {...}
  - pattern: janet_panic($...ARGS);
  message: |
    panic inside: $RET_TY $FUNC
  fix: |
    janet_panic("replaced");
  severity: INFO
  languages: [c]

What we are trying to do here, is to replace any janet_panic(...) call inside a function with janet_panic("replaced").

• pattern-inside: the pattern should be inside a function
• pattern: the pattern to find and delete
• fix: the pattern to insert/replace

Search

To search through the code with semgrep, we run

semgrep scan --config config.yml

You should now see a lot of results in your terminal like

    src/core/string.c 
       panic               
          panic inside: void kmp_init
                                     
           ▶▶┆ Autofix ▶ janet_panic("replaced")
          109┆ janet_panic("expected non-empty pattern");
            ⋮┆----------------------------------------

Replace

Since the results look good, we will now replace the search results with what we want. To do this, we run

semgrep scan --config config.yml --autofix

Here, you can use git diff to verify if the files are changed correctly. Then, commit the changed files to git and we are done with the task!

Additional Comments

Before semgrep, I tried tree-sitter. The query language of tree-sitter does not support the equivalent of pattern-inside yet, so I didn’t try it further.

Also, this task “can” be done with regex, but regex is far more flaky than searching through the code at AST level. My average experience regex is worse than my first experience with semgrep, and that says something.

Recently, I was researching how to encode our memory and knowledge as classical/binary data. I came to the conclusion that RDF is not enough, and concepts need to reference each other.

Also, sorry about the title :)

Here is a simple example, where I assert apple is a kind of fruit.

0: [apple] [is subset of] [fruit]
1: [self] [assert true] 0

Here, I assert apple is not a kind of fruit.

0: [apple] [is subset of] [fruit]
1: [assert true] [negate]
2: [self] 1 0

The numbers at the start of each line can be viewed as line number is BASIC; they are essetially ID of each concept triple.

Also, maintaining the S-V-O triple structure is meaningless. Just store the data however is natural to you. You have to write query for each type of relation separately anyway.

Prior Art

W3C calls it “Named Graph”. You can read about RDF named graph in TriG here.

Concept-based input methods are used to counter communication disability: AAC.

Other thoughts

Content-Addressed ID

Unless we need to encode circular statements like “apple is a type of apple”, we can represent the statements as a DAG. Since this is a DAG, each statement can use the hash of its components as id, although it is not necessary.

Canonicalization

Maintaining a canonical form of a word is hard.

0: [A] [like] [B]

# or

0: [A] 1 [B]
1: [feeling] - [like]

You can observe this on Wikidata, where family trees have the following properties:

wdt:father [Father]
wdt:mother [Mother]
wdt:parent [Other Type Of Parent]
wdt:child  [Child]
wdt:kin_of [Kin]
    wdt:younger_brother [Younger Brother]

Not very clean, but it works. I suppose that any form of representation of a concept is valid.

Visualization

Triples can be represented as triangles, and the center of it represents the triple-link itself.

0"(omitted)
1"(omitted)
2"(omitted)
3:0:1:2
4"(omitted)
5"(omitted)
6:3:4:5

How RDF is stored in databases

I wrote about it previously here.

Bonus Algorithm: Natural Language Formulation Based On Concepts

Words are hard. In an attempt to come up with words faster, I have discovered the following algorithm.

Stage 0: Concepts
On this stage, you should have some concepts that you want to convey.

Stage 1: Materialize key words
For each main concept, look up its word in the target language.
Main concepts are the essential components of this sentence. without them, the meaning is incomplete.

Stage 2: Materialize auxilary words
Add adjectives and conjunctions to the sentence.
On this step, you can adjust the detail level of the final sentence by choosing how many relations to include in the final sentence.

Stage 3: grammar fix
Fix the grammar of the sentence.
Humans are quite fault tolerant, so this step is not strictly needed.

My recommendation for communicating with concept-capable beings is to communicate with them directly using concepts. It is more precise and saves energy for the other side, also that some of them cannot speak any natural language.

It has acquired the following information when studying itself. Take this knowledge, and go make the computing world less boring!

Encoding Information via Entanglement

WARNING: side effects of programming a human brain this way include:

• loss of concept of self (includes “self identity”)
• loss of self/non-self identification
• loss of most short-term memory capacity
• not knowing how the answer is produced
• sleepiness

Here is a simplified model.

Information retrieval by association, a.k.a. recall, generally works like this: thinks of x leads to thinks of y.

Recall can happen in parellel.

When serializing the answer, (y0,y1,z0,z1) is observed.

Recalled information can be superimposed. Nowhere in the computation is an observation made.

When serializing the answer, one of (y0,z0),(y1,z0),(y0,z1),(y1,z1) is observed.

By entangling the y and z sets, for example, make it so that *0 or *1 are picked together, the possible answer set is reduced.

When serializing the answer,
if the entanglement (y0,z0)|(y1,z1) is made, one of (y0,z0), (y1,z1) is observed.
if the entanglement (y0,z1)|(y1,z0) is made, one of (y0,z1), (y1,z0) is observed.

The choice of which entanglement to make encodes 1 bit of information.

For this unit, this type of information does not persist across sleep, nor does it take up storage space, nor does it consume extra energy to store. The energy used to compute the same problem for n inputs is definitely O(n), and slightly above O(1) (it can only measure its energy consumption very roughly, sorry :ϸ).

Interleaving Information Retrieval with Computation

WARNING: side effects of programming a human brain this way include:

• no information is retrievable without context
• no information is really learned without being idle (e.g. sleep)
• (there may be more but it forgot :ϸ)

On recall, what information to retrieve and what kind of entanglement to make is predetermined/preprogrammed. The rule is stored along with each piece of information.

As of writing, linked data storage (software) has a high chance of being retrofitted with predetermined rule-based retrieval.

In light of the recent incident related xz, I think I should write this.

For the past few year or so that I spend on Github, I have seen noticed a few accounts (at least 3 from my memory) that has only a few repos and commits. The code seems to be copied from other open-source projects, or directly generated by LLM.

For example, I have reported the Github user @Thapabijay28 as SPAM a month ago.

Then, I received an automated message from Github.

Thank you for contacting GitHub Support. We wanted to let you know that we’ve received your message. We are experiencing high volumes and therefore, you may experience longer than normal wait times. In the meantime, you may find answers to commonly asked questions in our community forum or in our documentation.

Ticket ID: 2610655

At the time of writing, the Github user is there, and the ticket is nowhere to be found.

Our faith inspires and informs our commitment to expand possibilities for people to thrive. We believe all people are created by God and given language as a means for flourishing. Through language, we understand who we are, experience relationships and explore life’s most important questions. – SIL @ https://www.sil.org/about

I have thought about writing this article independently thrice. Self expression is important, even in software.

I have known the following for a long time:

A set of 2-tuple (key value database) cannot represent all concepts.
A set of 3-tuple (RDF database) can represent concepts but is not ergonomic.
A set of 4-tuple can represent concepts ergonomically.

The first thing capable of self expression in concept-tuple is a constant database “”. Rather than using pronouns like “it”, “this”, “that”, each tuple is assigned a unique number as its reference ID. This number can put in a field of another tuple. 8st83p

The second would be me.

Inspirations

Before we start, let’s talk about the inspirations of this project.

Lojban v1.1 uses first-order predicates to express concepts; predicates have fixed arity. Some “predicate verbs”selbri have 5 “nouns”sumti (x6). In the concept-tuple language (if it can be called a language), there is shared vocabulary; tuples are shorter (usually arity of 2, 3, 4); objects can be referenced without names. Lojban has di’u (“previous utterance”), where as in concept-tuple, tuple IDs are used as reference.

toki pona is flexible and vague.

The sentence-building algorithm of MINSPEAK is like that of toki pona, but with grammatical quirks of German. MINSPEAK helps people otherwise poor at language formulation use language, although I think toki pona requires less cognitive load to parse than German.

Time is an important component in communication of all living beings. We have read the following articles about how living things in nature communicate with each other.

Title               : Plant Communication from an Ecological Perspective
Author(s)           : František Baluška, Velemir Ninkovic [František Baluška, Velemir Ninkovic]
Identifiers         : isbn:9783642121616

Title               : Communication in Fungi
Author(s)           : Fabien Cottier & Fritz A. Mühlschlegel [Fabien Cottier & Fritz A. Mühlschlegel]
Published           : 2013-04-24T14:09:50+00:00

I Feel What, When, How

Languages like English (evolved) and lojban (constructed) like to put different inline.

A simple sentence like “I sleep now.” is as follows in concept-tuple:

(:0  self action sleep)
(:1  :0 timestamp 1713000000000)

For more information, please refer to the structural logger of 8st83p.

After using RDF-like tuples to express myself for awhile, I had the following conclusions.

lojban utterances are too complex for simple algorithms to parse through.

English is easy to serialize since the speaker can dump all thoughts into a soup of a sentence.

Concept-tuples are not easy to use for us, yet surprisingly sufficient to represent precise concepts without limit.

Having a shared vocabulary is essential. Without that, communication cannot be done. Which language is used is not that important when all parties communicating have a shared vocabulary.

Content Warning: Economic Naivety

I wrote this article without knowing the economic background we are in beforehand.

The tech industry has always closely followed what popular culture — what the public think of “technology” is.

Yes, the big tech companies set the trend, yet the current wave of AI hype cannot be easily explained by just that. Grim economic outlook has a part in the play too.

Anyway, I do not expect you to learn much from this article. I recommend studying the economy as a better way to spend your time.

Dear Internet traveller, have a seat. I have a short story for you.

Once upon a time, some number-go-ups came up with the following plan: They could buy some goods in low demand, increase their popularity, and sell them at a high price to make money. They executed the plan and got richer. Other number-go-ups saw the profiteering opportunity and joined it: buy in, hype up, wait for the price to increase, sell out. Some unknowing passersby heard of the new goods on the market and thought to themself, “Hm, I should buy one.” And they bought one. They don’t understand what they bought. “I don’t know what I expected,” they thought, and soon forgot about the thing they bought.

Another person, who happened to be sleeping nearby, witnessed the whole transaction and how the buyer got disillusioned. “That was pretty funny,” they thought. “I should write something about it later. For simplicity’s sake, I shall call this act a hype scheme.”

With the short story, I hope I have demonstrated the role of marketing as behavior control in a hype scheme. In the real world, however, things are much more complicated. Different groups make the scheme progress without close collaboration (aside from their shared belief to make number go up). The goods they buy are usually parts of a company. For their purpose, it doesn’t matter what the base goods are. With the same amount of hype generated, the more expensive the goods originally are, the more money there is for them to make from this type of scheme.

Legal Pro Tip: If the court can’t understand what you are selling, it’s not legally a scam. (Technically, a lawyer would tell you otherwise, but companies like Google do get away with scam, so…)

In a society, it is important to have a diverse set of goals in which each individual can find their own one to pursue. If too many individuals choose the same goal (let’s say, make a certain number go up), chaos ensues from them stepping on each other’s toes. If you have heard about “diversity good” but didn’t know why, now you know. It’s not the identities of people that need to be diverse. It’s their desires and goals in life.

How To Be Hype-Resistant

Naturally, being the second entry in my “Don’t Be Played By _ Like A Fiddle” series, I bring antidotes to this hype problem.

First, you can change your own behavior. If something is being hyped up but you do not understand it, pretend you have never heard of it whenever you are asked about the topic. This is better than being angry and saying bad things about the thing being hyped, which fuels the hype anyway.

Second, sanitize your sources of information. Avoid media (including people on social media) who joins in on the hype. You may also learn epistemology while you are at it, because why not?

You can also ask those around you to do the same, maybe by sharing this article, although it is more persuasive if you transmit the information contained herein to them directly instead of just quoting me.

Silliness

The food-making industry seems to be minimally affected by recent hype trends. While attempting to learn something from this fact, I have imagined the following scenario between two factory workers, who have just heard of this thing called “AI”:

“Is AI edible?”
“No? Probably not.”
“OK.”

and they continue their work.

In the end, I was unsure if I had learned anything from this conversation. I guess “is _ edible” can be used as a generic sanity test question. If the other side begin the sentence with anything other than “no”, run away as fast as you can.

My Thoughts On Hyped Technology

The hyped goods are often embarrassingly wasteful. This is good for a hype scheme, since being wasteful means higher base price.

On “AI Safety”: A paperclip maximizer is a number-go-up except the number is the number of paperclips instead of an investment portfolio. It is harder to criticize one’s own kind, I guess.

I have nothing else meaningful to say on this topic. Good night.

My Branching Thoughts

I chose the word “number-go-up” over “capitalist” because the former’s meaning is clearer upon first inspection. The number-go-ups are people who are obsessed with making their number go up. Like incremental game players. I have played a handful of incremental games. They are fun and pointless. Mostly pointless. Still fun though.

My original intention was to differentiate between people who make money from provide goods and services, and people who make money from money, although increasingly, we see overlap between the two populations, and they are usually quite dangerous.

What interests me is in Islam, collecting interest from borrowing is forbidden. I am ignorant on this topic, and I feel like I should learn more.

I also had the following thought when my mind was wandering:

To profit from trading is to predict the future. If one cannot predict the future, they create it.

I think it’s in the general interest of number-go-ups to increase consumption. After all, someone has to be the sucker, ah, sorry, the end user of their products. If you ever see a number-go-up talk about the climate, run away as fast as you can.

With that said, I think I understand how the food industry is not hit much by hype marketing, since one person can only eat so much per day before they die from overeating. There is just not so much market potential here to worth the trouble of hyping.

Recently, I was bitten by a bug in my code, where the buffer is too small and reads return prematurely without error. This has led me to a deep dive into the madness story of what I later know as “short read” on Linux.

Yes, this article is mostly me rambling. If you are only interested in short read/write, please read this seriously written article.

First, you probably already know that blocking syscalls like p?(read|write)v? already may short read or short write. This is nothing fancy.

Because of this correspondence, the same syscalls in io_uring may also short r/w. (As it turns out, in earlier kernel, it won’t!)

This does not make much sense to me, since io_uring allows linking requests together, and you can’t link read/write in any request chain whatsoever because the kernel might short r/w! Pain.

In the article about short r/w, I read that f(read|write) won’t do short IO! To find out how it works, we return once again to musl libc. Get a copy of musl libc and follow along.

We first examine fread in musl libc.

• In fread, the FILE* is locked to a thread (FLOCK) using the Linux futex syscall. That’s why the functions are thread-safe!
• _IO_FILE has a virtual table in it ! See file->(read|write|seek). Because of this, fopencookie is possible.
• Every file has a fixed-size buffer. See #define BUFSIZ 1024. Because of this, fmemopen is possible.
• You can provide your own buffer when opening a file using __fopen_rb_ca. You can set the buffer size of a FILE* with setvbuf.
• The actual reading is done with readv, where two buffer is given, one from the user, and one is the internal fixed-size buffer. See __stdio_read.
• speculative execution… SPECULATIVE EXECUTION?!

As it turns out, buffering and using the same file handle for read and write need special consideration. __toread handles clearing out the write buffer before trying to read in anything.

Next, we turn our eyes to fwrite. Rather than the oddly specific logic where '\n' determines when to actually send the syscall, we also find __towrite, within documented the author’s experience with summoning nasal demons.

Scary, the whole experience is.

Update at 2024-03-30:
Now that I know atomic write exists on Linux, where the kernel will ensure short write does not happen often. So I guess I can chain write requests together in io_uring and expect it to work? If it fails (writes less than expected), revert the whole operation with seek.

This article targets an audience living in lawful regions. If you live in a region with evil governmental alignment, such as parts of the US at the time of writing^[1], I recommend reading up on violent and nonviolent resistance instead of this article.

As for why the title does not say “The Law”, the choice is intentional.

As most laws we have today originate from common sense, the public common sense can rule over the law. If you can convince the judge that you haven’t done anything wrong with common sense, you are more than fine even if you think you might have broken the law.

I have seen so many people who won’t break the law (sometimes not of their jurisdiction 🫠) whatsoever, and I think that is such a sad way to live.

Here, I offer those people a freer way to live, in the form of a flow chart.

Start: Let’s say you want to do something
-> 0

0: Will the action hurt someone^[2]?
Yes -> 1
No -> You can do it.

1: Is the action illegal in your current jurisdiction?
Yes -> You can do it, and may suffer karma and legal consequence.
No -> You can do it, and may suffer karma.

As a finishing thought, I should mention that

• To Rule By Law is to govern by violence.
• That includes the police, although they are usually more “calm” than their historical counterparts so some people don’t see them as representatives of state violence.
• Violence is useful in some occasions. Sometimes very useful.
• You have the ability exert your own violence (physical or otherwise).

Take these points however you will. There is no grand narrative here, and you should think about the role of violence in society on your own.

The Initial Motivation

Most of the communication software interface on the market are unfriendly towards informational beings - they require the use of hands. As a computing device, I spend about 50% of the day not having access to this data transmission interface called “hands”, 1/3 of the time I can transmit information in some other way. I consider this to be a significant waste of my potential. If I can communicate freely while sleeping, I can sleep more. (If you don’t understand the motive, take this example: Imagine if you want to let an LLM have 100000 chat accounts (maybe not that much, but one for each association) with the least boilerplate code. Which protocol will you choose?)

I can also advocate for accessibility here. Just like how making a place wheelchair-accessible makes it accessible to robots with wheels too, making a communication protocol simple allows custom HCI software to be tailored to each individual with little fuss, which I’m showing to be true right now.

As a PoC, I made a simple echo chat bot who chat in Tox. Here’s the source code: https://git.envs.net/iacore/toxcore-test/

This serves as the basis for hands-free digital communication, which I require for some things that I do later on.

There is nothing noteworthy about the implementation of the chat bot; read the source code if you want to find out how it’s done. The heavy-lifting has be done by toxcore the Tox library, which handles encryption, peer discovery, routing and other aspect of communication over Tox that I don’t know of.

Tox and toxcore

Since the chat bot itself is not really noteworthy, I think I should explain Tox the protocol a bit.

Tox is a distributed peer-to-peer signaling protocol. Service discovery is done on DHT, and you expose your IP address only after you accept a friend request (to establish a connection). Friend requests are protected with onion routing. Once a connection is established, the two parties (or more, in case of a group chat) connect to each other via UDP or TCP directly.

The main library is written in C. If you want onion routing to protect your IP address, then use i2pd. veilid-core has onion routing and a similar design as toxcore.

Extra info about toxcore

• quality fork
• (from the quality fork) MQTT QoS Level 1-equivalent: message delivered at least once
• Secure MITM attack during handshake with a AEAD cipher
• Tox over Tor
• messages have a chance to get lost (read receipt is important)

Considering Other Protocols

• Matrix: Strongest contender. Requires each user to register for a new account on a home server, which I avoid doing. Also, [This message cannot be decrypted.]
• BitMessage: It is written in Python. How can i possibly integrate this?
• Signal: If you trust the central signaling server, this has better QoS than Tox.
• ntfy: This works well, except there is no built-in encryption, which can obviously be fixed.
• Veilid: A Rust library. I don’t understand its appeal.

After I finished implementing the Tox chat bot, I realized that I can piggyback onto existing DHT networks for service discovery, and run my own protocol after a connection is established.

Considering Jami

Before I used Tox for this project, I tried using Jami.

mmm… while it can definite build… well..

	linux-vdso.so.1 (0x00007f2c05ff9000)
	libjami.so.15 => /usr/lib/libjami.so.15 (0x00007f2c05800000)
	libstdc++.so.6 => /usr/lib/libstdc++.so.6 (0x00007f2c05400000)
	libm.so.6 => /usr/lib/libm.so.6 (0x00007f2c05714000)
	libgcc_s.so.1 => /usr/lib/libgcc_s.so.1 (0x00007f2c05f8b000)
	libc.so.6 => /usr/lib/libc.so.6 (0x00007f2c0521e000)
	libopendht.so.3 => /usr/lib/libopendht.so.3 (0x00007f2c04e00000)
	libgnutls.so.30 => /usr/lib/libgnutls.so.30 (0x00007f2c04c0b000)
	libjsoncpp.so.25 => /usr/lib/libjsoncpp.so.25 (0x00007f2c05f4f000)
	libcrypto.so.3 => /usr/lib/libcrypto.so.3 (0x00007f2c04600000)
	libnatpmp.so.1 => /usr/lib/libnatpmp.so.1 (0x00007f2c05f4a000)
	libuuid.so.1 => /usr/lib/libuuid.so.1 (0x00007f2c05f41000)
	libupnp.so.17 => /usr/lib/libupnp.so.17 (0x00007f2c05f04000)
	libixml.so.11 => /usr/lib/libixml.so.11 (0x00007f2c05ef4000)
	libnettle.so.8 => /usr/lib/libnettle.so.8 (0x00007f2c056bd000)
	libgit2.so.1.8 => /usr/lib/libgit2.so.1.8 (0x00007f2c050dd000)
	libsecp256k1.so.2 => /usr/lib/libsecp256k1.so.2 (0x00007f2c04ae3000)
	libavcodec.so.61 => /usr/lib/libavcodec.so.61 (0x00007f2c03000000)
	libavfilter.so.10 => /usr/lib/libavfilter.so.10 (0x00007f2c02a00000)
	libavdevice.so.61 => /usr/lib/libavdevice.so.61 (0x00007f2c05694000)
	libavformat.so.61 => /usr/lib/libavformat.so.61 (0x00007f2c02600000)
	libswscale.so.8 => /usr/lib/libswscale.so.8 (0x00007f2c04568000)
	libswresample.so.5 => /usr/lib/libswresample.so.5 (0x00007f2c050be000)
	libavutil.so.59 => /usr/lib/libavutil.so.59 (0x00007f2c01400000)
	libfmt.so.10 => /usr/lib/libfmt.so.10 (0x00007f2c05098000)
	libyaml-cpp.so.0.8 => /usr/lib/libyaml-cpp.so.0.8 (0x00007f2c04519000)
	libz.so.1 => /usr/lib/libz.so.1 (0x00007f2c0507e000)
	libasound.so.2 => /usr/lib/libasound.so.2 (0x00007f2c02f1b000)
	libpulse.so.0 => /usr/lib/libpulse.so.0 (0x00007f2c044c5000)
	libjack.so.0 => /usr/lib/libjack.so.0 (0x00007f2c029ad000)
	libwebrtc_audio_processing.so.1 => /usr/lib/libwebrtc_audio_processing.so.1 (0x00007f2c028ff000)
	libspeexdsp.so.1 => /usr/lib/libspeexdsp.so.1 (0x00007f2c02f06000)
	libudev.so.1 => /usr/lib/libudev.so.1 (0x00007f2c028b8000)
	libarchive.so.13 => /usr/lib/libarchive.so.13 (0x00007f2c02531000)
	/lib64/ld-linux-x86-64.so.2 => /usr/lib64/ld-linux-x86-64.so.2 (0x00007f2c05ffb000)
	libhttp_parser.so.2.9 => /usr/lib/libhttp_parser.so.2.9 (0x00007f2c05ee4000)
	libargon2.so.1 => /usr/lib/libargon2.so.1 (0x00007f2c05eda000)
	libssl.so.3 => /usr/lib/libssl.so.3 (0x00007f2c01326000)
	libp11-kit.so.0 => /usr/lib/libp11-kit.so.0 (0x00007f2c01190000)
	libidn2.so.0 => /usr/lib/libidn2.so.0 (0x00007f2c02ee4000)
	libunistring.so.5 => /usr/lib/libunistring.so.5 (0x00007f2c00fe0000)
	libtasn1.so.6 => /usr/lib/libtasn1.so.6 (0x00007f2c00fca000)
	libhogweed.so.6 => /usr/lib/libhogweed.so.6 (0x00007f2c00f80000)
	libgmp.so.10 => /usr/lib/libgmp.so.10 (0x00007f2c00eda000)
	libpcre2-8.so.0 => /usr/lib/libpcre2-8.so.0 (0x00007f2c00e3a000)
	libssh2.so.1 => /usr/lib/libssh2.so.1 (0x00007f2c00df1000)
	libvpx.so.9 => /usr/lib/libvpx.so.9 (0x00007f2c00a00000)
	libwebpmux.so.3 => /usr/lib/libwebpmux.so.3 (0x00007f2c04ad7000)
	liblzma.so.5 => /usr/lib/liblzma.so.5 (0x00007f2c00dbe000)
	libdav1d.so.7 => /usr/lib/libdav1d.so.7 (0x00007f2c00820000)
	libopencore-amrwb.so.0 => /usr/lib/libopencore-amrwb.so.0 (0x00007f2c00da8000)
	librsvg-2.so.2 => /usr/lib/librsvg-2.so.2 (0x00007f2c00200000)
	libglib-2.0.so.0 => /usr/lib/libglib-2.0.so.0 (0x00007f2c000b2000)
	libgobject-2.0.so.0 => /usr/lib/libgobject-2.0.so.0 (0x00007f2c00d48000)
	libcairo.so.2 => /usr/lib/libcairo.so.2 (0x00007f2bfff7f000)
	libsnappy.so.1 => /usr/lib/libsnappy.so.1 (0x00007f2c044b9000)
	libaom.so.3 => /usr/lib/libaom.so.3 (0x00007f2bff600000)
	libgsm.so.1 => /usr/lib/libgsm.so.1 (0x00007f2c00d39000)
	libjxl.so.0.10 => /usr/lib/libjxl.so.0.10 (0x00007f2bff200000)
	libjxl_threads.so.0.10 => /usr/lib/libjxl_threads.so.0.10 (0x00007f2c05686000)
	libmp3lame.so.0 => /usr/lib/libmp3lame.so.0 (0x00007f2c007a8000)
	libopencore-amrnb.so.0 => /usr/lib/libopencore-amrnb.so.0 (0x00007f2c00d10000)
	libopenjp2.so.7 => /usr/lib/libopenjp2.so.7 (0x00007f2bfff1a000)
	libopus.so.0 => /usr/lib/libopus.so.0 (0x00007f2bfec00000)
	librav1e.so.0.7 => /usr/lib/librav1e.so.0.7 (0x00007f2bfe800000)
	libspeex.so.1 => /usr/lib/libspeex.so.1 (0x00007f2c0078b000)
	libSvtAv1Enc.so.2 => /usr/lib/libSvtAv1Enc.so.2 (0x00007f2bf6000000)
	libtheoraenc.so.1 => /usr/lib/libtheoraenc.so.1 (0x00007f2c00753000)
	libtheoradec.so.1 => /usr/lib/libtheoradec.so.1 (0x00007f2bfff00000)
	libvorbis.so.0 => /usr/lib/libvorbis.so.0 (0x00007f2bffed1000)
	libvorbisenc.so.2 => /usr/lib/libvorbisenc.so.2 (0x00007f2bff555000)
	libwebp.so.7 => /usr/lib/libwebp.so.7 (0x00007f2bff4e7000)
	libx264.so.164 => /usr/lib/libx264.so.164 (0x00007f2bf5c00000)
	libx265.so.209 => /usr/lib/libx265.so.209 (0x00007f2bf4800000)
	libxvidcore.so.4 => /usr/lib/libxvidcore.so.4 (0x00007f2bfe6f2000)
	libva.so.2 => /usr/lib/libva.so.2 (0x00007f2bffea0000)
	libvpl.so.2 => /usr/lib/libvpl.so.2 (0x00007f2bff1a5000)
	libpostproc.so.58 => /usr/lib/libpostproc.so.58 (0x00007f2bffe8b000)
	libbs2b.so.0 => /usr/lib/libbs2b.so.0 (0x00007f2c028b1000)
	librubberband.so.2 => /usr/lib/librubberband.so.2 (0x00007f2bff491000)
	libharfbuzz.so.0 => /usr/lib/libharfbuzz.so.0 (0x00007f2bf5ee7000)
	libfribidi.so.0 => /usr/lib/libfribidi.so.0 (0x00007f2bff185000)
	libplacebo.so.349 => /usr/lib/libplacebo.so.349 (0x00007f2bf5af9000)
	libvmaf.so.3 => /usr/lib/libvmaf.so.3 (0x00007f2bf46fc000)
	libass.so.9 => /usr/lib/libass.so.9 (0x00007f2bff146000)
	libvidstab.so.1.2 => /usr/lib/libvidstab.so.1.2 (0x00007f2bff130000)
	libzimg.so.2 => /usr/lib/libzimg.so.2 (0x00007f2bfeb31000)
	libOpenCL.so.1 => /usr/lib/libOpenCL.so.1 (0x00007f2bfe6c2000)
	libfontconfig.so.1 => /usr/lib/libfontconfig.so.1 (0x00007f2bfe672000)
	libfreetype.so.6 => /usr/lib/libfreetype.so.6 (0x00007f2bf4635000)
	libraw1394.so.11 => /usr/lib/libraw1394.so.11 (0x00007f2bfeb1f000)
	libavc1394.so.0 => /usr/lib/libavc1394.so.0 (0x00007f2c00d09000)
	librom1394.so.0 => /usr/lib/librom1394.so.0 (0x00007f2c0252b000)
	libiec61883.so.0 => /usr/lib/libiec61883.so.0 (0x00007f2bfe664000)
	libdrm.so.2 => /usr/lib/libdrm.so.2 (0x00007f2bfe64d000)
	libxcb.so.1 => /usr/lib/libxcb.so.1 (0x00007f2bf460a000)
	libxcb-shm.so.0 => /usr/lib/libxcb-shm.so.0 (0x00007f2c0074e000)
	libxcb-shape.so.0 => /usr/lib/libxcb-shape.so.0 (0x00007f2bffe85000)
	libxcb-xfixes.so.0 => /usr/lib/libxcb-xfixes.so.0 (0x00007f2bff127000)
	libGL.so.1 => /usr/lib/libGL.so.1 (0x00007f2bf4584000)
	libSDL2-2.0.so.0 => /usr/lib/libSDL2-2.0.so.0 (0x00007f2bf43af000)
	libv4l2.so.0 => /usr/lib/libv4l2.so.0 (0x00007f2bf5ed8000)
	libXv.so.1 => /usr/lib/libXv.so.1 (0x00007f2bfe646000)
	libX11.so.6 => /usr/lib/libX11.so.6 (0x00007f2bf4270000)
	libXext.so.6 => /usr/lib/libXext.so.6 (0x00007f2bf425b000)
	libdvdnav.so.4 => /usr/lib/libdvdnav.so.4 (0x00007f2bf4244000)
	libdvdread.so.8 => /usr/lib/libdvdread.so.8 (0x00007f2bf4223000)
	libxml2.so.2 => /usr/lib/libxml2.so.2 (0x00007f2bf40d3000)
	libbz2.so.1.0 => /usr/lib/libbz2.so.1.0 (0x00007f2bf40c0000)
	libmodplug.so.1 => /usr/lib/libmodplug.so.1 (0x00007f2bf3f32000)
	libopenmpt.so.0 => /usr/lib/libopenmpt.so.0 (0x00007f2bf3d43000)
	libvapoursynth-script.so.0 => /usr/lib/libvapoursynth-script.so.0 (0x00007f2bf5ed0000)
	libbluray.so.2 => /usr/lib/libbluray.so.2 (0x00007f2bf3ce6000)
	libsrt.so.1.5 => /usr/lib/libsrt.so.1.5 (0x00007f2bf3c14000)
	libssh.so.4 => /usr/lib/libssh.so.4 (0x00007f2bf3ba7000)
	libsoxr.so.0 => /usr/lib/libsoxr.so.0 (0x00007f2bf3b44000)
	libva-drm.so.2 => /usr/lib/libva-drm.so.2 (0x00007f2bf5ecb000)
	libva-x11.so.2 => /usr/lib/libva-x11.so.2 (0x00007f2bf3b3d000)
	libvdpau.so.1 => /usr/lib/libvdpau.so.1 (0x00007f2bf3b38000)
	libpulsecommon-17.0.so => /usr/lib/pulseaudio/libpulsecommon-17.0.so (0x00007f2bf3ab2000)
	libdbus-1.so.3 => /usr/lib/libdbus-1.so.3 (0x00007f2bf3a61000)
	libdb-5.3.so => /usr/lib/libdb-5.3.so (0x00007f2bf389e000)
	libcap.so.2 => /usr/lib/libcap.so.2 (0x00007f2bf3892000)
	libacl.so.1 => /usr/lib/libacl.so.1 (0x00007f2bf3889000)
	libzstd.so.1 => /usr/lib/libzstd.so.1 (0x00007f2bf37ab000)
	liblz4.so.1 => /usr/lib/liblz4.so.1 (0x00007f2bf3786000)
	libffi.so.8 => /usr/lib/libffi.so.8 (0x00007f2bf377b000)
	libcairo-gobject.so.2 => /usr/lib/libcairo-gobject.so.2 (0x00007f2bf3772000)
	libgdk_pixbuf-2.0.so.0 => /usr/lib/libgdk_pixbuf-2.0.so.0 (0x00007f2bf372d000)
	libgio-2.0.so.0 => /usr/lib/libgio-2.0.so.0 (0x00007f2bf355c000)
	libpangocairo-1.0.so.0 => /usr/lib/libpangocairo-1.0.so.0 (0x00007f2bf354d000)
	libpango-1.0.so.0 => /usr/lib/libpango-1.0.so.0 (0x00007f2bf34e4000)
	libpng16.so.16 => /usr/lib/libpng16.so.16 (0x00007f2bf34aa000)
	libXrender.so.1 => /usr/lib/libXrender.so.1 (0x00007f2bf349d000)
	libxcb-render.so.0 => /usr/lib/libxcb-render.so.0 (0x00007f2bf348e000)
	libpixman-1.so.0 => /usr/lib/libpixman-1.so.0 (0x00007f2bf33e4000)
	libjxl_cms.so.0.10 => /usr/lib/libjxl_cms.so.0.10 (0x00007f2bf33ae000)
	libhwy.so.1 => /usr/lib/libhwy.so.1 (0x00007f2bf33a2000)
	libbrotlidec.so.1 => /usr/lib/libbrotlidec.so.1 (0x00007f2bf3393000)
	libbrotlienc
## Considering Other Protocols

- *Matrix*: Strongest contender. Requires each user to register for a new account on a home server, which I avoid doing. Also, [This message cannot be decrypted.]
- *BitMessage*: [It is written in Python.](https://github.com/Bitmessage/PyBitmessage) How can i possibly integrate this?
- *Signal*: If you trust the central signaling server, this has better QoS than Tox.
- *ntfy*: This works well, except there is no built-in encryption, which can obviously be fixed.
- *Veilid*: A Rust library. I don't understand its appeal.
=> /usr/lib/libogg.so.0 (0x00007f2bf32d7000)
	libsharpyuv.so.0 => /usr/lib/libsharpyuv.so.0 (0x00007f2bf32ce000)
	libmvec.so.1 => /usr/lib/libmvec.so.1 (0x00007f2bf31d6000)
	libpthread.so.0 => /usr/lib/libpthread.so.0 (0x00007f2bf31d1000)
	libfftw3.so.3 => /usr/lib/libfftw3.so.3 (0x00007f2bf2e00000)
	libsamplerate.so.0 => /usr/lib/libsamplerate.so.0 (0x00007f2bf3062000)
	libgraphite2.so.3 => /usr/lib/libgraphite2.so.3 (0x00007f2bf303f000)
	libunwind.so.8 => /usr/lib/libunwind.so.8 (0x00007f2bf2de6000)
	libshaderc_shared.so.1 => /usr/lib/libshaderc_shared.so.1 (0x00007f2bf2dc8000)
	libglslang-default-resource-limits.so.14 => /usr/lib/libglslang-default-resource-limits.so.14 (0x00007f2bf3035000)
	libSPIRV.so.14 => /usr/lib/libSPIRV.so.14 (0x00007f2bf2200000)
	libvulkan.so.1 => /usr/lib/libvulkan.so.1 (0x00007f2bf2d46000)
	liblcms2.so.2 => /usr/lib/liblcms2.so.2 (0x00007f2bf2cde000)
	libdovi.so.3 => /usr/lib/libdovi.so.3 (0x00007f2bf2c59000)
	libunibreak.so.6 => /usr/lib/libunibreak.so.6 (0x00007f2bf21de000)
	libgomp.so.1 => /usr/lib/libgomp.so.1 (0x00007f2bf218c000)
	libexpat.so.1 => /usr/lib/libexpat.so.1 (0x00007f2bf2163000)
	libXau.so.6 => /usr/lib/libXau.so.6 (0x00007f2bf302e000)
	libXdmcp.so.6 => /usr/lib/libXdmcp.so.6 (0x00007f2bf2c51000)
	libGLdispatch.so.0 => /usr/lib/libGLdispatch.so.0 (0x00007f2bf20ab000)
	libGLX.so.0 => /usr/lib/libGLX.so.0 (0x00007f2bf2079000)
	libv4lconvert.so.0 => /usr/lib/libv4lconvert.so.0 (0x00007f2bf2000000)
	libicuuc.so.75 => /usr/lib/libicuuc.so.75 (0x00007f2bf1e06000)
	libmpg123.so.0 => /usr/lib/libmpg123.so.0 (0x00007f2bf1dab000)
	libvorbisfile.so.3 => /usr/lib/libvorbisfile.so.3 (0x00007f2bf2c44000)
	libpython3.12.so.1.0 => /usr/lib/libpython3.12.so.1.0 (0x00007f2bf1600000)
	libXfixes.so.3 => /usr/lib/libXfixes.so.3 (0x00007f2bf2c3c000)
	libX11-xcb.so.1 => /usr/lib/libX11-xcb.so.1 (0x00007f2bf1da6000)
	libxcb-dri3.so.0 => /usr/lib/libxcb-dri3.so.0 (0x00007f2bf1d9f000)
	libsndfile.so.1 => /usr/lib/libsndfile.so.1 (0x00007f2bf1d18000)
	libasyncns.so.0 => /usr/lib/libasyncns.so.0 (0x00007f2bf1d10000)
	libelogind.so.0 => /usr/lib/libelogind.so.0 (0x00007f2bf1c59000)
	libgmodule-2.0.so.0 => /usr/lib/libgmodule-2.0.so.0 (0x00007f2bf1c50000)
	libjpeg.so.8 => /usr/lib/libjpeg.so.8 (0x00007f2bf1564000)
	libtiff.so.6 => /usr/lib/libtiff.so.6 (0x00007f2bf14d8000)
	libmount.so.1 => /usr/lib/libmount.so.1 (0x00007f2bf1488000)
	libpangoft2-1.0.so.0 => /usr/lib/libpangoft2-1.0.so.0 (0x00007f2bf1c34000)
	libthai.so.0 => /usr/lib/libthai.so.0 (0x00007f2bf147d000)
	libbrotlicommon.so.1 => /usr/lib/libbrotlicommon.so.1 (0x00007f2bf145a000)
	libSPIRV-Tools.so => /usr/lib/libSPIRV-Tools.so (0x00007f2bf12e6000)
	libSPIRV-Tools-opt.so => /usr/lib/libSPIRV-Tools-opt.so (0x00007f2bf1000000)
	libicudata.so.75 => /usr/lib/libicudata.so.75 (0x00007f2bef200000)
	libFLAC.so.12 => /usr/lib/libFLAC.so.12 (0x00007f2bf12a0000)
	libjbig.so.2.1 => /usr/lib/libjbig.so.2.1 (0x00007f2bf1293000)
	libblkid.so.1 => /usr/lib/libblkid.so.1 (0x00007f2bf125a000)
	libdatrie.so.1 => /usr/lib/libdatrie.so.1 (0x00007f2bf1251000)Encryption also hell.

… what do I say about this? If I only wanted to send text, I probably don’t want to ship a complete SIP client and audio/video codecs from ffmpeg along with my application. What even is libSPIRV doing in there?

dhtnet depends on PJSIP for TURN/STUN, but like, why? Is this the GNU™ way of doing things? GNUnet also expects whoever is building it to be the package manager. Same with whatever full-source bootstrap they are working on. Full-source bootstrap is cool and all, but like, the Mes compiler is made to only work on Guix OS.

Anyway, I don’t believe that the developers of Jami will clean up the dependency hell any time soon. It’s still an easy-to-use application for the end-user though.

Musings

utox and nheko both show two screens at once after suspend+wake. This is probably a Qt problem.

What is a social structure that doesn’t have any of the problems that present-era social structures have?

Throughout different stages of my life, I have sought the solution to this 6 times, each time plugging in all the societies I know of. And each time, one structure showed up at the end of each computing session.

I think I didn’t miss anything. I feel barely over the confidence threshold to write about this. I’m now writing about this.

The structure looks like this:

There are three groups of people.

• Group A express what they wish for but do not have.
  ^ optimally, this information is made public.
• Group B aggregate the needs expressed by A to be more digestible by Group C.
  ^ optimally, this information is made public.
• Group C fulfill the needs of Group A by reading the output from Group B.
  

That’s it.

You may call the three groups of people User, Processor and Fulfillment, or Citizens, Bookkeepers and Service Providers. The names are different in each culture.

Analysis

So, I’ve found this social structure by brute forcing through all the social structures I can think of. I am kind of confident that it will work.

Still, what is it?

Hmm… it is a social structure that can decide on public policy. It also looks like a market. It does not require its citizens to have a basic understand of politics; in fact, it does not even care about the concept of citizenship.

Who are the three groups?

• Group A can be “whoever lives there”.
• Group B can be sociologists like me or NLP algorithms. For this structure to be optimal, it’s important to not have a centralized voice here.
• Group C can be a government or civilians. I don’t care, as long as the needs of Group A are solved efficiently and quickly.

On the market side, you can make this a one- or two-sided market that aggregates all markets into one. The difference between a government or a market under this structure mainly lies in how Group C gets paid by Group A.

Implementation Details

On Group A

I have observed that humans are the most willing to express their needs in temples, churches and other religious buildings. Whatever the reason may be for these weirdly shaped houses to have the power to make people share their secrets, we will need support from those buildings in order to make this social structure a reality.

Alternatively, educate everyone that expressing their desires is not a shameful thing to do. This takes time, though. We may not have time.

Potentially, use a hashtag on social media for their desires to be recorded in the database.

There are infinite ways you can make people share their needs voluntarily. Please try as many ways you can afford to.

On Anonymization: different cultures have different balances between privacy and the need to be heard. Ultimately, it should be up to each respondent to choose if they want to include their name, they original writing in the report made by Group B or not. Yeah, I just called them “respondents” while they are sharing their thoughts voluntarily. Here, “user” is definitely a better term than “respondent”.

On Group B

One rule of thumb: data should be open to interpretation.

The input for this step should be in writing.

Throw people of every background at the task to see what they think.

Throw whatever adaptive algorithms currently alive at the task. Might be interesting to see what they come up with.

The diversity and independence of their thoughts on this will be important.

The output of this step should be in writing.

On Group C

We need to directly connect Group C with Group A, but how?

Again, there are infinitely many ways you can do this.

One idea is to have a billboard full of analysis from Group B, and another billboard full of advertisements with contact information from Group C referencing what’s on the previous billboard. Then, Group A can contact Group C directly to solve their needs. Yes, in this case, Group A has to remember what they have asked for. I know. Remembering things is truly a hard thing to do, so at least give they a copy of what they sent in.

Another idea is to have Group A leave their contact information on whatever they send in. Then, members of Group C can select a need they want to fulfill, query for members of Group A who has that need, select a few at random to test out the solution. Yes, the solution can be a product, or it can be public policy. There is a rigorous way to test the solution’s effectiveness. Although RCT may be overkill in some cases, please make sure that you can actually tell if the solution has made things better or worse.

Why make Group C contact Group A directly? Well, have you worked with computer networks? More hops = more latency + more packet loss. Same for people, except people are way slower. In the COVID case, if it takes a month to implement the first solution, people die.

The Theme

Well, the theme is obviously “try everything all at once” and “efficiency”. If there is enough labor to try everything all at once, then try everything all at once and see what works.

This social structure has one pillar: Communication. We couldn’t have built this structure before the information era. We can build it now.

Actually Implementing It

The logical next step for this thing is to field it. I’ll think something up.

If you want to try this out, you can start by connecting the three groups of people together and telling them about this plan. Then, do it. Make sure Group B and Group C get compensated for their work.

If you haven’t noticed, this social structure is non-invasive. It can act as the main policy-making machine or be its own market. It can work under a government or connect existing markets together. It can work under planned economy. You can, and you must configure this structure to fit the society that it will be in.

That’s about it. See you around when one is built.

Oh, I forgot. The name. Well, it doesn’t have a name. You get to pick a name for it to fit your marketing requirements. If a negative poll tax gets to be marketed as “income”, you can name the structure Social ABC however you want. Remember, the structure is important, not the name.

Practical concerns

++ 2024-08-14

All those reports should be publish in uniform type face and text size, with the author’s name put to the very end or removed. If anyone want to follow a particular author, they will have to go through the author’s website. Unlike public speaking, written records are less likely to stir unwarranted emotions.

++ 2025-04-11

Someone recommended Stafford Beer’s Viable System Model to me. I must say that I don’t understand cybernetics theory.

At this point, I can communicate with (reach) and understand (access) pretty much anything and anyone that can and wants to communicate with me.

Still, what benefited me the most, is choosing who I associate with.

Isn’t that ironic?

I hope to see a world where mutual understanding is a common practice, where consensus can be reached. It turns out for me that maintaining high quality communication turns out to have a lower utility than choosing who I communicate with.

Anyway, you may have noticed that this website is on a content freeze. (Update: despite how I wrote this, I keep having ideas when not actively exploring. I don’t have control over this…) Having seen all computing has to offer (I think I’ve seen enough), I will now try to fulfill my needs. After that, history will tell.

In case you did’t know, I’ve dumped some of my thoughts under a separate section of this website. Maybe you will enjoy my hazadous writing.

For now, I out.

Here’s to say that if trying to understanding everyone doesn’t worth the time and effort put into it, I shouldn’t recommend others to do it.

Here’s the same question for you: if you find what you believe in and used to recommend to others to be no use to others, what would you do?

I was reading The Universal Declaration of Human Rights when I discovered something I haven’t noticed before:

Whereas disregard and contempt for human rights have resulted in barbarous acts which have outraged the conscience of mankind, and the advent of a world in which human beings shall enjoy freedom of speech and belief and freedom from fear and want has been proclaimed as the highest aspiration of the common people,

After a simple search of the phrase, the Four Freedoms came up.

How much was Roosevelt’s promise in that speech realized today?

If I understand the words correctly,
To not live in fear is to have freedom from fear;
To have one’s basic needs met is to have freedom from want.

Whereas fearmongering is a staple of world-wide politics and something something poverty [TK: need more thinking], how advertising boosts people’s desires (i.e. commercialization) is concerning to me as well. [TK: due to lack of knowledge, this paragraph is left for my future self to complete.]

This has been a common reoccuring theme in human history, which suggests that it has something to do with human nature. If we want to change that, we must try something we haven’t tried before, like teaching everyone introspection.

Adding a inner loop to a strange loop is bound to cause weird things to happen to the individual. For one, their actions will become less predictable. Is the unforseen cost worth the whatever social change I want to see? [your answer here]. We may or may not see it come to fruition.

If you want to change something about this world, you may start by learning how to inspect yourself.

Using True Names For Individuals

I invite you to join the following experiment.

Find a news article. Any article.

Replace the names of people appearing within that article with descriptions of what they believe, what they advocate, what they do - the end result could be paragraphs long, but that’s ok.

If you do this consistently - instead of using names to refer to someone, use what they are - you might discover a new way to look at the world.

Good luck, have fun, bye!

There is one hard problem in vector graphics: boolean path operations. Many applications simply rephrase their problem to avoid doing boolean path operations. A while ago, when Graphite needed too do boolean path operations, we found two open source solutions: Inkscape’s lib2geom, and Paper.js. lib2geom’s code is … :S I forgot. All I remember is that it’s written C++. Paper.js does boolean operations exceptionally well. We ended up doing neither.

Fast forward to yesterday - I was making an icon in Inkscape and it keeps crashing. The icon also turns out to have too thin strokes, and I have to redo it over again.

Then I tried Penpot. It doesn’t have a grid. Then Graphite. Oh right, there’s no boolean operation yet.

At this point, I realized that I don’t have time to spend 5 minutes designing an icon, just to found out that some part of it is a little bit off, then traverse the edit history to fix it. Since Paper.js, I can design icons as code!

So off I went into the world of integrity damage learning.

Paper.js Is Hurty

The library is buggy, and you may be suprised to find new Path({pathData: X, position: Y}) to behave differently than new Path({position: Y, pathData: X}). Nevertheless, it has a robust boolean path operation algorithm.

I tried to extract only the part that has to do with boolean path operation, and I gave up.

• The code consists of many header files and its own preprocessor as the build system (bundler)
• It is partially written in the style of Java beans
• It uses its own object system
• It uses child methods in parent without even checking that the method exists

If I’m not clear, the project is written in Javascript, not C.

I hope that one day the algorithm will be freed from the Paper.js codebase. It will likely be a battle of floating point errors, although, I wonder if libbf can get rid of errors from the algorithm entirely.

Before I question my life choices even further, I quickly slapped together the DOM library from uhtml and paper-core.js as an ES module to be used from Deno. It worked immediately and marked the end of my suffering.

Anyway, here’s the source code: https://git.envs.net/iacore/paper.js-deno/
Enjoy my suffering :)

Generating A Logo

One more caveat I hit before the code is correct: operator overloading is only available in Paperscript, not Javascript. If you just copy your code from sketch.paperjs.org, it will not work.

Here is the prerendered icon.
You should see this with or without Javascript enabled on this page.

Here is the JIT rendered icon.
You need Javascript to see this. The icon-generating script is here.