@movq@www.uninformativ.de @prologic@twtxt.net @itsericwoodward@itsericwoodward.com Let me join the Enterprise Ruined It For Me Club. :-D

@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.

Tops 25°C is a very welcome change. Tomorrow just 21°C (but right before I went to bed they forecasted two degrees less today).

@david@daiwei.me It’s truly mind-boggling. All the hand full of episodes I’ve seen so far on this channel are amazing. Totally worth tuning in. I have to catch up a lot. :-)

Spitzenmäßige Doku über @movq@www.uninformativ.des kleinen Hausflugplatz: https://www.youtube.com/watch?v=F72t2fpiWPo

That’s such a cool The Rest Is Science episode: What Are The Odds You’ll Become A Fossil? https://www.youtube.com/watch?v=cYvDaDb_mbw

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.

@movq@www.uninformativ.de Ich war nie im Ubuntuusersforum unterwegs. Aber zu Delphizeiten damals im „Planet Quellcodes“-Forum aktiv, das es längst nicht mehr gibt. Ich schätze, die Hochzeiten der Foren sind einfach rum. Heutzutage ist einmal sehr viel mehr Wissen andersweitig zugänglich und dann sind vermutlich die allermeisten Leute auch einfach auf Soziale-Medien-Plattformen unterwegs. Oder werden die eigenen Projekte auf dem eigenen Blog und dergleichen vorgestellt.

Dann gab’s auch (zumindest gefühlt) eine Zeit, in der man einfach keine sinnvollen Antworten mehr in Foren bekam. So kam das mir jedenfalls vor. Ist schon eine ganze Weile her, aber ich kann mich noch dunkel erinnern, dass ich bei Forensuchtreffern häufig auf Reaktionen à la „such doch selber“ stieß. Oder einfach zuhauf komplett falsche Antworten vorgeschlagen wurden. Ich hab mir dann angewöhnt, Forenbeiträge komplett zu ignorieren.

Einige Foren haben auch noch damit angefangen, anonyme Zugriffe zu unterbinden oder zumindest einzuschränken. Das half im Rückblick natürlich auch nicht, dieses Medium attraktiv zu machen.

@aelaraji@aelaraji.com That’s totally fine if you work at the beach. :-)

@david@daiwei.me Right now, tt’s theme is baked into the binary. I have to edit the ui/styles.go and recompile. Luckily, this almost takes no time. But my todo list already includes a bullet point to make this customizable via the configuration file. :-)

@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 I should maybe look into it some day.

@david@daiwei.me I had to look these up, horror isn’t my genre at all. :-D No idea what the cool kids use today, but I still have zsh as my interactive shell. For shell scripts, though, I try to stick to POSIX and only resort to bash if really needed or it would be too cumbersome.

@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 @movq@www.uninformativ.de Same with tt, hash v2 has to be used right from the epoch onward. (And now replying to a message with a timestamp before the epoch still results in a v1 hash.)

We got some rain. Not a whole lot, but it’s actually cooler now and the temperatures outside are below the ones inside.

Cool, @dce@hashnix.club. You’re the first one I come across who actually writes Korn shell scripts. :-)

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:

@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-)

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 My grief with Java is that it’s sooo verbose. Sure, all the enterprise garbage makes it a hell lot more terrible, but even regular Java feels always so lengthy. And back in the days when I was using it daily, I missed so many convenient things in the stdlib after having experienced Python’s “batteries included”. Not sure if or how recent Java versions caught up.

@david@daiwei.me Oh, really? I thought I’ve posted compose view screenshots before. Anyway. Glad you like it as much as I do. :-)

The update interval has always been one second. I just didn’t remember and thus tried to time it by watching the preview update while typing. It felt like roughly under two seconds, but apparently my inner clock was off. After taking the screenshot and then examining it more closely, I noticed that the interval is stated right in the UI. :-D So, I just amended my message and didn’t bother taking a new screenshot. I figured I just leave it alone and see who spots the change, if at all. And, of course, you found the easter egg. Congrats, mate! 8-)

