I don’t get people strolling in nature with headphones on and constantly staring at their phones all the time. Why even go outside if you cover ears and eyes? Okay, you’re on the move and smell the country air, but still. Yesterday, one girl was wearing earphones and reading a real book while walking on a field path. Better than a phone, sure, but what the hell!?

@david@daiwei.me I first thought that this is a real lake, but it’s just a lake of craziness. :-D A town owned by a company (or so it reads to me), that’s insane.

Let me send you some nice 17°C.

@prologic@twtxt.net Yeah, great documentary. I was reading up on Orcas a few months ago. Zoos are really problematic.

@david@daiwei.me Yeah, with the long and thus taller list entries, things are getting off hands. Ah, when focused, you wouldn’t differentiate between read or unread.

@prologic@twtxt.net A screenshot won’t help in this case, as you don’t see anything. :-D It starts off just fine with a conversation tree like that:

Unknown conversation root
└╴Read reply
  └╴Read subreply

Everything works. After reloading the feeds, a new message becomes part of the conversation, so the conversation e.g. looks:

Unknown conversation root
└╴Read reply
  ├╴Read subreply
  └╴Unread subreply

However, the bug is that the whole conversation is not shown at all. None of the three (or four with the root) messages appear in the message tree view. My recursive SQL determining the messages to display is clearly broken.

📣 ACTION REQUIRED: Hey folks 👋 For those of you whom are using the Twtxt App either via the Hosted option or on your own twtd instnace or via Github/Gitea or any other publishing backend (doesn’t amtter). Please read.

Please open the app and you should be prompted to save your recovery code for your device. This basically is all of your settings, follows, etc in the app itself. This is synced to the Origin everytime you make a change, and also stored on-device. This is what makes it possible to sync your setting across services, move to another device, etc.

Please save a copy of the recovery code somewhere. This is only your only way to recover your settings.

Thank you 🙏

I should really fix this damn bug where new replies to read replies to unknown conversation roots are not showing up in tt. I run into this bug almost daily for weeks now.

@david@daiwei.me Ha, I just noticed that I changed Newsboat’s defaults. Right from the factory, new items are just bold, while read ones aren’t. No different colors, white on black. Focused items are bold yellow on blue. No matter the read status. I think that’s why I started to play with the config to differentiate them. It’s been so long ago that I didn’t know anymore I even messed with that.

And yes, you’re right, the red on black is borderline readable. Also, my white on green focus is rather silly. But I’m sooo used to it, I don’t realize how bad the contrast is. To be fair, I don’t spend a lot of time in the lists. Aha, there are new articles, Enter to hit the artice view, read it, press n to immediately jump to the next unread article, rince and repeat, finally I’m back in the article list view.

Default theme, read focused:

Default theme, unread focused:

Lyse’s schlimmbesserung, read focused:

Lyse’s schlimmbesserung, unread focused:

@dce@hashnix.club Fixed! 🥳 That 403 was our bug — connect was checking your token via /api/v1/user (needs read:user), but your token’s scoped to just the repo so it can’t. Now it validates against the repo itself instead 👍

@lyse@lyse.isobeef.org It reads a lot nicer, yeah. And you can do oink.my_property += 1 as well, for example.

@david@daiwei.me Not sure if you only mean the code segments or in general. In theory, a general darker text color for read messages would probably work. The thing is that regular white on black is quite standard. In Newsboat, new articles are red (I opted for yellow here) and read ones white. I found that useful and kinda copied it for tt.

@prologic@twtxt.net I created a repo called twtxt and an application key with read/write access to it (and only it). I then cloned the repo on Hashnix and hardlinked my twtxt into it, before committing and pushing. Next, I supplied the appropriate details on twtxt.app, under Codeberg/Gitea, and clicked “Connect”. gitea https://codeberg.org/api/v1/user: 403 Forbidden.

As an alternative, I also gave a much simpler teal on gray with reversed colors on focus a shot. Hmm, not so sure either. :-?

Unread messages:

Read messages:

