Notices by Devine Lu Ator (neauoire@merveilles.town)

I've been changing my workflow these past few days from working with textual sources, to using something called structured editing.

Normally you'd think of a program as source code made of text, but in structure programming, you edit the symbols of the program, in this case the bytecode, labels and comments.

I use the textual representation when saving my work, so it can be versioned, but while working anything that is not a bytecode, a symbol or a comment is not recorded.

So a few days I've realized that I very much liked working using structured editing.

Structured editing means that your editor is aware of the program's functioning enough that it handles how it should be presented, so you're not editing text as much as the underlying structure of the program.

It's just a fancy way of saying that it's basically just a symbols aware disassembler.

I've spent the past 2 days improving the UX so I could run the reassembler without going through the terminal.

(the code formatting in the video is all messed up, it's the first time that I manage to connect all 3 parts of together and I was too excited to bother fixing up the syntax parser)

The two hexadecimal editors are:

- left: a rom file(binary blob with the bytecode)
- right: a symbols file(label names and comments)

Assigning a type to a label(just a suffix extension in this case) allows me to display its content in whichever way I need(as opcodes, as letters, as hex bytes, or ..)

@mntmn the shark takes all your shit, only talk to him when you're totally lost.

@mntmn yay! :uxn:

You know what? I think Oquonie is complete.

For the past two months @rek and I ported a game of ours for its 10th years anniversary since iOS updates broke it beyond repair.

It has been rewritten to target a virtual machine, which should(hopefully) help us keeping it playable. In the next few days I'll release a document that explains how to write an emulator to run the game.

get game: https://hundredrabbits.itch.io/oquonie
get emulator: https://100r.co/site/uxn.html
get source: https://git.sr.ht/~rabbits/oquonie

#finishit

@akkartik I'm doing it per-routine at the moment, I'm not looking to doing it at the program scale since there's lots of I/O and optimisations going on.

It finds some routines as linear, others as safe, and most as crazy unsafe. But I would at least be able to rate the different levels of safety in terms of routines. Most routines do away with load/save operations altogether by using only stack opcodes, making it easy to "rasterize".

Still wasting my time experimenting with arity checking in uxntal. I feel like there's something there to explore, but I can't say I really found what it is yet.
https://git.sr.ht/~rabbits/uxnbal/tree/master/item/src/uxnbal.tal

@alcinnz I'm not sure if you like Technical Hitch, but the latest clip(as they always are) is pretty much in line with that concept I find

https://youtu.be/G0dn5Xu0ybk

@wim_v12e I'd just like to say that postfix function declaration looks very nice. At a glance it looks like you're building a cocktail of factor and joy, and I'm here for it.

@sejo is there a repo for the #uxn tutorial? Snufkin on irc is asking if they could make some improvements.

Growing a Language, by Guy Steele
https://www.youtube.com/watch?v=_ahvzDzKdB0

The text editor I use is not smart enough to locate and understand function definitions yet, so I waste a bunch of time going up and down between the definition and where I'm calling the routines.

Until today I had no way to scroll to a definition without moving the cursor. Which meant that each time I jumped to a definition, I had to jump back.

Each day I'd run this through my head "Would I spend more time implementing a scroll-to for markers, than the amount of time I save..?"

Yesterday, I was going on about how I wanted this round-about way of having quick access to definitions without scrolling, sort of like an IDE.

Talking about it gave me the motivation to stop procrastinating on this and just implement the darn thing. Left is now able to locate symbol definitions and its methods and members, and draw them inline.

Improved Left further, by adding different displays for both buffers and methods. This is getting pretty comfy.

I've allocated myself about 100 bytes of implementation space for this whole set of features, and I still have a few bytes left to do things with.

🤔

Medley Interlisp has a cute little 1-bit bitmap editor.
https://interlisp.org/documentation/Medley-Primer.pdf

Finishing up the last details in the Oquonie game, specifically the save/load file format handling.

The game is designed to run on a VM, and will be distributed with a manual that describes exactly how to write an emulator to run the 700kb rom - Our hope is that if platforms change, or if someone want to run it on their own unique system, they need only port the emulator, so the game may survive bit rot.

The entire toolchain including assemblers/linters is hosted on that same virtual machine.

Last night, I was thinking about the Genera scrollbar pattern which is a diagonal stroke that is more dense than what you could normally tile over 8x8 tiles. It turns out it's made of a pattern that tiles over 3 tiles, it's kind of a nice detail.

Wrote an implementation of the pretty Hilbert curve fractal. Since it relies on a sort of value swapping scheme, it lends itself pretty well to stack machines assembly.
https://en.wikipedia.org/wiki/Hilbert_curve