Okay, wow, I hadn't considered a node wildcard(?a) as a kind of arity 
value before, that's really clever. I remember that we explored the idea 
of <> (a .. b) in modal but it slowed down the interpretation enough 
that we disregarded it, but didn't look at it from that angle.

 > this kind of unlimited matching would turn Modal's
program queue into a multiset/bag/inventory. You could say
implement the fruit salad program:

<> (... flour ... sugar ... apples ...)

But modal is still ordered, even if we have length-skipping 
wildcards(..) it wouldn't quite be a bag, the following rule still 
expects a kind of order of nodes even if length-skipping wildcards are

Thanks for clearing that up :)

The reason I brought Fractran is that I think one of my first time 
coming into contact with someone going way into the deep end of the pool 
was with the creator of DawnOS. Who saw the way computation was going 
and wanted to slice through using an OISC of similar scale as fractran.

https://esoteric.codes/blog/a-programming-language-with-only-one-command-and

 > Built on a subleq chip, with subleq a “One Instruction-Set Computer” 
(or OISC), a programming language/architecture with only a single 
command. Geri found its minimalism an antidote to the dystopia of the 
current computing world. He sees chip and OS development as essentially 
political acts in a market dominated by corporate inefficiency.

Thanks Rett!

I'll take your word for it, if someone tells me to shut it, that's on you ;)

Aight, so I'd like to show you something kind of neat, I'm not sure 
where this lands in regards to collapse-computing, but maybe someone has 
a use for this crazy idea.

A couple years back, Conway(rip) presented this programming language 
called Fractran, here's an amazing talk that shows it off somewhat:

https://www.youtube.com/watch?v=548BH-YFT1E

The OISC runtime has 1 operation: multiply.

I was just re-reading James' email about how the collapseOS mailing list 
wasn't conductive to talking about broader topics, I was wondering if 
this was a thing I might have missed or is shared thoughts and 
experiment on the topic still welcome?

I got lots of little experiments that might be interesting to share, 
just wanted to make sure that it was fine to do so and that I haven't 
missed the memo or anything.

I spoke with Tiffany from WIRED about collapse computing today, I know 
she's contacted a couple of folks on here, I made sure to tell her that 
Virgil was working day and night to ensure that we could still make 
spreadsheets after the world caught fire ;)

The SDL version of varvara does screenbuffer changes in the background, 
but for the X11 implementation(which is why I use daily, uxnemu takes 
too much ram for my likes) I do it by hand:

https://git.sr.ht/~rabbits/uxn11/tree/main/item/src/uxn11.c#L251

Maybe this can help you?


On 2024-10-04 08:14, Virgil Dupras wrote:
> On Tue, Sep 24, 2024 at 04:52:53PM -0400, Virgil Dupras wrote:
>> * Activate icache and dcache in the RPi ports. varvara drawing on it is really,
>>    really, really slow and I suspect that it's because of the cache, because on
>>    dusk-sdl on a RPi, it's much faster.

No no, this is not too large at all! This is a fantastic portable 
recipe, I was looking for this the other day, which page did you find 
that on wikipedia btw?

I like that you shared a copy of this recipe here, it's a good primitive 
to have around.

Dll

I like that, I like that divide like Famicom/6502 -> Nova/Vera. The ALU 
and graphics API will be defined as a wrapper around Vera rules, in this 
case(half viznut) a lot of what would otherwise be found in the wider 
computer system of Nova is emulated directly in the CPU.

How far along are you with defining the ALU?

On 2024-10-02 10:47, (wryl) wrote:
> The CPU cost comes, largely, from the fact that we're doing everything in unary. There's no native arithmetic in Vera, apart from built-in rules that we could add, and the only thing Capital's example relies on is the presence of a screen.
> 
> If we swap to binary, or add built-ins for math, things get a ton faster. I'm working on generating rule-sets for doing arithmetic in binary (as well as other bit-based operations).

Wow, that's what I call a tour-de-force.
Does this cpu cost worries you at all for Vera moving forward?

I've been wondering about how inventory languages programming do really 
well at connecting wires together, but are very hard to do front-end 
stuff natively, do you think a different front-end could cut on that 
cost? What would that look like?

Dll

There's this interesting program in rewrite that I keep running into, 
we've called these variances walkers, because the program's output looks 
like little characters walking, and changing places:

A _ _ _ _ B
_ A _ _ _ B
_ _ A _ _ B
_ _ _ A _ B
_ _ _ _ A B
_ _ _ _ A B hey boo!
_ _ _ _ B A
_ _ _ B _ A
_ _ B _ _ A
_ B _ _ _ A

The book doesn't mention anything about the word order, it's just my 
assumption when I see things in sentences that look like tally marks.

Eridians don't have eyes, but they can feel extruded letters, they have 
a base-6 time system with 6 glyphs,that looks like:

ℓ I V λ + V = 0 1 2 3 4 5

The book doesn't go into too much detail, I think the author is trying 
to keep it light.

I remember coming across a paper that explored mapping sentences to 
multisets, like: if you encode "to be or not to be", you'd get something 
like: To be^2 or not to