Unread messages are yellow, while read messages are white in tt. Focusing them just alternates the fore- and background colors. With the old color scheme, I disliked that inline code and code blocks were basically just the opposite of normal text. Hence, unread code was white and read code yellow. I found this often confusing, especially with larger code blocks. Sure, there are the timestamp and author columns that still show the usual white (read) and yellow (unread) background for selected messages, but still.

This is how it was before with unread messages:

Before with read messages:

So, I just reworked the code styles. Not sure if I like that or if it is actually an improvement. Unread code is teal on gray when not in focus and becomes blue on orange when focused. I thought the dark gray code background on a black regular background is still nice and subtle. The same similarity in colors for focused messages meant to go with an orange code background on a yellow regular background. The teal was too light, so went with a blue foreground color:

When read and unfocused, the new color scheme calls for the same code style teal on dark gray. However, with white as the main background for selected messages, I went with a light gray code background and a blue code foreground. Again, the contrast with white and teal wasn’t good enough. Vice versa, blue on dark gray is also not all that readable:

It looks like a parrot. Let’s see if I begin to like it.

@movq@www.uninformativ.de The nice thing about properties is that you can compute and cache things on the fly at first attempt and also ensure validation for writing. But like you said, since it’s not obvious that reading or writing might do some more things, it’s strongly advised to avoid doing expensive stuff disguised as properties.

I reckon the vast majority of property use cases is to provide read-only access. At least that was my impression when I was doing a lot more in Python.

Personally, I think that this just reads a lot nicer:

oink.my_property
oink.my_property = 42

Than:

oink.get_my_property()
oink.set_my_property(42)

Btw, any field access is implemented using method calls. I might be wrong, but I believe there’s always __getattr__ and __setattr__ involved. 8-)

I trip over this in our code at work all the time.

Python has this concept of “properties”:

class Oink:
    def __init__(self):
        self._foo = 3

    @property
    def my_property(self):
        return self._foo


a = Oink()
print(a.my_property)

my_property() is a method but it can be used as if it were a field.

This can also be used to define a setter:

class Oink:
    def __init__(self):
        self._foo = 3

    @property
    def my_property(self):
        return self._foo

    @my_property.setter
    def my_property(self, value):
        self._foo = 123 * value

Because, for some reason, Python people don’t like getters and setters. Instead, they hide it behind a property.

The result is, when you read this:

a.my_property = 5
print(a.my_property)

You have no idea that this actually calls a method.

Does yarnd still support the old “threading”? Let’s see.

I really think I should go back to Java.

Writing programs in Python is so exhausting. I want a compiler and I want static typing. No, linters and type checkers and IDEs are not good enough. Compilers catch way more errors in advance.

Rust is also exhausting. They’re constantly adding language features and, at the same time, the runtime library remains tiny and you need 3rd party libraries for everything. Many of those are still at version 0.x (SemVer!) and you can’t rely on anything. Often times, you need the latest Rust nightly compiler.

Go is … I don’t like it. And huge binaries.

I like C as a language, but it’s too fragile. I want to have a proper HashMap every now and then.

None of the above have good GUI libraries, at least not on Linux.

And then there’s Java. This is my fractal renderer that I wrote over 17 years ago:

https://movq.de/v/fcd3c4e557/vid-1784121825.mp4

It’s fast. It has a GUI with custom widgets and those weren’t even hard to make. It still works without changing a single line of code. The source code files have timestamps from 2009 and I just noticed that the JAR file I’m using in the video was compiled in 2010.

Java as a language is relatively easy to learn and to master. There are few surprises. The source code organization with packages is good. Java API docs are clear and well written.

The JVM ramp-up times have improved considerably:

https://movq.de/v/e7314e521e/vid-1784121998.mp4

This isn’t like the Dark Ages anymore. Might even be usable for some CLI tools.

The only thing where Java really sucks is anything close-ish to the kernel. Try issuing an ioctl() … I couldn’t have made my TUI framework in Java, but then again, I wouldn’t have needed to because Swing already exists and it just works.

