lyse @lyse.isobeef.org
 (12m ago)

(#qpsyz6q) Wow, as I anticipated, this is waaay out of my capabilities to really understand it. But Iā€™m quite happy to just have spotted a mistake in an explanatory comment in section 4.5.2 ā€œThe icode Arrayā€. Of course, it should be /e + tc + /i + ni + t\0. Letā€™s hope that my e-mail with the patch actually makes it into Briamā€™s inbox. I fear GMail just hides it in the spam folder.

#uiokkxq
movq @www.uninformativ.de
 (1h ago)

I recently got an email with this byte sequence:

\xf0\x9f\x8e\x81\xf0\x9f\x95\xaf\xef\xb8\x8f

Thatā€™s U+1F381, U+1F56F, U+FE0F. The last one is a ā€œvariation selectorā€:

https://unicodeplus.com/U+FE0F

My toolkit renders this incorrectly ā€“ and so do tmux and GNU screen.

Unicode ainā€™t easy. šŸ„“

#pu4km3a
movq @www.uninformativ.de
 (3h ago)

(#hddm6pa) @prologic@twtxt.net Iā€™d love to take a look at the code. šŸ˜…

Iā€™m kind of curious to know how much Assembly I need vs. How much of a microkernel can I build purely in Mu (Āµ)? šŸ¤”

Canā€™t really answer that, because I only made a working kernel for 16-bit real mode yet. That is 99% C, though, only syscall entry points are Assembly. (The OpenWatcom compiler provides C wrappers for triggering software interrupts, which makes things easier.)

But in long mode? No idea yet. šŸ˜… At least changing the page tables will require a tiny little bit of Assembly.

#hgl7mjq
prologic @twtxt.net
 (3h ago)

(#hddm6pa) Iā€™ve only got a handful of syscalls working right now. Taking inspiration from the calling convention of the Linux kernel and even made the service/interrupt handler int 0x80h šŸ¤£ Iā€™ve only got read, write, alloc and exit working righ tnow šŸ„²

#hu7yu6a
prologic @twtxt.net
 (4h ago)

(#hddm6pa) Whohoo! šŸ„³ You have no idea how great a feeling this is! This includes the Mu stdlib and runtime as well, not just some simple stupid program, this means a significant portion of the runtime and stdlib ā€œjust worksā€ā„¢ šŸ¤£

#m6um2lq
prologic @twtxt.net
 (6h ago)

Btw @movq@www.uninformativ.de youā€™ve inspired me to try and have a good ā€˜ol crack at writing a bootloader, stage1 and customer microkernel (ĀµKernel) that will eventually load up a Mu (Āµ) program and run it! šŸ¤£ I will teach Mu (Āµ) to have a ./bin/mu -B -o ... -p muos/amd64 ... target.

#hddm6pa
prologic @twtxt.net
 (7h ago)

Took me nearly all week (in my spare time), but Mu (Āµ) finally officially support linux/amd64 šŸ„³ I completely refactored the native code backend and borrowed a lot of the structure from another project called wazero (the zero dependency Go WASM runtime/compiler). This is amazing stuff because now Mu (Āµ) runs in more places natively, as well as running everywhere Go runs via the bytecode VM interpreter šŸ¤ž

#lo7lumq
movq @www.uninformativ.de
 (1d ago)

(#mqvmwva) @bender@twtxt.net Iā€™m already using it for tracktivity (meant for tracking activities and events, like weather, food consumption, stuff like that), which is basically a somewhat-fancy CSV editor:

https://movq.de/v/f26eb836ee/s.png

I have a couple of other projects where I could use it, because they are plain curses at the moment. Like, one of them has an ā€œedit boxā€, but you canā€™t enter Unicode, because it was too complicated. That would benefit from the framework.

Either way, itā€™s the most satisfying project in a long time and Iā€™m learning a ton of stuff.

#sge677a
movq @www.uninformativ.de
 (1d ago)

(#4b4ypwa) @lyse@lyse.isobeef.org Unix terminals are quite limited in that regard. šŸ«¤ You know how Ctrl works? The XOR 0x40 thing? And Alt doesnā€™t exist at all, itā€™s just a prefixed ESC byte.

I was surprised to see curses knowing about ā€œShift+Tabā€, wondering how that is supposed to work. Well, itā€™s an escape sequence, of course (depending on the terminal, of course).

#5pxodta
lyse @lyse.isobeef.org
 (1d ago)

Here am I looking at the different tcell.Key constants and typing different key combinations in the terminal to see the generated tcell.EventKeys in the debug log. Until I pressed Ctrl+Alt+Backspaceā€¦ :-D Yep, suddenly there went my Xā€¦

So far, it appears as if I can have either only Ctrl or Alt as modifiers. But not in combination. And Shift is just never ever set at all. Interesting.

#4b4ypwa
prologic @twtxt.net
 (3d ago)

This week, Mu (Āµ) get s bit more serious and starts to refactor the native backend (a lot). Soonā„¢ we will support darwin/arm64, linux/arm64 and linux/amd64 (Yes, other forms of BSD will come!) ā€“ Mu (Āµ) also last week grew concurrency support too! šŸ¤£

#4hzbyjq
lyse @lyse.isobeef.org
 (3d ago)

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.

#sczoyta
lyse @lyse.isobeef.org
 (3d ago)

(#2puspya) @movq@www.uninformativ.de Sorry, I meant the builtin module:

$ python3 -m pep8 file.py
/usr/lib/python3/dist-packages/pep8.py:2123: UserWarning: 

pep8 has been renamed to pycodestyle (GitHub issue #466)
Use of the pep8 tool will be removed in a future release.
Please install and use ```pycodestyle` instead.

  $ pip install pycodestyle
  $ pycodestyle ...

I canā€™t seem to remember the name pycodestyle for the life of me. Maybe thatā€™s why I almost never use it.

#2jboz4q
movq @www.uninformativ.de
 (4d ago)

Since I used so much Rust during the holidays, I got totally used to rustfmt. I now use similar tools for Python (black and isort).

What have I been doing all these years?! I never want to format code manually again. šŸ¤£šŸ˜…

#pebgp3a