@lyse@lyse.isobeef.org take a small video, pretty please! I would love the see them shining in the fields! On the pics, 1 is mine, all mine! 🥰

@movq@www.uninformativ.de Yes, this screenshot. However, not the Dutch but rather the German version, no wonder it looks so crazy!!1!11

It’s been a hot minute or two since I last used KDE, so I don’t remember exactly. I just vaguely recall that I found myself thinking multiple times that the KDE application categories were better matching or there were more or something like that. Most of my classmates were on Windows and had one giant long list of all sort of stuff in there. You even had to scroll in the menu. Sure, they installed all kind of garbage, which didn’t exactly help. Where in KDE, they were actually grouped by Office, Internet, Graphics, Multimedia, Games, etc. In Windows, applications usually hid themselves in a sub folder named after the software vendor. At least in the later (?) days.

I only used Win 95, 98 and XP at home. For maths class with computer algebra system (Maple), we had a Cassiopeia with Win CE: https://en.wikipedia.org/wiki/Casio_Cassiopeia At school, there was probably also Win 2000, but I don’t know anymore for sure.

@lyse@lyse.isobeef.org In what way was KDE 3’s menu organized? KDE 1 is the only KDE version I ever used. 😅 We’re talking about this one, right?

Isn’t Notepad++ and Python cheating!? :-D

Well, Python was certainly already a thing back then, but Notepad++ is from 2003, right. I think I used https://www.wintotal.de/download/proton/ at the time? Maybe? I don’t know. 😅

The dairy farm has a new milk vending machine. The prices increased by 20%. One liter is now 1.20€ instead of 1.00€. But I don’t complain.

In a few meters of shrubs there were easily 50 butterflies. That was crazy, I’ve never seen this many in one spot. I should have taken a video.

The grain field in the beginning was looking so great. Crazy colorful and very yummy looking. I would have loved to take a bite. Or at least lie down right in the middle.

That was another great time in the outdoors. The 21°C were killing us, though. We were always glad when we reached a shady spot with a little breeze. I’m not gonna survive the 35°C later this week. :-(

https://lyse.isobeef.org/waldspaziergang-2026-06-15/

In Magic today, the Phyrexian Invasion failed in the first game, but the second game was EPIC!

I played my (unlisted) Dragons 2: Draconic Boogaloo deck, and…

Turn 1: Nothing special
Turn 2: Miirym (when a dragon enters, copy it)
Turn 3: Tiamat (choose 5 dragons from deck, put in hand)
Turn 4: Klauth (when dragons attack, create mana equal to their total power)
I attacked with all 5 dragons, which made 28 mana x2 = 56(!) mana.
Then (still turn 4) I played Scourge of Valkas (when a dragon enters, deal damage to target equal to number of dragons) + 5 other dragons, dealing 6 + 2 x (7+8+9+10+11+12+13+14+15+16+17) = 270(!) direct damage (more than double enough to kill the other 3 players).

Damn fine win, if I do say so myself.

@lyse@lyse.isobeef.org Is it this one? https://github.com/rivo/tview It’s almost 10 years old but hasn’t seen a 1.0.0 release yet? 🤔

@movq@www.uninformativ.de You may want to include another antipattern to avoid in your article:

• bump $same_dependency from 1.0.0 to 1.0.1
  
• bump $same_dependency from 1.0.1 to 1.0.2
  
• bump $same_dependency from 1.0.2 to 1.1.0
  
• bump $same_dependency from 1.1.0 to 1.2.0

Every now and then, I think that I have carefully proof-read my message enough times and hit the “Add message” button in tt. But then, in the message tree, I spot another missed typo. My process is then to go to my twtxt.txt and fix it by hand. However, I still have to clean up tt’s cache. This is rather tidious:

1. Recall the sqlitebrowser ~/.local/share/twtxt/tt2.sqlite from my shell history.
   
2. Switch to the “Browse data” tab.
   
3. Go to the messages table and wait a second or two until it’s loaded.
   
4. Sort by the created_at column twice, so that I get descending order.
   
5. Select the first message, which is typically the one in question.
   
6. Find the “Remove currently selected row” button in the tool bar.
   
7. Commit the changes.
   
8. Close sqlitebrowser.
   

So, I finally implemented the removal of messages from the cache in tt. I can now hit d and confirm the removal. Bam! Should have done that ages ago!

https://lyse.isobeef.org/tmp/tt-confirm-message-removal.png

Next up is the search, I think.

testing 1 2 3

@lyse@lyse.isobeef.org love the unicorn vomit! All of them, but vomit 1 is my favourite. :-)