Hurray, I can now press gg instead of g to go to the top in tt. Much better! :-) Other multi-key combinations are also easily possible now.

I should probably write a real article about this at some point, but here we go. The only downside with my new key binding system is that it breaks tview’s established pattern. You’ve got an InputHandler(), that is implemented using WrapInputHandler(…). It typically then directly implements the switching logic depending on the key press. Something like this:

func (w *Widget) InputHandler() func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
    // WrapInputHandler allows for intercepting key events with SetInputCapture(…)
    // from the outside for customization. This handles the default key bindings.
    return t.WrapInputHandler(func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
        switch event.Key() {
        case tcell.KeyRune:
            if event.Modifiers() == tcell.ModNone {
                switch event.Rune() {
                case 'k':
                    w.scrollUp()
                    return // we already handled the event, stop processing

                case 'j':
                    w.scrollDown()
                    return
                }
            }
        }

        // We didn't handle the key event. Maybe the parent
        // widget knows what to do with it.
        if handler := w.parent.InputHandler(); handler != nil {
            handler(event, setFocus)
        }
    })
}

From the outside, you can intercept and either stop or continue the widget’s original key handling with a potentially rewritten key event using SetInputCapture(…):

w := NewWidget()
// customized or additional key bindings
w.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
    switch event.Key() {
    case tcell.KeyUp:
        // Rewrite the event, so the "cursor up" key is an alias
        // for the vim key binding "k", that is handled by the
        // wrapped input handler above. (I know, I know, this is a
        // completely unrealistic example, why would anyone use
        // cursor keys when there are vim key bindings available?!)
        return tcell.NewEventKey(tcell.KeyRune, 'k', tcell.ModNone)

    case tcell.KeyRune:
        if event.Modifiers() == tcell.ModNone {
            switch event.Rune() {
                case 'q':
                    app.Stop()
                    // we already handled the event, do not pass it
                    // to the wrapped input handler above
                    return nil

                case 'r':
                    toggleMessageReadStatus()
                    return nil
            }
        }
    }

    // we didn't handle the event, pass it to the wrapped
    // input handler above
    return event
}

Since they all expect a single key, I’ve noticed that using multiple dedicated KeyBindings of mine on these different levels kinda breaks multi-key handling with common prefixes. The outer-most KeyBinding captures the prefix, but it can’t transfer it to the inner one if not handled by the outer one. At least not without some more (potentially ugly) changes. So, I now have to work with just a single KeyBindings object for the entire widget chain (if it consists of multiple other widgets or the regular input handler and input capture are in the game). The outside needs to register all its key bind customizations or extensions at the same level that the original widget handles its default ones. Doable by exposing the widget’s KeyBindings instance, but not pretty. You always have to keep this in mind.

With the KeyBindings, it will look like that:

type Widget struct {
    parent tview.Primitive

    // make it available to children or the outside either by
    // direct field access or by providing a getter method
    KeyBindings *bind.KeyBindings
}

