So, @d6 made something neat. A #uxntal manual page, that contains the full opcode reference with all that's needed to program with it. It saves opening the browser to check the docs, it installs with uxn11.
long shot, but has anybody managed to compile #orca on the playdate? the repo mentions linux env instructions and I totally got stuck on windows. #uxn #uxntal
Still working my way through day 3 of the compudanzas #uxntal tutorial: now drawing on the screen via keyboard input, which is really satisfying.
I kind of took a detour to improve my tools (ebook reading experience in emacs), but now I'm back to hacking. I think I might have enough knowledge to try to build a tiny text editor of some kind?
I created a simple memory management unit for the Uxn VM. It provides support for dynamic memory allocation (malloc/free style), and it's done using a virtual memory approach so to access the allocated memory LDA/STA works.
If anyone's interested, I will explain more. There's a README and a rough draft of a DESIGN doc (linked from the README).
I created a concurrent version of the Uxn VM. It breaks up long-running tasks in chunks, the purpose is to improve responsiveness, in particular of audio. You need to add some code to your .tal to make use of it.
If anyone's interested, I will explain more.
Haven't had time to write up how it works, the current README is just the default Uxn one.
Implemented something like lambdas(fancy word to mean inline anonymous functions) in #Uxntal, it makes some types of code a bit more readable. Here's a little snippet that applies the body of a lambda to each pixels of a 256x256 texture. The body of the lambda is Viznut's code from the Permacomputing paper in the latest Computing Within Limits workshop.
Action at a distance is an anti-pattern in computer science in which behavior in one part of a program modifies operations in another part of the program. I will try to demonstrate how it can be a powerful ally when writing #uxntal if wielded safely.
Implementing structural editing in #uxntal. I remember having lots of fun with THINK Pascal when the IDE was reformatting my program automatically and I've been meaning to have this as part of my workflow now.
For speed-critical loops in #uxntal, consider this pattern:
Use the return-stack to juggle the items needed inside the loop, and if you know how many times the loop needs to run, flatten your boundaries to a single byte(so 0..0x10, becomes 0xf0).
Made a little companion REPL to Left, select a bit of code and press ctrl+p to have it assembled and evaluated in the Bicycle window. It's a good way to learn how #uxntal translates to bytes, and vice-versa.
I haven’t done much with uxn, but I would guess that it is how the command interprets the labels. The labels are just numbers with nice names, so how a command interprets the numbers is up to it.
Added a few notes to the #uxntal page on how to quote/unquote opcodes and functions. "Quoting" here means to defer an operation, as in in, evaluating it later. It's doubles as a little introduction to Uxn's self-modification patterns. http://wiki.xxiivv.com/site/uxntal_immediate.html
I've been working on implementing callable words in #uxntal.
Instead of the typical PUSH->POP->JSR sequence each time you want to run a routine, these tokens are not pushing to the stack - they'll run immediately.
They'll be impractical for doing pointer arithmetic, but save 1 byte for every subroutine call, and will save millions of cycles in a project of the size of a text editor or drawing software.
They don't break compatibility with old roms, and make source files a bit more readable.
There is a subset of #uxntal that is perfectly reversible and that does not generate any loss in entropy, meaning that a step debugger could step backward in time without any loss of information.
I implemented a stack-effect checker last week and I think I might be able to detects linear routines too. Jumping around, self-modification, load/store opcodes will need to stash the entropy loss in a 3rd stack which will allow reversion of non-linear operations.
#Uxn folks, I wrote a spec for Funktal, a functional language I'm working on intended to compile to #Uxntal. Before I go deep down the rabbit hole, I'd value your views on this.
So, Yeti on the #uxntal mailing list discovered a genius way to print inline strings(as opposed to passing a reference to that piece of text), and @tty rewrote it to be this super lean 10 bytes long implementation.
![@dotw ( y* m d -- dotw )
( y -= m < 3; )
OVR STH SWP2 #00 STHr #02 LTH SUB2
STH2
( t[m-1] + d )
#00 ROT ;&t ADD2 LDA #00 SWP
ROT #00 SWP ADD2
( y + y/4 - y/100 + y/400 )
STH2kr
STH2kr #02 SFT2 ADD2
STH2kr #0064 DIV2 SUB2
STH2r #0190 DIV2 ADD2
ADD2
( % 7 )
#0007 DIV2k MUL2 SUB2 NIP
JMP2r
&t 00 03 02 05 00 03 05 01 04 06 02 04](https://keybored.me/photo/preview/640/895750 "@dotw ( y* m d -- dotw )
( y -= m < 3; )
OVR STH SWP2 #00 STHr #02 LTH SUB2
STH2
( t[m-1] + d )
#00 ROT ;&t ADD2 LDA #00 SWP
ROT #00 SWP ADD2
( y + y/4 - y/100 + y/400 )
STH2kr
STH2kr #02 SFT2 ADD2
STH2kr #0064 DIV2 SUB2
STH2r #0190 DIV2 ADD2
ADD2
( % 7 )
#0007 DIV2k MUL2 SUB2 NIP
JMP2r
&t 00 03 02 05 00 03 05 01 04 06 02 04")