@lyse@lyse.isobeef.org Shadow on the wall!!1! 📣😅

https://gopher.floodgap.com/gopher/gw?gopher://magical.fish/1/chat .

Se encuentra en gopher://crotera.net.ar:7026/1/

The guy really felt that his silly stupid movie got exposed for being irrelevant. More people care about Star Wars than they care about me? So what? Most people don’t care about Star Wars at all. So, yes, 1 > 0. And 1 is still irrelevant.

I went 1-for-2 again at Magic today, winning the first game with my (mostly standard) Fallout “Hail, Caesar” deck by creating a swarm of soldiers and slapping people across the face with them (LOL!), before quitting the 2nd game for lack of time after my board got wiped (I mean, I might have lucked into something eventually, but it was getting late, so I dropped out).

I hope to play more regularly going into the summer, but who knows.

I should have changed the key binding from Print to Shift+Print a long time ago to launch import and upload the screenshot to my server. I was constantly hitting that stupid key on accident when I actually wanted to press [AltGr].

If I only could map a key binding to slap these damn ThinkPad T15 keyboard layout designers at Lenovo remotely in the face. Seriously, who in their right mind puts Print (in German Druck) between AltGr and Ctrl at the bottom row to begin with?! Exactly. Nobody. What a horrible location.

https://www.notebookcheck.net/fileadmin/_processed_/e/6/csm_ThinkPad_T15_Gen2_Eingabe_1_d94cf14182.jpg

Estoy probando el simulador Flightgear 2024.5.1. Muy bueno!

I just wanted to look up 9V block battery prices online and these automatically generated descriptions are getting dumber by the minute:

Datum der Erzeugung: Verfallsdatum minus 7 Jahre

(Date of manufacturing: expiration date minus 7 years)

Or look at this one:

Die leistungsstarke 9 V-Block E Batterie, auch 6LR61 genannt, eignet sich besonders gut für Taschenlampen, Radio oder Kinderspielzeug, die einen gleichbleibenden Strombedarf haben. Ihre max. Spannung beträgt 1,5 V.

(The high performance 9 V block E battery, also known as 6LR61, is particularly suitable for torches, radio or child’s toys, which have a steady power demand. Its max. voltage is 1.5 V.)

The battery is best suited for… devices where it fits. No shit, Sherlock! Has anyboy ever come across 9V block torches? O_o I haven’t.

Just missed the 15th anniversary of the Linux installation on my laptop:

$ head -n 1 /var/log/pacman.log
[2011-04-27 11:38] installed filesystem (2011.04-1)

@prologic@twtxt.net @movq@www.uninformativ.de @bender@twtxt.net Thank you very much! <3

I only filtered out the noise floor of the camera itself. I selected one second of “silence” in Audacity and used the “Effect” → “Noise reduction” (Rausch-Verminderung in German) dialog with its default settings. I repeated that two or three times in total with different sections of “silence”. It’s very hard to find something where there is really no other bird singing in the background. But in contrast to the original audio, the edited version is noticeably more squeaky I find.

Oh, and I increased the volume. Especially after the noise reduction, everything is a bit quieter.

I got rather lucky, only a few cars went by and my microphone is too shitty, to really pick it up. :-D It’s kinda drowned out by the background noise. 45 seconds into the video, a car passes. Also at 1:10 without a doubt. I’m sure there were actually many were. Most of them passed behind me, the mic is facing away from that sound source. Of course, the densely built-up area still reflects a lot.

It also helped that Azabache is a loud singer himself. Fortunately, no idiots screaming either.

If you want to compare yourself or play around to see what other improvements you are able to achieve, I uploaded the original from the camera in the same directory under the lovely name DSCN5687.MOV. It’s 236.1 MiB in size.