func NewWidget() *Widget {
    w := &Widget{KeyBindings: &bind.KeyBindings{}}
    w.KeyBindings. // default key bindings
        Bind0(bind.KeySequence('k', w.scrollUp).
        Bind0(bind.KeySequence('j', w.scrollDown)
    return w
}

func (w *Widget) InputHandler() InputHandler() func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
    return t.WrapInputHandler(func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
        // also note the missing support for focus transfer at the moment
        event = w.KeyBindings.Capture(event)
        if event == nil {
            return
        }

        if handler := w.parent.InputHandler(); handler != nil {
            handler(event, setFocus)
        }
    }
}

And then from the outside, or in a child widget:

w := NewWidget()
w.KeyBindings. // additional or customized key bindings
    Bind1(bind.KeySequence(tcell.KeyUp), func(*tcell.EventKey) *tcell.EventKey {
        return tcell.NewEventKey(tcell.KeyRune, 'k', tcell.ModNone)
    }).
    Bind0(bind.KeySequence('q'), app.Stop).
    Bind0(bind.KeySequence('r'), toggleMessageReadStatus)

When directly working with tview primitives that are not part of custom widget implementations, the following works well so far:

textView := tview.NewTextView().
    SetWordWrap(true).
    SetText("…")
    SetScrollable(true)
textView.SetInputCapture((&bind.KeyBindings{}).
    Bind0(bind.KeySequence('q'), app.Stop).
    Bind1(bind.KeySequence('g', 'g'), func(*tcell.EventKey) *tcell.EventKey {
        return tcell.NewEventKey(tcell.KeyHome, 0, tcell.ModNone)
    }).
    Capture)

I need to sleep on this some more.

Also, writing very long messages like this one is really not all that fun in tt’s editor. I should absolutely provide a way to shell out to vim.

(Took me about one and a half hours to compose, holy crap. But not only because of not using vim. Although, that might have saved me a quarter hour or so for sure. Proof-reading this message also uncovered quite a few bugs in my real documentation. So, that’s a big win!) Good night!

Of course, Marco will never read my reply, I am afraid, because his is, yet-another, one way feed.

@bender@twtxt.net Thanks, mate!

On the back of the bench, the badge says: “Gestiftet Verein berg hohenstaufen Göppingen 2013”. I read that as the Mt. Hohenstaufen club donated the bench itself:

On the front of the bench, the badge says: “Gestiftet von Hildegard Schuster, Gesellschafterin der Schwarz-Gruppe, Firma Wackler”. The bronze lady was donated by a shareholder of the Schwarz group, specifically the local Wackler trucking and logistics company. Clip of 27 in original resolution:

The book itself reads: “Zur Erinnerung an Ralph Kobza” It’s in memory of the sales manager of the art foundry next town that created also this statue. My mate took this photo:

Reading you loud and clear 😅

@lyse@lyse.isobeef.org the siting lady reads this?

Gestiftet von
Hildegard Schünar
Gesellschafterin
der Schwarz-Gruppe
Firma Wüst's
Anni

Or it is something else? Awesome pics, Lyse! Some oldies I missed (the lady), and some pretty cool new ones. I can’t get enough of nature pics!

I just read @kat@yarn.girlonthemoon.xyz’s blog post over here:

https://bubblegum.girlonthemoon.xyz/articles/learning-to-code-like-it-s-the-90s

Jesus, it must be so overwhelming for young people to get started with programming.

When I started programming, there was the built-in ROM BASIC of that PC and probably a bit of BASIC on a floppy, and that was it. Nowadays? Millions of libraries and frameworks and languages and what not – and, much worse, there’s the expectation that you need to make something fancy. When I started, printing something and understanding IF was good enough.

@movq@www.uninformativ.de It’s working fine. I can still read your messages. :-)

Oh, that‘s sad, Om Malik was one of those writers I read again and again. Rest in peace. https://om.co/2026/06/24/1966-2026/

@prologic@twtxt.net That’s how I read that, too. :-D Unfortunately, all listed articles stop at only 30% maximum. Scam!!