@movq@www.uninformativ.de Looks like subject parsing is broken.

@david@daiwei.me Ramen! Bon appetit.

@balloon-fu-sen@tw.fus.f5.si Not bad, quite a groovy sound.

@zvava@twtxt.net hunter2

@prologic@twtxt.net Not sure if this really counts as a draft mode or this is what you had in mind. I just was in the editor for ages and didn’t close it. tt provides an integrated preview for the rendered message in there. It automatically updates every second.

Here’s a screenshot of the compose view with the conversation context on the top to which to reply to, the editor in the middle and the almost-live preview at the bottom, I hope it’s big enough:

But it’s not like I hit the “Add message” button in the compose view (the one currently selected on the screenshot), see the message in the conversation tree and then come back into the compose view to continue editing. There’s no edit functionality in tt. Once the message is appended to my twtxt.txt file on disk, all I can do is edit it with vim. The U+2028 line breaks are really annoying to deal with (I’m sure I could do something about that if I spent the time), so I try to avoid that at all costs.

Once new messages have been added to my local file, I then manually upload the file to my server in a separate terminal. There’s no upload command integrated into tt. Right from my very first message in the beginning, I’ve always done it exactly like that. I’m used to this and it really doesn’t bother me. But I can see that others might not be fans of that at all. I might add an upload mechanism to tt at some point in the future.

@david@daiwei.me Very nice!

Dear weather gods, can we please also have a decent amount of rain and not just a few drops that only make the humidity even worse?

@dce@hashnix.club I like the teal colors in the file manager.

@david@daiwei.me You mean, you mean… like mowing down a whole rain forest in a thunderstorm’s brutal heat? :-?

Show us today’s rain. :-)

Now, that’s cool shit, I have to say! Discovering so many hidden sounds… With Fotric Acoustic Imager: https://youtu.be/CKJT_ECOsK4

@david@daiwei.me Hahaahaaahaaaaa, that was funny as heck, mate! I had to laugh really hard! :‘-D

@david@daiwei.me Hahaha, for sure. (But my observation wasn’t meant as a complaint.)

@david@daiwei.me :-D

Wow, 79 new messages over night, similar numbers in the past days. Looks like we’re surfing a high-traffic wave again. :-)

@prologic@twtxt.net @david@daiwei.me Thanks! Hahaha, rest assured, it was not right from the beginning at all. I had to fix it over and over again.

Uuhh, nice, @eldersnake@we.loveprivacy.club is back!

@prologic@twtxt.net Perhaps somebody tried to register “yarn_secret_service”. 8-)

@prologic@twtxt.net Where’s the before picture!? :-D

@movq@www.uninformativ.de Yes, this is absolutely a no-go!

A long time ago when the first telemetry shitstorm happened, I added export GOTELEMETRY=off in my ~/.zshrc. But it doesn’t seem to be picked up at all (I actually call this sabotage!):

$ go env GOTELEMETRY
local

$ go env -w GOTELEMETRY=off
go: GOTELEMETRY cannot be modified

$ go telemetry off

$ go env GOTELEMETRY
off

@prologic@twtxt.net @david@daiwei.me I just want to bring up the following: From a data protection point of view, edits and deletions are important. But that’s about it, I will not join discussions on that topic. :-)

@prologic@twtxt.net You also have to tell us the username!

Hell yeah, @kat@yarn.girlonthemoon.xyz is back! \o/

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!

@david@daiwei.me Not so keen on the mowing part. :-)

@prologic@twtxt.net That’s a good way to keep spammers out:

Your browser did not pass the anti-spam check! Please make sure JavaScript is enabled and try again.

It was turned on.

@david@daiwei.me Haha, great response!

@movq@www.uninformativ.de Hottest room is still at 24°C. But that will change in this week, no doubt. :-(

@david@daiwei.me I don’t want to start the discussion again, but edits wouldn’t be an issue if we had agreed on a better addressing scheme. Maybe edit more as a quiet riot. :-P