@bender@twtxt.net Well I’m open to ideas of course 😅 My goal here was to build something like a Civ-1 inspired game that’s playable online and multiplayer. Do you remember this old bad boy that was played on PC(s) on MS-DOS ?! 😅

Actual Software for Win3x: gopher://shibboleths.org/1/win31

As an enjoyer of delightfully bad graphic design, found on most Czech village center cork boards, I’m sad to see the stolen clipart and badly cropped watermarked stock images, gradually replaced with AI slop.

This is far from a serious rant, but generating images of my kind being telepathically hit with sharp rocks, surely gives me a right to complain.

So far these seem the most prominent slop categories, seem to be…

Architecture slop:

1. find a sketch of what an old building looked like
   
   
2. generate an AI version, without correcting any of the perspective errors - this one is diagonally levitating
   
   
3. generate a recreation of the buildings demise - after going through the AI, for the second time, it is now a completely different building
   
   

Moralizing slop:

History slop:

@movq@www.uninformativ.de LOL. I think I get the idea. I am concerned about AI too. Managers starting with “I don’t know anything about this, but here is what says”. Infuriating.

I came across this one today, here is a gift link: https://www.nytimes.com/2026/04/15/opinion/art-artificial-intelligence.html?unlocked_article_code=1.bFA.XNiu.ZukFfdNl3Al1&smid=nytcore-ios-share

@movq@www.uninformativ.de Yup, I’ve also seen the floating point conversion happening with (1 << 63) - 1 yesterday night. But instead of pausing to think about it for a second, somehow all I had in mind was “give me a better representation, ain’t gonna have time for this shit”, so I turned it to hex. Beyond my comprehension what I was thinking there. O_o That’s embarrassing, unbelievable. Well, I blame late o’clock where my brain had already quit on me and went to bed.

Very interesting data point you raise there. The fun part didn’t cross my mind yet or at least I couldn’t pinpoint it. In hindsight it’s totally obvious, though. Past experience also tells me the exact same. Dealing with a problem and researching something myself is a so much more better teacher. The longer I faced up with a topic, the higher the chance to really manifest in long- or at least mid-term memory. If I just get told something, the odds are that it’s completely erased from memory in a matter of days if not hours.

@lyse@lyse.isobeef.org AI result ahead, feel free to ignore.

I “asked” the AI at work the same question out of morbid curiousity. It “said” that SQLite converts that integer to floating point internally on overflows and then, when converting back, the x86 instruction cvttsd2si will turn it into 0x8000000000000000, even if the actual floating point value is outside of that range. So, yes, it allegedly actually saturates, as a side effect of the type conversion.

I couldn’t find anything about that automatic conversion in SQLite’s manual, yet, but an experiment looks like it might be true:

sqlite> select typeof(1 << 63);
╭─────────────────╮
│ typeof(1 << 63) │
╞═════════════════╡
│ integer         │
╰─────────────────╯