(Lol, but this ended up on HackerNews. 189 comments at the moment. https://news.ycombinator.com/item?id=48586231 hfgl, I’m probably not gonna read that.)

In today’s #caturday image, Emperor Maximilian the First tries to teach his subjects how to play Sequence, despite never having read the rules himself…

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!

Next up is the search, I think.

@movq@www.uninformativ.de Hahaha, great timing! :-D I love your article and agree with almost all your points.

On the AI changelog part, though, I’d rather recommend to just not have a changelog at all.

Another important thing for me is the deprecation notice section. What do I need to look out for in the future? Should I start to migrate to another API soon? Even right now? Or does it have time?

While going through these terrible GitHub release pages, I also found these “New Project Contributors” sections (yeah, for that, they found the time to make a section) annoying. Don’t get me wrong, sure, credit where credit is due. But come on. Soooooo much space for an inefficiently formatted (and also unsorted) list. At least it was easy enough to skip over it.

And then, there are also these changelogs or rather notice documents in general that are infested with multicolored emojis all over the place. My brain’s spam filter kicks in and shoves everything to /dev/null immediately. It’s especially a thing at work.

In my previous work project, we also used the Keep A Changelog Format. That was great. You wouldn’t believe how often I resorted back to that document. At least twice a week, often several times a day. I was very glad that we put in this effort. Of course, writing the changelog took its time, but it was worth every minute and more. Reading a many months old item, it was immediately clear. I was our best customer in that regard.

Now, it’s just the same auto shitshow with MR titles in a rolling date-versioned release scheme. It’s just our team who has to deal with that, though. I think I’m the only one who is not a fan of it.

@itsericwoordward@itsericwoodward.com I just want to let you know that your mention completion seems to be broken. :-) The URL is duplicated with a comma in between. Actually, the protocols differ. I suspect that you extract all url metadata fields from the feed, not only the canonical one used for hashing (the first one) and join them. I’m not completely sure, I would need to read up on the specs (it’s already past bed o’clock, though), but I guess that there is no explicit rule for picking the mention URL. Without having thought about it too much, I reckon the safest bet is to stick to the hashing URL when in doubt and the URL that was used to subscribe to the feed is not available for whatever reason. The URL from the subscription list is probably even better.

@movq@www.uninformativ.de Related reading (if you’re interested): Let’s Talk about LLMs by James Bennett

First, it quotes the DORA report on the “State of AI-assisted Software Development”:

The research reveals a critical truth: AI’s primary role in software development is that of an amplifier. It magnifies the strengths of high-performing organizations and the dysfunctions of struggling ones.

At the end, it quotes the late Fred Books:

The first step toward the management of disease was replacement of demon theories and humours theories by the germ theory. That very step, the beginning of hope, in itself dashed all hopes of magical solutions. It told workers that progress would be made stepwise, at great effort, and that a persistent, unremitting care would have to be paid to a discipline of cleanliness. So it is with software engineering today.

@movq@www.uninformativ.de enjoy your vacation! A nice read here: https://web.archive.org/web/20260603173839/https://www.theatlantic.com/philosophy/2026/06/no-artificial-intelligence-is-not-conscious/687378/, if you get bored. :-P

@movq@www.uninformativ.de what are your thoughts after reading it?

@movq@www.uninformativ.de Interesting read! The current state is already a very great achievement. I felt honored being able to already have followed your development along here on twtxt. :-)

That’s a cool clock, I should remind myself of my working time, too.

Yay finally fixed some of those annoying “Mark as Read” behaviours/bugs 🐞

@bender@twtxt.net Fine, Let me answer properly and concretely 😅

Would you want your children not to learn anything, because “they have AI”?

No, children still need to learn. That will never change. What they learn however will over time.

Are you OK with your children using the AI for all of their homework?

Yes, frankly I am. Why? Because much of what we teach them in school is utterly pointless.
For example, learning to read Shakespear never taught me anything useful in my life. I regret much of my school years to be honest.
I leanred to read and write, sure. But I learned Math, Science, Computing and how things work on my own by being very curious.

What sense will it make?

That assumes I answered “no”, which I did not. So it all makes perfect sense :D

What kind of future would that bring for them?

This assumes I said “Yes”, which I did :D It will be an itneresting future that’s for sure. I don’t think we can just bury our heads in teh sand and pretend it’s all going to go away, It will not. It will make things very interesting for sure, as we’re already starting to see what’s possible and what’s changeing. For example; ordinary people are using these LLM(s) to write their legal suit and defense in courts with varying levels of success.

Even if AI were to become omniscient, what will it be of the human race then?

I’m not convinced it ever will. In fact, I am not convinced we know how to create true intellience at all.

What would we do?

What would be so different from say an Alien invasion from far superious beings?
What would we do that? Band together and defend humanity?

Serve the AI? Maintain the AI?

That assumes that “AI” will become intelligent and omniscient, which I don’t believe it ever will.

Would we have found the true meaning of life then?

If the meaning of life is to create our own sub-species liken to ourselves, sure, maybe. But is that even a reality? not sure, I doubt it. We barely understand ourselves at the best of times, let alone how our minds works.

To care for AI, Is that it?

How would this be different to caring for a friend, a family member If we could ever truly reate an actual sentient being with real feelings and intelligenace, is there any reason to worry? Could we not be freinds and have mutual goals and form relationships?

@bender@twtxt.net Now that’s an interesting philosophical viewpoint right there. But this assumes that the “AI” we seemingly have available to us today is actually telligent, understands and has cognitive reasoning. It does not. All of these LLM models from big-tech companies like Anthropic, OpenAI, Google, Microsoft, Meta and Alibaba are all just very powerful, very large multidimensional neural networks with attention that are very good at statistical probabilities of ‘what comes next”. I think we get really upset over the wrong things sometimes. We need to continue to be upset that these 🤬 companies have basically destroyed any meaningful value of the concept of Copyright and Intellectual Property and Works of art. The so-called “AI” we have today is just a tool. Can you say for certain that the typewriter and the computer ruined our ability to write? Perhaps yes, but we still learn how to do so, likewise, I still think that learning to write code, research, read and write are all valuable skills to learn. Later on once you have the basics, you can defer some of the “tedious” work to these models, because frankly, they’re far better at inferencing and pattern matching than you or i will ever be, not because they’re better at pattern-matching per se, but because they have been trained on a very large corpus and they are much much faster at doing the same basic things we are far superior at.

@bender@twtxt.net Nope. Trust me I do not. The only time I do is when I’m reading/writing. I otherwise have no inner monologue when doing anything.

Be the Blogger You Want to Be (Or Read) ?~L~X https://thenewleafjournal.com/b/E2M

@tftp@tilde.town Ah, I see. I have a feeling that a lot of stuff is going on under the hood all the time and it’s mostly the userland-visible things that stay the same? 🤔 But yeah, some stuff is really, really old, like the TCP code I’ve recently (tried to) read.

Ah, there’s even a term for it:

https://en.wikipedia.org/wiki/Generation_effect

The generation effect is a psychological phenomenon whereby information is better remembered if it is generated from one’s own mind rather than simply read.

hfgl with your coding agents

@tftp@tilde.town mentioning in here requires he whole shebang. With jenny, if using vim, there is a key combination:

Nick name completions: Allows you to use ^X ^U to turn verbatim nick names into full twtxt mentions. For example, typing “cath” and then pressing ^X ^U will turn “cath” into a full mention, like “@”. (This function will read the contents of your “~/.config/jenny/follow” file.)

See: https://movq.de/git/jenny/file/vim/README.html

Interesting read on the ECONNRESET saga, @movq@www.uninformativ.de. Thanks for the writeup! <3

I don’t read anymore, I INGEST

@lyse@lyse.isobeef.org

So, it’s plenty good enough for them.

Yeah, but on the other hand, you can’t even log in normally to a Matrix/Element account. I mean using username + password. It’s not expected that you ever log out or lose your browser session. If you do, you must use a one-time backup code (that you must create and save beforehand) to log in again.

To be fair, I can’t say that I fully understand what Matrix is doing in the first place. The text that I quoted reads like they have your keys. But they also claim that they only store this stuff encryped: https://element.io/en/help#encryption5 So … encrypted with what? Only option here is my password, isn’t it? (But if my password was good enough to reclaim an account … why do all the other stuff …)

Matrix takes end-to-end encryption seriously. When I ran a Matrix server for the family, the family members would regularly lose their keys, because they didn’t pay attention to something. That’s on purpose! Or rather, that was on purpose. Maybe it’s different these days?

No clue.

All sorts of .de domains don’t resolve right now. But not all, movq.de for example still works. All on our server and basically all major other sites are cactus. Maybe some DENIC problem? I’m too tired to investigate, but I’m looking forward to tomorrow to read some report on that. :-) Good night.

@movq@www.uninformativ.de I would love to read a more detailed account on these moves. When you write moved, you mean user data, correct?

Finished reading The Island of Desire, by Robert Dean Frisbie. A book of two halves; the first slow, and the second nail-biting. ★★★★ 📗