sqlite> select typeof((1 << 63) - 1);
╭──────────────────────╮
│ typeof((1 << 63) ... │
╞══════════════════════╡
│ real                 │
╰──────────────────────╯

As for cvttsd2si, this source confirms the handling of 0x8000000000000000 on range errors: https://www.felixcloutier.com/x86/cvttsd2si

The following C program also confirms it (run through gdb to see cvttsd2si in action):

<a href="https://yarn.girlonthemoon.xyz/search?q=%23include">#include</a> <stdint.h>
<a href="https://yarn.girlonthemoon.xyz/search?q=%23include">#include</a> <stdio.h>

int
main()
{
    int64_t i;
    double d;

    /* -3000 instead of -1, because `double` can’t represent a
     * difference of -1 at this scale. */
    d = -9223372036854775808.0 - 3000;

    i = d;
    printf("%lf, 0x%lx, %ld\n", d, i, i);

    return 0;
}

(Remark about AI usage: Fine, I got an answer and maybe it’s even correct. But doing this completely ruined it for me. It would have been much more satisfying to figure this out myself. I actually suspected some floating point stuff going on here, but instead of verifying this myself I reached for the unethical tool and denied myself a little bit of fun at the weekend. Won’t do that again.)

@lyse@lyse.isobeef.org

Disclaimer: Can’t guarantee that I’m fully awake and I’m being trained at work not to use my brain anymore, so maybe this is complete bullshit. 😪🧟‍♀️

It says here that SQLite uses signed integers:

https://sqlite.org/datatype3.html

In pure bits, 1 << 63 would be 0x8000000000000000, but as a signed value, it gets interpreted as -9223372036854775808. Subtracting 1 yields -9223372036854775809 – but that doesn’t fit in 64 bits anymore. It’s possible that SQLite doesn’t want to wrap around but instead saturates? Haven’t checked. 🤔

With 62 bits, there is enough room.

With 1 << 64, I have no idea how SQLite wants to handle this, because this should immediately trigger a warning, because it doesn’t fit right away. Maybe it gets truncated to 0?

sqlite> select printf('0x%x', 2 * (1 << 64));
╭──────────────────────╮
│ printf('0x%x', 2 ... │
╞══════════════════════╡
│ 0x0                  │
╰──────────────────────╯
sqlite> select printf('0x%x', 0 - 1);
╭──────────────────────╮
│ printf('0x%x', 0 ... │
╞══════════════════════╡
│ 0xffffffffffffffff   │
╰──────────────────────╯
sqlite> select printf('0x%x', 0 - 2);
╭──────────────────────╮
│ printf('0x%x', 0 ... │
╞══════════════════════╡
│ 0xfffffffffffffffe   │
╰──────────────────────╯

Eehhh, what the hell is going on here!?

SELECT
    printf("0x%x", (1 << 63) - 2),
    printf("0x%x", (1 << 63) - 1),
    printf("0x%x",  1 << 63     ),
    printf("0x%x", (1 << 63) + 1),
    printf("0x%x", (1 << 63) + 2)

SQLite yields:

0x8000000000000000 (instead of 0x7ffffffffffffffe)
0x8000000000000000 (instead of 0x7fffffffffffffff)
0x8000000000000000 (correct)
0x8000000000000001 (correct)
0x8000000000000002 (correct)

Huh!? O_o Am I stupid? What am I missing here? Or is this actually a bug? :-?

With 62 bits, everything is spot on:

0x3ffffffffffffffe
0x3fffffffffffffff
0x4000000000000000
0x4000000000000001
0x4000000000000002

And 64 bits rather unsurprisingly also yield:

0xfffffffffffffffe
0xffffffffffffffff
0x0
0x1
0x2

@lyse@lyse.isobeef.org 1, 3, and 22 are my picks on this very reduced set. Our bird is King/Queen, and that stop on the roof is their spot! 🥰

Send snail mail to Cupertino: 1 Apple Park Way, Cupertino CA 95014

I went 1 for 2 at Magic this week… Temmet made a good showing the first game before being overwhelmed by an infinite number of Wylls (aka Fred Durst, on account of all his “rollin’, rollin’, rollin’!”). As a result, I unleashed Chatterfang on the group for the second game, and he lead his squirrel army to victory once again. Good times!

What do the Gopher Troopers think of the following? The Gopher protocol is a nearly-forgotten network protocol from the early 1990s, designed to serve and navigate text-based menus and documents over the Internet. While it’s far less common than HTTP/HTTPS today, there are still some security risks associated with Gopher and Gopher space. Let’s break them down carefully: 1. Lack of Encryption Problem: Gopher was designed long before widespread use of SSL/TLS. All data—including credentials, file transfers, and menu selections—is transmitted in plaintext. Impact: Anyone intercepting traffic (e.g., via a network sniffer, public Wi-Fi, or a compromised router) can read sensitive information, including usernames and passwords. 2. No Authentication or Access Control Problem: Gopher servers rarely implement robust authentication; access control is usually limited or non-existent. Impact: Unauthorized users might browse sensitive directories or download private files, particularly if servers are misconfigured. 3. Server Software Vulnerabilities Problem: Modern OSes can still run legacy Gopher servers, but the software is often unmaintained. Impact: Old software may contain buffer overflows, directory traversal bugs, or command injection vulnerabilities that attackers could exploit. 4. Malicious Gopher Links Problem: Gopher menus can contain links that point to scripts or other servers, similar to hyperlinks in HTTP. A client following a malicious link could inadvertently: Download malware Access sensitive internal network resources (server-side request forgery) Impact: Could serve as a vector for attacks if a user opens content from untrusted sources. 5. Legacy Protocol Weaknesses Problem: Gopher lacks modern web security mechanisms like: Content security policies Same-origin policies Cross-site request forgery protection Impact: If Gopher is bridged to other services (like modern browsers via gateways), old vulnerabilities may be exposed. 6. Information Leakage Problem: Gopher servers often provide directory listings without restriction. Impact: Sensitive files, backup directories, and internal documents may be exposed unintentionally. 7. Bridging Risks Problem: Some modern browsers access Gopher via gateways (HTTP-to-Gopher proxies). These bridges may: Expose sensitive internal resources to the gateway Introduce logging or tracking that wouldn’t exist on pure Gopher Impact: Attacks could occur indirectly through insecure intermediaries. Key Takeaways Gopher is inherently insecure due to its design in a pre-HTTPS era. Main threats: eavesdropping, unauthorized access, malware delivery, and exploitation of unpatched server software. Safe practice: Use Gopher only in isolated, trusted environments, or through secure HTTP(S) gateways with proper sanitization.

@lyse@lyse.isobeef.org Thanks (again) for the heads-up!. I’m not sure why you were seeing black text, but I just pushed a new version of the library (v0.10.1) with some updated colors in the demo’s themes (which should hopefully address the contrast issues).

The dark mode was an aesthetic choice by a designer with a strong preference for dark mode (and who thought the maroon looked better as a background color), but in the interest of being supportive of my audience, I added a localstorage-backed memory to the theme toggle (so when you turn it to light mode, it should remember for future visits).

Went 2/3 at Magic today: Prosper dominated game 1, Ash and his Knights came within a single planar die roll of winning game 2, and then Atraxa came up with the win in a fairly tight game 3. All in all, not a bad afternoon of Magic.

I’m supporting incremental SQLite schema changes to just upgrade from an older database version to whatever the current software version supports. In the past, I already noticed that this is quite expensive in unit tests when each test case runs through the entire schema patches and applies them one by one.

To speed up test execution I now decided that I finally go through the troubles of maintaining both a set of incremental patches and a full schema setup in one go. A unit test verifies that both ways end up with the same structure. This gives me a set of SQLs to check the structures:

SELECT type, name, tbl_name, sql
FROM sqlite_schema
ORDER BY type, name, tbl_name

Unfortunately, the resulting CREATE TABLE SQL queries are formatted differently, depending on whether the full schema was set up in one big step or the structure had been modified with ALTER TABLE. Mainly, added columns are not on their own lines but appended in one physical line. That’s why I wanted an SQL formatting tool. Since I didn’t find one that works decently, I’m now doing some simple string manipulation. Joining consecutive whitespace into a single space character, removing spaces before commas and closing parentheses and spaces after opening parentheses. This works surpringly good enough. Of course, if it fails, the “diff” is absolutely horrendous.

Now for the cool part, my test execution dropped from around 5:05 minutes to just 1:32 minutes! I call that a win.

I just stumbled across PRAGMA table_info('tablename') https://sqlite.org/pragma.html#pragma_table_info, PRAGMA foreign_key_list('tablename') and friends. I guess, I have to play with that, now. It’s probably much better to use than the SQL text approach.

To whoever is operating this “xt” client, there might be a misconfiguration. My feed is often, but not always, pulled twice within a few seconds:

2026-03-14T15:31:02+01:00 "GET /twtxt.txt HTTP/1.1" 304 "xt/0.0.1"
2026-03-14T15:31:31+01:00 "GET /twtxt.txt HTTP/1.1" 304 "xt/0.0.1"

2026-03-14T15:41:19+01:00 "GET /twtxt.txt HTTP/1.1" 304 "xt/0.0.1"
2026-03-14T15:41:31+01:00 "GET /twtxt.txt HTTP/1.1" 304 "xt/0.0.1"

2026-03-14T15:51:04+01:00 "GET /twtxt.txt HTTP/1.1" 304 "xt/0.0.1"

2026-03-14T16:01:25+01:00 "GET /twtxt.txt HTTP/1.1" 304 "xt/0.0.1"
2026-03-14T16:01:27+01:00 "GET /twtxt.txt HTTP/1.1" 304 "xt/0.0.1"

2026-03-14T16:11:51+01:00 "GET /twtxt.txt HTTP/1.1" 304 "xt/0.0.1"
2026-03-14T16:11:54+01:00 "GET /twtxt.txt HTTP/1.1" 304 "xt/0.0.1"

2026-03-14T16:21:53+01:00 "GET /twtxt.txt HTTP/1.1" 304 "xt/0.0.1"

2026-03-14T16:32:19+01:00 "GET /twtxt.txt HTTP/1.1" 304 "xt/0.0.1"
2026-03-14T16:32:22+01:00 "GET /twtxt.txt HTTP/1.1" 304 "xt/0.0.1"

2026-03-14T16:52:28+01:00 "GET /twtxt.txt HTTP/1.1" 304 "xt/0.0.1"
2026-03-14T16:52:31+01:00 "GET /twtxt.txt HTTP/1.1" 304 "xt/0.0.1"

Maybe this is caused by a development and a production setup, no idea. Since this client is sending the If-Modified-Since or If-None-Match request header, I’m good with that, though. Looking forward to discover a new feed hopefully soon. :-)

Hi @c2803! You are right. But whot is the reason, that the onion site of magical.fish is not working? Why 1436.ninja/1/Port70News is not working? Why gopher://sdf-eu.org is not working? I thing, big companies or states are making troubles to gopher sites. If you like to search the web anonymously, take the onion site of me0w.net .

Actual Software For Win3x Users: gopher://shibboleths.org/1/win31

Do not die from hunger. Man does not live from bread only, but from every word out of God’s mouth. Read the Good News of Matthew in the Bible. bible.com or 5fi.sh in every language or gopher://rbfh.de or gopher://sdf.org/1/users/scn/Bibel .

@bender@twtxt.net Here is a properly formatted version of your message:

Not yet — but that’s probably a good idea.

Instructions:

1. Clone the repository
   

git clone https://git.mills.io/saltyim/saltyim.git
cd saltyim

1. Check out the v2 branch
   

git checkout v2

1. Build and install the CLI/TUI
   

make DESTDIR=$HOME/bin install

After installation, run:

salty-chat

A Phlog about the mysteries of history and the most incredible events, new conspiracy theories and the wildest world news gopher://shibboleths.org/1/phlog

I’m trying to implement configurable key bindings in tt. Boy, is parsing the key names into tcell.EventKeys a horrible thing. This type consists of three information:

1. maybe a predefined compound key sequence, like Ctrl+A
   
2. maybe some modifiers, such as Shift, Ctrl, etc.
   
3. maybe a rune if neither modifiers are present nor a predefined compound key exists
   

It’s hardcoded usage results in code like this:

func (t *TreeView[T]) InputHandler() func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
    return t.WrapInputHandler(func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
        switch event.Key() {
        case tcell.KeyUp:
            t.moveUp()
        case tcell.KeyDown:
            t.moveDown()
        case tcell.KeyHome:
            t.moveTop()
        case tcell.KeyEnd:
            t.moveBottom()
        case tcell.KeyCtrlE:
            t.moveScrollOffsetDown()
        case tcell.KeyCtrlY:
            t.moveScrollOffsetUp()
        case tcell.KeyTab, tcell.KeyBacktab:
            if t.finished != nil {
                t.finished(event.Key())
            }
        case tcell.KeyRune:
            if event.Modifiers() == tcell.ModNone {
                switch event.Rune() {
                case 'k':
                    t.moveUp()
                case 'j':
                    t.moveDown()
                case 'g':
                    t.moveTop()
                case 'G':
                    t.moveBottom()
                }
            }
        }
    })
}

This data structure is just awful to handle and especially initialize in my opinion. Some compound tcell.Keys are mapped to human-readable names in tcell.KeyNames. However, these names always use - to join modifiers, e.g. resulting in Ctrl-A, whereas tcell.EventKey.Name() produces +-delimited strings, e.g. Ctrl+A. Gnaarf, why this asymmetry!? O_o

I just checked k9s and they’re extending tcell.KeyNames with their own tcell.Key definitions like crazy: https://github.com/derailed/k9s/blob/master/internal/ui/key.go Then, they convert an original tcell.EventKey to tcell.Key: https://github.com/derailed/k9s/blob/b53f3091ca2d9ab963913b0d5e59376aea3f3e51/internal/ui/app.go#L287 This must be used when actually handling keyboard input: https://github.com/derailed/k9s/blob/e55083ba271eed6fc4014674890f70c5ed6c70e0/internal/ui/tree.go#L101

This seems to be much nicer to use. However, I fear this will break eventually. And it’s more fragile in general, because it’s rather easy to forget the conversion or one can get confused whether a certain key at hand is now an original tcell.Key coming from the library or an “extended” one.

I will see if I can find some other programs that provide configurable tcell key bindings.

@eldersnake@we.loveprivacy.club

Steps to world domination:

1. “Invent” “AI” (by using other people’s data).
   
2. Get people hyped about it and ideally hooked on it.
   
3. Only provide it as a cloud service. But hey, if you want to, you can run it locally!
   
4. Buy all hardware available on the market, so that nobody but you can build more systems.
   
5. All PCs of consumers and competitors are too weak now and can’t be upgraded anymore.
   
6. Everybody depends on your cloud service! Win!
   

All of that is possible because corporations don’t have a “conscience” in capitalism. Nobody forces the RAM manufacturers to sell all their stuff to just one or two buyers, but since the only goal of that manufacturer is to make money, they do it.

Nice! 😊 Here are the startup latencies for the simplest Mu (µ) program. println("Hello World"):

• Interpreter: ~5ms
  
• Native Code: ~1.5ms

Hmmm 🤔

Excluding merges, 1 author has pushed 171 commits to main and 175 commits to all branches. On main, 294 files have changed and there have been 52880 additions and 18269 deletions.

From the Mu (µ) Gitea Activity Tab

@movq@www.uninformativ.de Well, just a very limited subset thereof:

1. inline and multiline code blocks using single/double/triple backticks (but no code blocks with just indentation)
   
2. markdown links using using [text](url)
   
3. markdown media links using ![alt](url)
   

And that’s it. No bold, italics, lists, quotes, headlines, etc.

Just like mentions, plain URLs, markdown links and markdown media URLs are highlighted and available in the URLs View. They’re also colored differently, similarly to code segments.

I definitely should write some documentation and provide screenshots.

@lyse@lyse.isobeef.org

I assume you made the thing load quickly, didn’t you?

That’s the problem with Python. If you have a couple of files to import, it will take time.

I want this to be reasonably fast on my old Intel NUC from 2016 (Celeron N3050 @ 1.60GHz) and I already notice that the program startup takes about 95 ms (or 125 ms when there are no .pyc files yet). That’s still fine, but it shows that I’ll have to be careful and keep this thing very small …

Python 3.14 will bring lazy imports, maybe that can help in some cases.

The tt URLs View now automatically selects the first URL that I probably are going to open. In decreasing order, the URL types are:

1. markdown media URLs (images, videos, etc.)
   
2. markdown or plaintext URLs
   
3. subjects
   
4. mentions
   

I might differentiate between mentions of subscribed and unsubscribed feeds in the future. The odds of opening a new feed over an already existing one are higher.

Whoo! I fixed one of the hardest bugs in mu (µ) I think I’ve had to figure out. Took me several days in fact to figure it out. The basic problem was, println(1, 2) was bring printed as 1 2 in the bytecode VM and 1 nil when natively compiled to machine code on macOS. In the end it turned out the machine code being generated / emitted meant that the list pointers for the rest... of the variadic arguments was being slot into a register that was being clobbered by the mu_retain and mu_release calls and effectively getting freed up on first use by the RC (reference counting) garbage collector 🤦‍♂️

very good blog post that reminded me why it’s taking so long to ship bbycll — previously i had computed the hashes of every post before storing them in the database, after realizing it’s a much better idea to compute the hashes during runtime and only store the post content & timestamp i’m now having to rewrite every function that reads & writes data. i hope the reason as to why i lost motivation is obvious — thankfully i caught it early enough so that once i’m done rewriting just those functions i should™ be able to finalize 1.0-rc with little hassle

⇒ the cardinal sin of software architecture: the unnecessary distribution, replication, or restructuring of state, both in space and time.